在类中动态分配对象指针的二维数组

Question

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

这是我发现动态分配二维数组的方法：

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++ 的做事方式有点陌生，有人能告诉我我做错了什么吗？ 或者即使我试图完全做错事？

提前致谢！

Answer 1

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

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] **|

*/
 }

Answer 2

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

这是一个使用 int 创建数组 [rowCount][colCount] 的示例：

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

否则当然你总是可以通过使用在堆栈上有一个二维数组：

int array[rowCount][colCount];

Answer 3

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

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;

Answer 4

分配指针数组也可以以线程安全的方式完成：

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) 分配行在 [] 运算符中不会递减，因为行为将是未定义的
2) 分配指针数组后，解引用数组元素有未定义的行为（就像没有赋值的普通指针一样）。 还请记住，在上述情况下，我没有从 bad_alloc 中恢复，我只是重新抛出，它可以在调用终止之前记录在其他地方。 如果您想从其他用户定义的对象创建指针数组，您可以使用 std::uninitialized_copy 或 std::uninitialized_fill。 另一种方法是使用向量。