在类的私有部分声明数组

Question

我有一个类，该类的部分输入是一个可变长度的向量（称为数据）（假设它的长度为 N）。我已将其包含在函数之后：

    N = data_->size();

在类的私有部分中，我想声明一个数组 double A[N][N];。然而，当我尝试这样做时，我听到一些话

错误：“N 不是类型名称、静态或枚举数”。

如何创建数组 A[N][N]？

抱歉，如果这已经在其他地方解释过，因为我对 C++ 很陌生，所以甚至不知道要寻找什么！

编辑 - 附加代码：

    class foo {     
    public:
        foo (std::vector &data)
    : data(data_)
    {
        N = data_->size();
        M =  /* four times the last member of data (which is a vector of positive integers)*/
    }

    private:
      double A[M][M];

    void foo(void)
    {
      for (std::size_t i=1; i<=M; ++i)
        {
          A[i][i] = 1;
        }
    }
    };

希望这有某种意义......我如何能够定义 A[M][M]？也许对 M 来说这是不可能的，因为 M 是数据的函数。如果M不可能，N也可能吗？

我能想到的一种可能性是我可以将 A 设为 std::vector< std::vector> A 然后将很多 0 或其他内容推入其中，然后修改值...

Answer 1

如果您使用 std::vector 类，则必须在 data_ 类的函数（例如构造函数）中创建向量，使用以下句子：

A = vector<vector<double> >(N, vector<double>(N, 0));

括号的第一个参数是向量的大小，第二是它的数据类型。

抱歉我的英语，我是西班牙人，而且我的英语不是很好。

Answer 2

你不能那样做。数组是类型，必须在编译时知道它们。这包括它们的尺寸。所以你不能将动态数组作为类的一部分。您得到的最接近的东西是指向手动分配的数组的指针，但实际上它本质上是一个 std::vector 。因此，也许最简单的解决方案是只拥有一个向量向量，或者可能是一个大小为 N * N 的向量，您可以按 j + N * i 的步幅访问它。

示例：

std::vector< std::vector<int> > v(N, std::vector<int>(N));

或者：

std::vector< std::vector<int> > v;
//...
v.resize(N, std::vector<int>(N));

访问：v[2][4] = 8;

---

更新： 由于您编辑了答案，您可以编写类似这样的内容来获取 N * 4n 向量，其中 data.back() == n：

std::vector<unsigned int> data = get_data(); // given!

std::vector< std::vector<double> > v(data.size(), std::vector<double>(4 * data.back()));

Answer 3

嗯...这里有几个问题...

• N 和 M 均未声明（在构造函数中或作为 foo 的成员
• ）尝试初始化未声明的成员data（您可能指的是data_(data)，因为语法是member(expression)，而不是表达式(member))
• 构造函数的参数是不完整的类型：它需要是 std::vector<某种类型>;如果你希望它是通用的，你需要使用模板或从 boost 获得一些帮助
• 你没有初始化你声明的唯一成员变量 (A)
• void foo(void) 是一个问题，因为它不是构造函数（没有类型）的正确语法，而是使用类名

让我们构建更接近您想要的内容

从类 foo 开始：

class foo {
};

构造函数采用单个类型参数std::vector

class foo {
public:
  foo(std::vector<double> &data);
};

你想用数据初始化一个成员变量

class foo {
private:
  std::vector<double> data_;
public:
  foo(std::vector<double> &data)
    :data_(data)
  {};
};

此时我会注意到，我通常不会把非-的定义类声明中的简单构造函数，而是在实现文件中，因此我可以将成员变量的声明与构造函数的声明一起放在公共部分下方。但为了简洁起见，我将在这里保留这种方式。

您想要捕获并存储数据的大小

class foo {
private:
  std::vector<double> data_;
  size_t N;
 public:
  foo(std::vector<double> &data)
    :data_(data)
    ,N(data.size())
  {};

};

此时，我们还没有制作出您想要的多维存储，但是现在您需要做出一些有关如何管理存储的决定。如果您使用 Kerrek SB 的方法，这看起来像

class foo {
private:
  std::vector<double> data_;
  size_t N;
  std::vector< std::vector<double> > A;
public:
  foo(std::vector<double> &data)
    :data_(data)
    ,N(data.size())
    ,A()
  {
    A.resize(N);
    for (size_t i=0; i<N; ++i) {
      A[i].resize(N);
    }
  };
};

Answer 4

如果您不想自己管理内存，则需要使用智能指针动态创建它。

double **A;

在构造函数中：

A = new double *[N];
for(i=0;i<N;++i)
{
  A[i] = new double [N];
}

并不是说您必须在析构函数中调用delete，现在要遵守三规则，您必须有一个复制构造函数和一个赋值运算符...这里使用智能指针更好：请参阅 Boost 智能指针帮助页面。