初始化动态数组

Initialize dynamic array

本文关键字：数组 动态 初始化      更新时间：2023-10-16

>我以这种方式创建了一个动态数组： 

arr = new int*[m];
for(size_t i=0;i<m;++i){
    arr[i]=new int[n];
}

m 和 n 的值是 3，我得到了一个矩阵，每个单元格包含 2 或 1 个矩阵看起来像这样。 

{{2,1,2,1},
{1,2,2,2},
{1,1,1,1},
{2,1,1,2}}

我在 cpp 文件中将数组创建为类的一部分，我可以初始化数组的任何选项，而无需使用包含矩阵的参数，然后使用一个循环遍历矩阵的每个[i][j]并将其复制到动态数组。此外，编写 16 行代码的解决方案并不好，因为数组可能比我放弃的数组大。矩阵不是来自用户的默认数组的输入。那么有什么解决方案可以在不使用循环和不使用包含矩阵的另一个参数的情况下初始化数组吗？

在 C++11 中，您可能有：

int **arr = new int*[4];
arr[0] = new int[4]{2,1,2,1};
arr[1] = new int[4]{1,2,2,2};
arr[2] = new int[4]{1,1,1,1};
arr[3] = new int[4]{2,1,1,2};

现场示例

但我强烈建议std::array（现场示例）或std::vector

如果您使用此代码，则m和n为 3：

arr = new int*[m];
for(size_t i=0; i < m; ++i) {
    arr[i]=new int[n];
}

然后你最终会得到一个矩阵，里面充满了未初始化的值，你不能确定你将在每个单元格中拥有的值。前提是您将代码更改为：

arr = new int*[m];
for(size_t i=0; i < m; ++i) {
    arr[i]=new int[n];
    memset( arr[ i ], 0, sizeof( int ) * n ); 
}

然后，矩阵将是 3x3 矩阵：

{ { 0, 0, 0 }
  { 0, 0, 0 }
  { 0, 0, 0 } }

好的，现在，如何在初始化时避免使用 for 循环？我们可以使用与上面相同的技巧，使用 memset() ，并将数组分配在一个大块中。

struct Array {
    int * v;
    int rows;
    int cols;
};
Array * createArray(int rows, int cols)
{
    const int Length = rows * cols;
    Array * toret = new Array;
    toret.v = new int[ Length ];
    memset( toret, 0, Length );
    toret.rows = rows;
    toret.cols = cols;
    return toret;
}
int getCell(const Array * a, int row, int col)
{
    return a->v[ ( row * a->cols ) + col ];
}

我不确定您实际上是在使用 C 还是C++。在使用C++的情况下，创建一个类而不是具有独立函数的结构会更合适。

class Array {
public:
    Array(int rs, int cs)
         :rows( rs ), cols( cs )
    {
        const int Length = rows * cols;
        v = new int[ Length ];
        memset( v, 0, Length );
    }
    ~Array()
    {
       delete[] v;
    }
    int &cell(int row, int col)
    {
        return v[ ( row * cols ) + col ];
    }
private:
    int * v;
    int rows;
    int cols;
};

希望这有帮助。

相关文章：