C++ 构造对象，其中一个属性依赖于另一个属性。在C++； 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);

---

？

您可以使用

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

  }

};

编辑

根据所讨论的修改，然后可以将构造函数保留为空（或初始化任何其他成员），并在类

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,
 }
}

---

您可以使用

std:：vector

捕获矩阵。另外，将

N

的类型更改为

int

class A
{
  public:

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

A类
{
公众：
int N；
向量矩阵；
};

定义构造函数并初始化构造函数中的数据

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;
};

A类
{
公众：
A（int n）：n（n）
{
int matrixSize=N*N*N+1；
for（int i=0；i

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

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
  ...
}

另请参见上的教程

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

A（aN）
//当该对象超出范围时，例如在创建该对象的函数结束时，该对象将自动销毁

A*A=新的A（aN）

//当不再需要此对象时，必须自己删除此对象：

。。。
删除一条

如果在创建对象时不知道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
看一下
std:：vector
。它有一个以大小为参数的构造函数。内部向量还需要一个
std:：
此外，如果N是常量，您仍然可以使用向量。我以前从未使用过构造函数。问：当我在main（）中实例化A时，我可以说A InstanceOfA；，或者N必须像在一个实例fa（N）@ABC，如前所述，如果
N
不会从外部确定，则无需在构造函数中传递size参数，您只需将
N
初始化为任何值，并使用它（或涉及它的任何表达式）作为大小。否则，在创建对象时必须将
size
作为参数传递，如
ob（100）
。请注意，
N
成员是多余的，因为向量可以告诉您它自己的大小。我以前从未使用过构造函数。问：当我在main（）中实例化A时，我可以说A InstanceOfA；，或者N必须像在一个实例fa（N）；？我在上面的问题中增加了细节。我认为在声明对象时需要设置N对我的问题不方便。在这种情况下，您可以推迟分配对象，直到您知道N为止。这意味着，您不在构造函数中进行分配，而是在其他函数中进行分配。（参见示例）我以前从未使用过构造函数。问：当我在main（）中实例化A时，我可以说A InstanceOfA；，或者N必须像在一个实例fa（N）@ABC，您必须使用
instanceOfA（N）我在上面的问题中添加了详细信息。我认为在声明对象时需要设置N对我的问题不方便。在知道大小之前，您可以推迟构建
instanceOfA
。它不必在那之前建造。
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
  ...
}

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
  ...
}