Question

我有一个char * [] []，我需要清空它，并且不时地制作一个新的，但我不知道如何一遍又一遍地重新初始化它

我试过

args = malloc(sizeof(char*[20][250])*20);

和

args = malloc(sizeof(char***)*20);

但我仍然无法重新启动数组。数组真的是20 X 250，可能是char *作为元素吗？

如何迭代* [20] [250]类型的char数组？

这是针对execv的，将像这样使用

for(int i =0 ;i< maxArgs;i++){
    execv(args[i][0],args[i]);
    ERROR("failed to start");
}

Answer 1

后缀运算符的优先级始终高于前缀，所以当你说

时

char*[20][250]

你得到一个包含20个指向字符的20个数组的数组。您可以使用括号更紧密地绑定*：

char (*)[20][250]

表示指向20个250个字符阵列的数组的指针。所以，如果你有

char (*args)[20][250];

你可以使用

args = malloc(sizeof(char [20][250]));

Answer 2

如果args被声明为：

char* args[20][250];

您可以使用以下命令为该数组的每个项目分配内存：

for (int i = 0; i < 20; ++i )
{
   for ( int j = 0; j < 250; ++j )
   {
      args[i][j] = malloc(sizeof(*args[i][j])*(SIZE_OF_STRING+1));
   }
}

如果args被声明为：

char*** args;

您需要再进行几次malloc来电。

第1步

为arg分配内存。

args = malloc(sizeof(*args)*20);

第2步

为args[0] - args[19]分配内存。

for (int i = 0; i < 20; ++i )
{
   args[i] = malloc(sizeof(*args[i])*250);
}

第3步

为args[0][0] - args[19][249]分配内存。

for (int i = 0; i < 20; ++i )
{
   for ( int j = 0; j < 250; ++j )
   {
      args[i][j] = malloc(sizeof(*args[i][j])*(SIZE_OF_STRING+1));
   }
}

合并

args = malloc(sizeof(*args)*20);
for (int i = 0; i < 20; ++i )
{
   args[i] = malloc(sizeof(*args[i])*250);
   for ( int j = 0; j < 250; ++j )
   {
      args[i][j] = malloc(sizeof(*args[i][j])*(SIZE_OF_STRING+1));
   }
}

Answer 3

为了清楚起见，当你需要一个char*[20][250]类型的二维数组时，你在C语言中要求的是一个20个元素的char*[250]数组，每个数组都是一个250个元素的char * C-strings 数组（每个都是char s的数组。

因为动态分配的2D数组不是单个内存区域，而是指向其他数组的指针数组，所以不能一步完成¹。能够做你想做的分配看起来像这样：

char ***args;

args = malloc(sizeof(char**[20]));
for (int i = 0; i < 20; ++i) {
    args[i] = malloc(sizeof(char*[250]));

    // optional, depending on your usage:
    for (int j = 0; j < 20; ++j)
        args[i][j] = ""; // This makes every `char *` element point to the same location in memory— the location of the compiled-in `""` / `(char *){ '\0' }`.
}

要释放内存，请将调用与malloc代码相同，但采用反向分层顺序：

for (int i = 0; i < 20; ++i)
    free(args[i]);
free(args);

_{¹好的，所以在技术上可以将它分配为一个大blob，然后将20个元素的数组连接起来指向blob中所需的偏移量。虽然这通常并不是必需的，但对于大多数用例来说，性能增益可以忽略不计（而且你仍然需要free()一个单独的指针数组，这些指针可以解决这个问题。 2D blob）。当数据是大规模2D时（例如图像数据），您通常只会看到2D-blob分配，并且malloc()访问语法被避免使用data[x][y]语法，因为它的效率不低于编译器的效率，每个blob数据不需要多个data[y * width + x] / malloc对。}

Answer 4

你可以为这样的二维数组声明一个typedef：

    typedef char *array2d_t[20][250];

现在你可以malloc足够的内存来容纳这个2d数组的单个实例：

    array2d_t *array3d = malloc(1 * sizeof(*array3d));

因为指针的行为类似于它们所指向的事物的数组，所以我们实际上有一个3d数组，其第一个维度为arity 1（注意malloc中的1 *），因此第一个索引只能为0。我们可以这样索引它：

    array3d[0][0][0] = "Hello";
    array3d[0][1][0] = "World";
    array3d[0][19][249] = "End of the world!";

或者，如果您愿意，我们可以明确地取消引用指针：

    (*array3d)[0][0] = "Hello";
    (*array3d)[1][0] = "World";
    (*array3d)[19][249] = "End of the world!";

或者，我们可以为这样的1d数组声明一个typedef：

    typedef char *array1d_t[250];

现在可以malloc足够的内存来容纳这个1d数组的20个实例：

    array1d_t *array2d = malloc(20 * sizeof(*array2d));

我们现在无法使用以下内容索引数组：

    array2d[0][0] = "Hello";
    array2d[1][0] = "World";
    array2d[19][249] = "End of the world!";

如何申报char * [20] [250]

4 个答案: