C语言 将一个3D数组(字符串的2D数组)传递给一个函数并在那里编辑它

Question

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

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

我设法传递了 3D 字符数组，只要我通过数组 [5][5][

5] 和 void 函数（字符数组[5][5][5]）添加简单的字符。但我不能以这种方式添加字符串。我真的很着急。如果您不想回答我的问题，那么只需给我一个解释位置的链接，我会弄清楚的。

编辑：

  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 %sn",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 数组，而第二个版本使用 2D char*数组 ，必须在函数中为您填充矩阵的每个字符串分配这些数组。

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

在POSIX-2008标准中，我们还具有多种字符串处理功能，可生成现成的malloc'd字符串，如strdup()，getline()，asprintf()等。如果您使用这些，则分配字符串以适应的很多麻烦就会消失。