c - 如何在 C 程序中声明、定义和调用函数，该函数必须具有 1 )"fill"3D 数组和 2 )"read"3D 字符数组

Question

我是 C 编程新手，我需要任何熟悉 3D 数组并可以通过函数对其进行一些更改的人的帮助。 我在网上找到的所有解释都基于二维数组。我无法理解他们。

我的意思是，我了解指针、函数原型(prototype)(声明)、函数定义以及如何操作一维数据数组的基础知识。

我知道任何函数调用都可以进行本地复制或更改其物理存储中的变量数据，但我无法理解一件事。当您使用 char * 类型参数(数组)调用函数时，您总是输入类似 — void func_name(char * var_name) — 因此，如果您需要更改值，您就这样输入它，当您不需要更改时，您可以在 char * var_name 之前添加 const。 对于 int 和 char 类型的参数，我们还有另一个规则:您必须在 func 原型(prototype)中添加(de？)引用运算符 - *及其定义，如果要更改存储中的变量数据，不需要更改则不必使用它(“获取本地副本”命令)；并且，如果您必须更改变量数据，则必须使用应用于参数的取消引用运算符 & 来调用 func — 例如 void func_name(&var_name); 。

当我的任务是通过特定函数(“填充第一维”、“填充第三维”、“读取第 N 维(本地副本)”命令)操作 3D 数组时，您能否解释一下如何正确操作？我如何编写函数原型(prototype)来更改而不是更改 3D 数组的值？

void func_name(char *array[][][]) — 这是正确的吗？

void func_name( char *(***array) ) — 或者也许像这样？

如果我必须使用每个维度中的元素进行操作，我是否必须创建这样的函数原型(prototype)？ :

void func_name( char *(*array), char *(**array), char *(***array) ) {. . .}

调用3D数组操作函数有什么具体规则吗？或者我只需要像 func_name(var_name); 一样保留它们？

我找到了一些工作代码，它们试图解释如何定义一个以二维数组作为参数的函数，以及如何调用这个仅“读取”二维数组(获取本地副本)的函数。但这段代码并没有让我清楚如何使用函数执行另一个操作(“填充”)以及如何正确编写原型(prototype)。而且，该示例仅具有 int 类型的操作，但我需要 char *..代码:

#include <stdio.h>

const int M = 3;
const int N = 3;

void print(int arr[M][N])
{
    int i, j;
    for (i = 0; i < M; i++)
      for (j = 0; j < N; j++)
        printf("%d ", arr[i][j]);
}


int main()
{
    int arr[][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    print(arr);
    char answer[10];
    printf("ok? : ");
    scanf("%s", answer);
    return 0;
}

最后，我无法清楚地理解这些短语的含义:“指向字符的指针的二维数组”，“指向字符的二维数组的指针”；我无法理解上下文，在哪里使用“指针数组”以及在哪里使用“指向数组的指针”。我头脑中的困惑源于这样一个事实:在函数原型(prototype)和定义中，我们使用 (type-name) * 作为类型，始终将数组作为函数参数。

问题比较多，希望大家帮忙，谢谢!

编辑1:

伙计们，我已经研究了一段时间并得到了一些工作编译，这解决了我的任务。感谢大家的反馈，我的解决方案如下。

解决方案:

#include <stdio.h>

void find(int a, char *name, char *country, char *city, const char (*paaa)[4][100]);
void fill( char (*paaa)[4][100] );

// --------------------------------------------//
int main()
{
  char name[100] = {0}, country[50] = {0}, city[50] = {0};

  char array3D[100][4][100]; // 0 field is for name, 1 - for city, 2 - for country
  char (*paaa)[4][100] = &array3D[0]; // initialize the pointer 'paaa'

  fill(paaa); // fills 12 entries with the same data in each field

  printf("> full array: \n");
  printf("\033[0;34m"); // set text color to blue
  for (int x = 0; x < 12*4; x++) // each entry contains 4 fields of strings, so '12*4' here
  {
    printf("%s", (*paaa)[x]);
  }
  printf("\033[0m"); // reset text color to default

  int a = 0;
  printf("> input entry number(max:11): ");
  scanf("%u", &a);
  printf("\n");

  find(a, name, country, city, paaa); // retrieve each field in variables

  printf("ENTRY No. %u : \n\n", a);
  printf("> Name - %s\n", name);
  printf("> City - %s\n", city);
  printf("> Country - %s\n", country);
  printf("> Good? : ");
  scanf("%u", &a);
  printf("> Done.\n\n");

  return 0;
}
// --------------------------------------------//


void fill( char (*paaa)[4][100] )
{
    char local_name[50] = { " Jacob Goodman \n" };
    char local_city[50] = { " Melbourne \n" };
    char local_country[50] = { " Australia \n" };

    int entries_amount = 12;
    int en = 0, da = 0; //entry, data

    for (en = 0; en < entries_amount ; en++)
    {

          for ( da = 0; local_name[da] != '\0'; da++)
            {
            paaa[en][0][da] = local_name[da];
            }
          for ( da = 0; local_city[da] != '\0'; da++)
            {
            paaa[en][1][da] = local_city[da];
            }
          for ( da = 0; local_country[da] != '\0'; da++)
            {
            paaa[en][2][da] = local_country[da];
            }

    }
}

// takes an entry number,
// reads from 3D-array 3 fields of given entry
// and saves each field to 3 global variables
void find(int a, char *name, char *city, char *country, const char (*paaa)[4][100])
{
  int da = 0;
  for ( da = 0; paaa[a][0][da] != '\0'; da++)
    {
    name[da] = paaa[a][0][da];
    }
  for ( da = 0; paaa[a][1][da] != '\0'; da++)
    {
    city[da] = paaa[a][1][da];
    }
  for ( da = 0; paaa[a][2][da] != '\0'; da++)
    {
    country[da] = paaa[a][2][da];
    }

}

Answer 1

“指向 T 的指针”可用于指向单个 T 变量或指向 T 数组的第一个元素。T 数组的所有元素都可以通过指针访问。

T a;
T arr[3];  // Array [3] of T
T *pa = &a; // Pointer to T
T *parr = &arr[0]; // Pointer to T. Equivalent initializer: T *parr = arr;

*pa = foo;     // will set a = foo;
parr[2] = bar; // will set arr[2] = bar;

pa 和 parr 都是“指向 T 的指针”类型。

“T 的二维数组”是“T 的数组的数组”:

T aa[4][3]; // Array [4] of array [3] of T

aa[0][1] = foo;

“指向 T 的指针数组”可用于模拟 T 的二维数组。每个指针元素都指向其自己的 T 数组，该数组可以动态分配，如下所示:

T *ad[4]; // Array [4] of pointer to T

for (i = 0; i < 4; i++) {
    ad[i] = calloc(3, sizeof (T));
}

ad[0][1] = foo;

“指向 T 数组的指针”可用于访问 T 的二维数组的元素:

T aa[4][3]; // Array [4] of array [3] of T
T (*paa)[3] = aa; // Pointer to array [3] of T. Equivalent initializer: T (*paa)[3] = &aa[0];

paa[0][1] = foo; // will set aa[0][1] = foo;

“指向 T 的指针的指针”可用于访问“指向 T 的指针的数组”的元素:

T arow0[3], arow1[3], arow2[3], arow3[3]; // Each is array [3] of T
T *ad[4] = {arow0, arow1, arow2, arow3}; // Array [4] of pointer to T
T **pad = &ad[0]; // Pointer to pointer to T. Equivalent initializer: T **pad = ad;

pad[0][1] = foo; // will set ad[0][1] = foo; will set arow0[1] = foo;

“T 的 3 维数组”是“T 的数组的数组的数组”:

T aaa[4][3][2]; // Array [4] of array [3] of array [2] of T

“指向 T 的 2 维数组的指针”是“指向 T 的数组的数组的指针”，可用于访问 T 的 3 维数组(具有兼容维度)的元素:

T aaa[4][3][2]; // Array [4] of array [3] of array [2] of T
T (*paaa)[3][2]; // Pointer to array [3] of array [2] of T

paaa = aaa; // Equivalent: paaa = &aaa[0];
paaa[0][1][1] = foo; // will set aaa[0][1][[1] = foo;

“指向 T 的指针的二维数组”是“指向 T 的指针数组的数组”:

T arow00[2], arow01[2], arow02[2]; // Each is array [2] of T
T arow10[2], arow11[2], arow12[2];
T arow20[2], arow21[2], arow22[2];
T arow30[2], arow31[2], arow32[2];
T *app[4][3] = {
      {arow00, arow01, arow02},
      {arow10, arow11, arow12},
      {arow20, arow21, arow22},
      {arow30, arow31, arow32}
    }; // Array [4] of array [3] of pointer to T

app[0][1][1] = foo; // Will set arow01[1] = foo;

“指向指向 T 的指针的指针”可用于访问指向 T 的指针的指针数组的元素:

T arow00[2], arow01[2], arow02[2]; // Each is array [2] of T
T arow10[2], arow11[2], arow12[2];
T arow20[2], arow21[2], arow22[2];
T arow30[2], arow31[2], arow32[2];
T *parow0[3] = { arow00, arow01, arow02 }; // Each is array [3] of pointer to T
T *parow1[3] = { arow10, arow11, arow12 };
T *parow2[3] = { arow20, arow21, arow22 };
T *parow3[3] = { arow30, arow31, arow32 };
T **ppa[4] = { parow0, parow1, parow2, parow3 }; // Array [4] of pointer to pointer to T
T ***pppa = ppa; // Pointer to pointer to pointer to T;

pppa[0][1][1] = foo;
// will set ppa[0][1][1] = foo;
// will set parow0[1][1] = foo;
// will set arow01[1] = foo;