堆上的多维数组-C

我正在学习C语言，并试图创建一个函数，该函数将创建一个字符串数组

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


void parse(char ***aoa)
{
char *string = calloc(9, sizeof(char));        //create a string of size 8+1
strcpy(string, "hi world");                   // put text in that array
char **array = calloc(10, sizeof(char *));    //create an array of strings
aoa = calloc(10, sizeof(char *));             //create and array of arrays
aoa[0] = array;                               //assign string array to the 0th elements of new array
array[0] = string;                            //assign our string to 0th element of string carry
printf("%s\n", aoa[0][0]);                    //print 0th element of 0th array. 
}


int main()
{
char ***array = NULL;
parse(array);
printf("%s\n", array[0][0]);
return 1;
}

#包括
#包括
#包括
无效解析（字符***aoa）
{
char*string=calloc（9，sizeof（char））；//创建一个大小为8+1的字符串
strcpy（字符串，“hi world”）；//将文本放入该数组中
char**array=calloc（10，sizeof（char*）；//创建一个字符串数组
aoa=calloc（10，sizeof（char*）；//创建和数组
aoa[0]=数组；//将字符串数组分配给新数组的第0个元素
数组[0]=string；//将字符串分配给字符串进位的第0个元素
printf（“%s\n”，aoa[0][0]）；//打印第0个数组的第0个元素。
}
int main（）
{
字符***数组=NULL；
解析（数组）；
printf（“%s\n”，数组[0][0]）；
返回1；
}

aoa（数组数组数组）位于堆上，因此这两种方法的aoa应该相同。它确实在解析函数中打印“hi-world”，但在main中给出了分段错误，我的代码有什么问题

---

显然，我需要释放（）所有内容并进行错误检查，但我删除了它以显示问题的要点

您从未在函数内部取消引用

aoa

，因此您只需覆盖参数的局部值。函数参数在C中按值传递。您也不需要全部定位两个字符串数组，这似乎不正确。

如果在

parse（）

中为局部变量保留空间，则需要从

main

传递指向

array

的指针，然后在函数内部取消引用：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void parse(char ****aoa)
{
    char *string = calloc(9, sizeof(char));        //create a string of size 8+1
    strcpy(string, "hi world");                   // put text in that array
    char **array = calloc(10, sizeof(char *));    //create an array of strings
    *aoa = calloc(10, sizeof(char *));             //create and array of arrays
    *(aoa[0]) = array;                               //assign string array to the 0th elements of new array
    array[0] = string;                            //assign our string to 0th element of string carry
    printf("%s\n", *(aoa[0][0]));                    //print 0th element of 0th array. 
}


int main()
{
    char ***array = NULL;
    parse(&array);
    printf("%s\n", array[0][0]);
    return 1;
}

#包括
#包括
#包括
无效解析（字符****aoa）
{
char*string=calloc（9，sizeof（char））；//创建一个大小为8+1的字符串
strcpy（字符串，“hi world”）；//将文本放入该数组中
char**array=calloc（10，sizeof（char*）；//创建一个字符串数组
*aoa=calloc（10，sizeof（char*）；//创建和数组
*（aoa[0]）=array；//将字符串数组分配给新数组的第0个元素
数组[0]=string；//将字符串分配给字符串进位的第0个元素
printf（“%s\n”，*（aoa[0][0]）；//打印第0个数组的第0个元素。
}
int main（）
{
字符***数组=NULL；
解析（&数组）；
printf（“%s\n”，数组[0][0]）；
返回1；
}

不幸的是，问题在于你的主要问题。您将变量数组作为值发送给parse函数，因此，parse不会更改它，并且在MAIN中保持NULL。函数解析的原型应该是

void parse(char ****aoa)

你应该像这样把它发送到main：

parse(&array)

但是你把代码复杂化了。尝试在别处启动数组数组，而不是在函数中传递指向它的指针。例如：

char ***getArray(void)
{
char ***ret;                                   //the array you return
char *string = calloc(9, sizeof(char));        //create a string of size 8+1
strcpy(string, "hi world");                   // put text in that array
char **array = calloc(10, sizeof(char **));    //create an array of strings
ret = calloc(10, sizeof(char ***));             //create and array of arrays
ret[0] = array;                               //assign string array to the 0th elements of new array
array[0] = string;                            //assign our string to 0th element of string carry
return (ret);
}


int main()
{
char ***array = getArray();
printf("%s\n", array[0][0]);
return (0);
}

---

顺便说一句，请始终验证您的分配没有失败。

有一条合理的经验法则，即如果您发现自己需要两个以上的间接寻址级别，那么您的程序设计是糟糕的。（“三星级节目”）

您还使用基于指针的查找表，而不是数组。这会导致分段，并阻止您将分配的结果视为连续内存块

除此之外，您的代码还有几个其他问题。 我会考虑从头开始重写，而实际上是使用多维数组。以下是一个工作示例：

#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>

bool create_string_array2d (size_t x, 
                            size_t y, 
                            size_t max_length, 
                            char (**string_array)[x][y][max_length]);

void print_string_array2d (size_t x,
                           size_t y,
                           size_t max_length,
                           char string_array[x][y][max_length]);

static void fill_with_junk (size_t x,
                            size_t y,
                            size_t max_length,
                            char string_array[x][y][max_length]);

int main()
{
  const size_t X = 9;
  const size_t Y = 10;
  const size_t MAX_CHARS = sizeof("hi world xx yy");

  char (*array)[X][Y][MAX_CHARS];
  bool result;

  result = create_string_array2d(X, Y, MAX_CHARS, &array);

  if(result == false)
  {
    printf("out of memory, halt & catch fire");
    return 0;
  }

  fill_with_junk(X, Y, MAX_CHARS, *array);

  print_string_array2d(X, Y, MAX_CHARS, *array);

  free(array);

  return 0;
}


bool create_string_array2d (size_t x, 
                            size_t y, 
                            size_t max_length, 
                            char (**string_array)[x][y][max_length])
{
  *string_array = calloc(1, sizeof(char[x][y][max_length]));

  return string_array != NULL;
}

void print_string_array2d (size_t x,
                           size_t y,
                           size_t max_length,
                           char string_array[x][y][max_length])
{
  for(size_t i=0; i<x; i++)
  {
    for(size_t j=0; j<y; j++)
    {
      printf("%s\n", string_array[i][j] );
    }
    printf("\n");
  }
}

static void fill_with_junk (size_t x,
                            size_t y,
                            size_t max_length,
                            char string_array [x][y][max_length])
{
  for(size_t i=0; i<x; i++)
  {
    for(size_t j=0; j<y; j++)
    {
      char junk [sizeof("hi world xx yy ")] = "hi world ";
      char num  [sizeof("xx ")];
      sprintf(num, "%.2d ", (int)i);
      strcat(junk, num);
      sprintf(num, "%.2d", (int)j);
      strcat(junk, num);

      strcpy(string_array[i][j], junk);
    }
  }
}

#包括
#包括
#包括
#包括
bool创建字符串数组2d（大小x，
尺寸，
尺寸t最大长度，
字符（**字符串数组）[x][y][max_长度]；
无效打印字符串数组2D（尺寸x，
尺寸，
尺寸t最大长度，
字符字符串_数组[x][y][max_长度]；
用垃圾填充静态空隙（尺寸为x，
尺寸，
尺寸t最大长度，
字符字符串_数组[x][y][max_长度]；
int main（）
{
常数大小X=9；
常数大小Y=10；
const size_t MAX_CHARS=sizeof（“hi world xx yy”）；
字符（*数组）[X][Y][MAX_CHARS]；
布尔结果；
结果=创建字符串数组2d（X、Y、最大字符数和数组）；
如果（结果==false）
{
printf（“内存不足，停止并着火”）；
返回0；
}
用_垃圾填充_（X，Y，MAX_字符，*数组）；
打印字符串数组2d（X，Y，最大字符，*数组）；
自由（数组）；
返回0；
}
bool创建字符串数组2d（大小x，
尺寸，
尺寸t最大长度，
字符（**字符串数组）[x][y][max\u长度]）
{
*string_array=calloc（1，sizeof（char[x][y][max_length]）；
返回字符串_数组！=NULL；
}
无效打印字符串数组2D（尺寸x，
尺寸，
尺寸t最大长度，
字符字符串（数组[x][y][max\u长度]）
{
对于（size_t i=0；i是什么阻止您为10x10数组分配100并将其用作10x10数组？事实上，我稍后会为所选字符串数组动态重新分配空间。3x3示例：最初看起来是这样的：{{hi，my，name}，{one，two，three}，{red，green，blue}。但稍后我可能需要将其更改为：{{hi，my，name，is，Alex}，{one，two}，{cyan，洋红，yellow，key}}}char**数组不是多维数组，this=>>char数组[SIZE][SIZE]是多维数组。