Question

我花了很多时间寻找这个答案，即使我找到了一些类似的答案，似乎没有什么对我有用，让我非常沮丧：/

我想做的很简单。我想在1个函数中创建一个2D字符串数组（字符串的2D数组是字符的3D数组），我想将它传递给另一个函数并在其中编辑它。我很高兴如果1维可以通过动态但我对malloc有太多麻烦，我甚至会接受一个选项，其中所有3个维度都是静态的。只要我可以将引用传递给它来运行，将其填入该函数然后在main中使用它。我正在寻找没有结构的解决方案。

只要我通过数组[5] [5] [5]然后使用void函数（char数组[5] [5] [5]）添加简单的字符，我设法传递3d数组的字符。但我不能这样添加字符串。我真的很着急。如果你不想回答我的问题，那就给我一个链接，解释这个问题，我会弄清楚。

编辑：

  void function(char* array[5][5]) { 
        array[0][0] = malloc(sizeof(char) * 5); array[0][0] = "something" 
    } 

    int main() {
       char* array[5][5]; function(array); printf("%s", array[0][0]); 
    }

Answer 1

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

void doit ( char ***array, int x, int y, int z ) {
   int i,j,k;
   for ( i=0; i<x; i++ ) {
      for ( j=0; j<y; j++ ) {
         snprintf(array[i][j],z,"this is %d/%d",i,j);
      }
   }
}

void main ( int c, char**v ) {
   int i,j,k,x=3,y=5,z=17;
   char ***array = (char***)malloc(sizeof(char**)*x);
   for ( i=0; i<x; i++ ) {
      array[i] = (char**)malloc(sizeof(char*)*y);
      for ( j=0; j<y; j++ ) {
         array[i][j] = (char*)malloc(z);
      }
   }
   doit(array,x,y,z);
   for ( i=0; i<x; i++ ) {
      for ( j=0; j<y; j++ ) {
         printf("%d/%d %s\n",i,j,array[i][j]);
      }
   }
   for ( i=0; i<x; free(array[i++]) ) {
      for ( j=0; j<y; free(array[i][j++]) );
   }
   free(array);
}

使用C ++，可以用更易读的方式实现同样的目标。

Answer 2

简单方法：

void foo(size_t height, size_t width, size_t length, char (*stringMatrix)[width][length]) {
    for(size_t y = 0; y < height; y++) {
        for(size_t x = 0; x < width; x++) {
            for(size_t i = 0; i < length; i++) {
                stringMatrix[y][x][i] = /*whatever*/;
            }
        }
    }
}

int main() {
    size_t height = 5, width = 7, length = 9;

    //use either of the following two lines
    char stringMatrix[height][width][length];
    //char (*stringMatrix)[width][length] = malloc(height * sizeof(*stringMatrix));

    foo(height, width, length, stringMatrix);

    //if you used malloc(), don't forget to free your matrix:
    //free(stringMatrix);
}

更好的方法：

//Fills the matrix with malloc'd strings.
void foo(size_t height, size_t width, char* (*stringMatrix)[width]) {
    for(size_t y = 0; y < height; y++) {
        for(size_t x = 0; x < width; x++) {
            stringMatrix[y][x] = malloc(/* the length that you need for this string */);
            //initialize the string in stringMatrix[y][x]
        }
    }
}

int main() {
    size_t height = 5, width = 7;

    //use either of the following two lines
    char* stringMatrix[height][width];
    //char* (*stringMatrix)[width] = malloc(height * sizeof(*stringMatrix));

    foo(height, width, stringMatrix);

    //Cleanup
    for(size_t y = 0; y < height; y++) {
        for(size_t x = 0; x < width; x++) {
            free(stringMatrix[y][x]);
        }
    }
    //if you used malloc(), don't forget to free your matrix:
    //free(stringMatrix);
}

两种方法都使用真正的多维数组，该数组作为指向数组第一维的第一个元素的指针传递给函数。区别在于，第一个版本使用真正的3D数组，而第二个版本使用char*的2D数组，必须在函数中为每个填充矩阵的字符串分配。

为什么第二版更好？仅仅因为它没有限制你可以处理的字符串的大小。在任何地方使用动态分配的字符串似乎不方便，但事实是几乎每个固定长度的缓冲区都是等待发生的错误。迟早你会得到一个超出限制的用例，你的程序会爆炸。

使用POSIX-2008标准，我们还提供各种字符串处理功能，可生成现成的malloc＆＃d}字符串，如strdup()，getline()，asprintf()等如果你使用这些，很多分配字符串的麻烦就会消失。

将3D数组（字符串的2D数组）传递给函数并在那里编辑它

2 个答案: