如何声明字符*[20][250]

我有一个字符 * [][]，我需要清空它，时不时地创建一个新一个，但我不知道如何一遍又一遍地重新初始化它

我试过了

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");
}

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

char*[20][250]

你会得到一个由 20 个数组组成的数组，其中包含 250 个指向字符的指针。您可以使用括号更紧密地绑定*：

char (*)[20][250]

表示指向由 20 个数组组成的数组(包含 250 个字符(的指针。所以如果你有

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

您可以使用

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

如果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));
   }
}

需要明确的是，当你想要一个 char*[20][250] 类型的 2D 数组时，你在 C 语言中要求的是一个 20 元素的 char*[250] 数组，每个数组都是一个 250 元素的 char * C 字符串数组(每个数组都是一个 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 *){ '' }`.
}

若要释放内存，请按与 malloc -ing 代码相同的方式构建调用，但按反向层次结构顺序排列：

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

_{¹ 好的，所以在技术上可以将其分配为一个大 blob，然后将 20 个元素的数组连接到 blob 中所需的偏移量。这free()，通常不是必需的 - 对于大多数用例，性能提升可以忽略不计(您仍然需要malloc()一个单独的指针数组，这些指针地址到2D blob中(。通常，仅当数据是大规模 2D 时(例如图像数据(，并且data[x][y]访问语法被避开以支持data[y * width + x]语法时，才会看到 2D-blob 分配，因为它的效率不低于编译器所执行的效率，并且每个 blob 数据不需要一个以上的malloc/free对。}

你可以为 2d 数组声明一个 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!";

相关内容

最新更新

热门标签：