构造对象，其中一个属性依赖于另一个。在 C++ 中

Question

• C++ 初学者

我有课，说

class A
{
  public:

  int N;
  double ..... 
};

但我希望.....根据 N 定义一个大小矩阵。如果改变方法，它是 N 的一个不相同的函数，而不仅仅是 N 本身，比如 N^3+ 1.

• 如果是这种方法，我从未在 C++ 中编写过对象的构造函数。因此，如果这是方法，请您提供一些详细信息。我不明白它是如何工作的。当类被实例化时，可能属性 N 还没有被初始化。
• 我不清楚如何获得在执行中确定的大小的矩阵或数组（我仍然不清楚 C++ 的基本数据类型）。

编辑： N 的值稍后在代码中确定。是这样的：

A InstanceOfA; //The variable InstanceOfA is declared of type A.
...
Some other stuff happens, e.g. other properties of InstanceOfA are initialized 
and some of the functions are used. And then:
...
A.setN(4);

我没有从下面的答案中理解。我需要做吗

A InstanceOfA(4);

?

Answer 1

您可以使用std::vector

class A
{
 public:

 int N; // you should use int for size
 double std::vector<std::vector<double>> matrix; //define the matrix

 //initialize it in the constructor
 A( int size ):N(size), matrix(size*3+3)// or you can use any expression that evaluates an integral value
  {
    //you can initialize the values in matrix here

  }

};

注意

表达式matrix(size*3+3) 初始化矩阵，使得有size*3+3 行，每行中的列数尚未指定。您还可以在构造函数中指定列大小，例如

for( int i=0;i< N*3+3; ++i) //for each row
{
  matrix[i].resize(N*2);// resize each col to hold N*2 cells,
}

编辑

根据有问题的修改，您可以将构造函数留空（或初始化任何其他成员），并在类A 中提供setSize 方法，稍后将初始化大小。

void setSize(int size){
 N= size;
 matrix.resize( size*3+3);
 for( int i=0;i< N*3+3; ++i) //for each row
 { 
  matrix[i].resize(N*2);// resize each col to hold N*2 cells,
 }
}

然后你可以像这样使用它：

A instanceOfA;
//other code
//
instanceOfA.setSize(N);

Answer 2

您可以使用std::vector<std::vector<double>> 来捕获矩阵。另外，将N的类型改为int。

class A
{
  public:

  int N;
  std::vector<std::vector<double>> matrix;
};

定义一个构造函数，并在构造函数中初始化数据。

class A
{
  public:
  A(int n) : N(n)
  {
     int matrixSize = N*N*N+1;
     for (int i = 0; i < matrixSize; ++i )
     {
        matrix.push_back(std::vecotr<double>(matrixSize));
     }
  }

  double N;
  std::vector<std::vector<double>> matrix;
};

Answer 3

一种可能的方法是使用指针。如果你只在构造函数中分配你的数组并且它的大小在你的对象的生命周期内不会改变，那可以通过这种方式完成：

class A
{
  public:
  double N;
  double* arr;
  A(double aN):N(aN)
  { arr = new double[3*N+1]; // allocate your array in constructor
    ...                      // do whatever else you need to initialize your object
  } 
  ...
  ~A() { delete[] arr;} // free it in destructor
  ...
}

另请参阅Dynamic Memory 上的教程。

然后，您将通过以下两种方式之一实例化您的类：

A a(aN); // 这个对象会在超出范围时自动销毁，例如在创建它的函数结束时

A* a = new A(aN);

// 这个对象在不再需要时必须自己删除：

... delete a;

如果你在创建对象的时候还不知道N，可以推迟分配：

class A
{
  public:
  double N;
  double* arr = NULL;
  A() { ... } // do whatever you need in your constructor
  setN(double aN)
  { 
    N = aN;
    arr = new double[3*N+1]; // allocate your array
   } 
  ...
  ~A() { if(arr) delete[] arr;} // free your array in destructor if needed
  ...
}

那么您可以将您的对象称为：

A a;