多维字符数组 如何在C++中初始化和取消多维字符数组？ < p>阅读-你会发现你需要的一切！p>

创建：

静态分配：

char mda[ dim1_size ][ dim2_size ]...[ dimn_size ];

Using nested delete[].

动态分配：嵌套

new[]

调用

初始化：

嵌套循环；与您的维度一样多的

联合化：你的意思是毁灭吗

静态分配：当堆栈帧解缠时（或者对于全局变量，当程序停止运行时），编译器会执行此操作

动态分配：

char mda[ dim1_size ][ dim2_size ]...[ dimn_size ];

Using nested delete[].

读一下——你会在那里找到你需要的一切

创建：

静态分配：

char mda[ dim1_size ][ dim2_size ]...[ dimn_size ];

Using nested delete[].

动态分配：嵌套
new[]
调用

初始化：

嵌套循环；与您的维度一样多的

联合化：你的意思是毁灭吗

静态分配：当堆栈帧解缠时（或者对于全局变量，当程序停止运行时），编译器会执行此操作

动态分配：

char mda[ dim1_size ][ dim2_size ]...[ dimn_size ];

Using nested delete[].

您可以像这样初始化多维数组：

int grid[2][3] = {1, 3, 5, 2, 4, 6};

在这种情况下，单独的值应为：

grid[0, 0]: 1
grid[0, 1]: 3
grid[0, 2]: 5
grid[1, 0]: 2
grid[1, 1]: 4
grid[1, 2]: 6

您可以像这样初始化多维数组：

int grid[2][3] = {1, 3, 5, 2, 4, 6};

在这种情况下，单独的值应为：

grid[0, 0]: 1
grid[0, 1]: 3
grid[0, 2]: 5
grid[1, 0]: 2
grid[1, 1]: 4
grid[1, 2]: 6

一个快速的代码片段-它在g++中编译

int rows = 10;
int cols = 10;

char** array = new char*[rows];
for( int i = 0; i < cols; ++i ) {
  array[i] = new char[cols];
}

//do stuff with array

for( int i = 0; i < cols; ++i ) {
  delete array[i];
}
delete array;

int行=10；
int cols=10；
字符**数组=新字符*[行]；
对于（int i=0；i
一个快速代码片段-它用g++编译

int rows = 10;
int cols = 10;

char** array = new char*[rows];
for( int i = 0; i < cols; ++i ) {
  array[i] = new char[cols];
}

//do stuff with array

for( int i = 0; i < cols; ++i ) {
  delete array[i];
}
delete array;

int行=10；
int cols=10；
字符**数组=新字符*[行]；
对于（int i=0；i
这很有趣，需要认真的观察

roo给出的答案是一个广泛使用的答案，但我喜欢他的观察结果——仅仅因为它可以编译并不意味着它可以工作

我认为一个更好的解决方案是分配一个连续的内存块（行*列），然后将其视为一个2D数组？
这很有趣，这需要认真考虑

roo给出的答案是一个广泛使用的答案，但我喜欢他的观察结果——仅仅因为它可以编译并不意味着它可以工作

我认为更好的解决方案是分配一个连续的内存块（行*列），然后将其视为二维数组？
我建议您使用Boost.Multi_数组库。
数组的维度必须在编译时提供，但大小仅在运行时使用。
这意味着您拥有动态分配的优势，而无需处理内存问题

下面是一个例子

int
主要（）{
//创建一个3 x 4 x 2的三维阵列
typedef boost:：multi_array_type；
typedef数组_type:：index索引；
数组_类型A（boost:：extensts[3][4][2]）；
//为元素指定值
int值=0；
对于（索引i=0；i！=3；++i）
对于（索引j=0；j！=4；++j）
对于（索引k=0；k！=2；++k）
A[i][j][k]=值++；
//验证值
int=0；
对于（索引i=0；i！=3；++i）
对于（索引j=0；j！=4；++j）
对于（索引k=0；k！=2；++k）
断言（A[i][j][k]==verify++）；
返回0；
}
我建议您使用Boost.Multi\u阵列库。
数组的维度必须在编译时提供，但大小仅在运行时使用。
这意味着您拥有动态分配的优势，而无需处理内存问题

下面是一个例子

int
主要（）{
//创建一个3 x 4 x 2的三维阵列
typedef boost:：multi_array_type；
typedef数组_type:：index索引；
数组_类型A（boost:：extensts[3][4][2]）；
//为元素指定值
int值=0；
对于（索引i=0；i！=3；++i）
对于（索引j=0；j！=4；++j）
对于（索引k=0；k！=2；++k）
A[i][j][k]=值++；
//验证值
int=0；
对于（索引i=0；i！=3；++i）
对于（索引j=0；j！=4；++j）
对于（索引k=0；k！=2；++k）
断言（A[i][j][k]==verify++）；
返回0；
}
我是用tic-tac趾板学的

const int ROW = 3;
const int COLUMN = 3;
char board [ROW] [COLUMN] = {{'O', 'X', 'O'},
                             {'X', 'X', 'X'},
                             {'X', 'O', 'X'}};

我希望这有帮助
 我是用tic-tac趾板学的

const int ROW = 3;
const int COLUMN = 3;
char board [ROW] [COLUMN] = {{'O', 'X', 'O'},
                             {'X', 'X', 'X'},
                             {'X', 'O', 'X'}};

我希望这有帮助
 取决于语言。什么是不初始化？我必须是盲人，你已经在C++中指定了：作业标签被贬低了，这取决于语言。你是什么意思？我必须是盲人，你已经在C++中指定了：作业标签被弃用。哦，我的天，这太可怕了。这是用C++伪装的C！哦，天哪，这太糟糕了。这是用C++伪装的C！分配一个连续的内存块是很有意思的，但这样做会失去在每个维度上更改数组大小的任何可能性。分配一个连续的内存块是很有意思的，但这样做会失去在每个维度上更改数组大小的任何可能性。