在类中动态分配对象指针的2D数组

Dynamically allocating a 2D array of object pointers in a class

本文关键字：2D 数组 指针 对象 动态分配      更新时间：2023-10-16

我目前正在为在运行时动态分配数组的想法而挣扎。来自Java，习惯于只在类骨架中声明数组，只需要实现中的大小。

这就是我发现的动态分配2D阵列的方法：

Grid.h   
Block** grid;
Grid.cpp
grid = new Block*[size]
for(int i = 0 ; i < size ; i++)
    grid[i] = new Block[size]

这工作得很好，尽管在处理对象时，我一直被告知使用指向对象的指针而不是存储对象本身在性能方面要好得多。因此，当我尝试制作数组的第二维度指针时，指针是这样的：

Grid.cpp
grid = new Block*[size]
    for(int i = 0 ; i < size ; i++)
        grid[i] = new Block*[size];

当我把代码改成这个时，我得到了一个错误：

error: assigning to 'Block *' from incompatible type 'Block **'; dereference with *
        grid[i] = new Block* [size];
                ^ ~~~~~~~~~~~~~~~~~
                  *

作为C++做事方式的新手，有人能告诉我我做错了什么吗？或者即使我试图做完全错误的事情？

提前感谢！

我不建议你写这种类型的代码，但如果你仍然想破解你的方法，你可以做这样的事情：-

int main()
{
Block*** grid;      
grid = new Block**[10];         
for(int i = 0 ; i < 10 ; i++)
{       
    grid[i] = new Block*[10];   
}
/*Here, we have created a grid of pointers*/
/*
|Block**[10]|
|Block[0] **|------------->|Block* [10]|
|Block[1] **|------------->|Block* [10]|
|Block[2] **|------------->|Block* [10]|
|Block[3] **|------------->|Block* [10]|
..
..
|Block[9] **|------------->|Block* [10]|
*/
for(int i = 0 ; i < 10 ; i++)
{       
    for(int j = 0 ; j < 10 ; j++)
    {
        grid[i][j] = new Block[10]; 
    }
}
/*
|Block**[10]|
|Block[0] **|------------->|Block* [0]|------------->|Block1|Block2| .. |Block10|
                           |Block* [1]|------------->|Block1|Block2| .. |Block10|
                           |Block* [2]|------------->|Block1|Block2| .. |Block10|
                           ..
                           |Block* [9]|------------->|Block1|Block2| .. |Block10|

|Block[1] **|------------->|Block* [0]|------------->|Block1|Block2| .. |Block10|
                           |Block* [1]|------------->|Block1|Block2| .. |Block10|
                           |Block* [2]|------------->|Block1|Block2| .. |Block10|
                           ..
                           |Block* [9]|------------->|Block1|Block2| .. |Block10|          
|Block[2] **|
|Block[3] **|
..
..
|Block[9] **|
*/
 }

动态2D数组是指向数组的指针数组。您应该首先初始化指针数组，然后使用循环初始化其他数组。

这里有一个使用int创建数组的例子[rowCount][colCount]：

int** array = new int*[rowCount];
for(int i = 0; i < rowCount; ++i)
    array[i] = new int[colCount];

否则，当然可以使用在堆栈上始终有一个2D阵列

int array[rowCount][colCount];

使用二维数组的线性表示：

std::unique_ptr<int[]> array(new int[rowCount*colCount]);
for (size_t r = 0; r < rowCount; r++)
  for (size_t c = 0; c < colCount; c++)
    (array.get())[r*colCount + c] = r*c;

指针数组的遍历也可以用线程安全的方式完成：

size_t allocatedRows = rowCount;
        try{
            array = new char*[allocatedRows];
            while(allocatedRows){
                --allocatedRows;
                array[allocatedRows] = new char[colCount];
            }
        }catch(std::bad_alloc& ex){
            while(++allocatedRows < lines)
                delete array[allocatedRows];
            delete array;
            throw;
        }

在上面的代码中有两件事需要注意：
1） allocatedRows在[]运算符中未递减，因为行为未定义
2） 在分配了指针数组之后，取消引用数组元素会有未定义的行为（就像没有赋值的普通指针一样）。还请记住，在上述情况下，我没有从bad_alloc中恢复，我只是重新划船，它可以在呼叫终止之前记录在其他地方。如果您想从其他用户定义的对象创建指针数组，可以使用std:：uninitialized_copy或std:：uninitialized_fill。另一种方法就是使用矢量。

相关文章：