C++ 如何在类内初始化动态数组？

我希望初始化类中的多维动态数组。但是，我得到了一个错误

我在网上看到了几个例子。他们似乎很难。我不熟悉编码。如果可能的话，我想要一个简单的解决方案

class myp
{
    int ntc = 5;
    public:
    double** y = new double*[ntc];
    for(int i = 0; i < ntc; ++i)
        y[i] = new int[3];
};
int main()
{
    int x;
    myp mp;
    mp.y[1][1] = 3;
    cout<<mp.y[1][1]<<endl;;
    return 0;
}

test.cpp:12:2: error: expected unqualified-id before ‘for’
  for(int i = 0; i < ntc; i++)
  ^~~
test.cpp:12:17: error: ‘i’ does not name a type
  for(int i = 0; i < ntc; i++)
             ^
test.cpp:12:26: error: ‘i’ does not name a type
  for(int i = 0; i < ntc; i++)

类myp
{
int ntc=5；
公众：
双精度**y=新双精度*[ntc]；
对于（int i=0；icout您需要在构造函数中进行类初始化，在析构函数中进行清理

class myp
{
  int m_numColumns;
  int m_numRows;
  double** y;
public:

  // overload array operators
  double* operator [] (size_t row) { return y[row]; }
  const double* operator [] (size_t row) const { return y[row]; }

  // return dimensions of array
  int numColumns() const { return m_numColumns; }
  int numRows() const { return m_numRows; }

  // constructor
  myp(int nc, int nr) : m_numColumns(nc), m_numRows(nr)
  {
    y = new double*[m_numRows];

    for(int i = 0; i < m_numColumns; ++i)
      y[i] = new int[m_numColumns];
  }

  // destructor
  ~myp()
  {
    for(int i = 0; i < m_numColumns; ++i)
      delete [] y[i];
    delete [] y;
  }

  // be careful of the copy ctor. I'm deleting it in this case!
  myp(const myp&) = delete;

  // edit: as per user4581301's suggestion
  myp() = delete;
  myp(myp&&) = delete; // remove move ctor
  myp& operator = (const myp&) = delete; // remove assignment
  myp& operator = (myp&&) = delete; // remove move assignment
};

int main()
{
   myp mp(5, 3);
   mp[1][1] = 3;
   cout << mp[1][1]<<endl;
   return 0;
}

类myp
{
国际数字列；
国际货币基金组织；
双**y；
公众：
//重载数组运算符
双*运算符[]（大小为行）{返回y[行]；}
const double*运算符[]（size_t row）const{return y[row]；}
//数组的返回维数
int numColumns（）常量{return m_numColumns；}
int numRows（）常量{return m_numRows；}
//建造师
myp（北卡罗来纳州，北卡罗来纳州）：北卡罗来纳州，北卡罗来纳州
{
y=新的双*[m_numRows]；
对于（int i=0；icout您需要在构造函数中进行类初始化，在析构函数中进行清理

class myp
{
  int m_numColumns;
  int m_numRows;
  double** y;
public:

  // overload array operators
  double* operator [] (size_t row) { return y[row]; }
  const double* operator [] (size_t row) const { return y[row]; }

  // return dimensions of array
  int numColumns() const { return m_numColumns; }
  int numRows() const { return m_numRows; }

  // constructor
  myp(int nc, int nr) : m_numColumns(nc), m_numRows(nr)
  {
    y = new double*[m_numRows];

    for(int i = 0; i < m_numColumns; ++i)
      y[i] = new int[m_numColumns];
  }

  // destructor
  ~myp()
  {
    for(int i = 0; i < m_numColumns; ++i)
      delete [] y[i];
    delete [] y;
  }

  // be careful of the copy ctor. I'm deleting it in this case!
  myp(const myp&) = delete;

  // edit: as per user4581301's suggestion
  myp() = delete;
  myp(myp&&) = delete; // remove move ctor
  myp& operator = (const myp&) = delete; // remove assignment
  myp& operator = (myp&&) = delete; // remove move assignment
};

int main()
{
   myp mp(5, 3);
   mp[1][1] = 3;
   cout << mp[1][1]<<endl;
   return 0;
}

类myp
{
国际数字列；
国际货币基金组织；
双**y；
公众：
//重载数组运算符
双*运算符[]（大小为行）{返回y[行]；}
const double*运算符[]（size_t row）const{return y[row]；}
//数组的返回维数
int numColumns（）常量{return m_numColumns；}
int numRows（）常量{return m_numRows；}
//建造师
myp（北卡罗来纳州，北卡罗来纳州）：北卡罗来纳州，北卡罗来纳州
{
y=新的双*[m_numRows]；
对于（int i=0；i
类myp
{
int ntc=5；
公众：
双**y；
void initArray（）
{   
y=新双*[ntc]；
对于（int i=0；i
类myp
{
int ntc=5；
公众：
双**y；
void initArray（）
{   
y=新双*[ntc]；
对于（int i=0；i如果愿意，可以省略删除移动构造函数和移动赋值运算符。如果提供了用户定义的复制构造函数，则不会创建隐式移动构造函数或移动赋值。删除复制构造函数视为提供。是的，但是OP最好意识到可能还有一些方法需要实现如果他们想建立一个完整的2D动态数组类型，请使用nt。同意。这并不意味着从我这里得到太多，旁注：这种矩阵的另一个缺点是它允许像
delete[]myMatrix[x]；
或
myMatrix[x]这样的自毁行为=nullptr；
它也有点慢，因为当与小矩阵一起使用时，指针追逐和由此产生的不良缓存行为。如果愿意，可以省略删除移动构造函数和移动赋值运算符。如果提供了用户定义的副本构造函数，则不会创建隐式移动构造函数或移动赋值。删除copy构造函数算作提供。是的，但是OP最好意识到，如果他们想构建一个完整的2D动态数组类型，可能还有一些方法需要实现。同意。这并不意味着我会说太多，旁注：这种类型的矩阵还有一点不好，那就是它允许像
删除[]myMatrix[x]；
或
myMatrix[x]=nullptr；
它也有点慢，因为指针追逐以及与小矩阵一起使用时产生的不良缓存行为。提供的第一个选项是一个坏主意。它不会破坏并允许创建一个定时炸弹对象。请尽可能推广。此外，人类有一个讨厌的习惯，即锁定在第一个选项是给他们的。如果第一个选项糟糕透顶，他们很有可能会写糟糕的代码。第二个选项忽略了，通常会导致另一个定时炸弹。第三个选项也是如此。最后，答案并不能解释出哪里出了错。第一个选项是一个糟糕透顶的主意。它不会破坏并允许创建一个o这是一个定时炸弹。请尽可能地宣传。此外，人类有一个讨厌的习惯，就是锁定他们给出的第一个选项。如果第一个选项糟糕透顶，他们很可能会编写糟糕的代码。第二个选项忽略了这个选项，通常会导致另一个定时炸弹。第三个选项也是如此。最后，答案无法解释出了什么问题。