C语言 为什么一个函数有多个指针?

Question

我正在做一个相对简单的任务，但我不了解它的更广泛的上下文/应用程序目的:

void ft_multipointer(int *********nbr)
{
*********nbr = 99;
}

1. 在哪种情况下我可以使用/需要这么多指针?
2. 术语nbr是强制性的还是我可以在那里写其他字母顺序?

谢谢!

Answer 1

1. 通常您不需要那么多指针，但您可能想要传递指针或指针到指针。您还可以使用指针来解引用多维数据结构。

2. nbr只是变量名，您可以使用任何其他有效的字母和数字序列。

Answer 2

很少看到超过三层的间接(例如int ***nbr)。我想不出有什么实际情况需要九个间接层次，但我的经验并不是那么广泛。

在几种情况下会出现多级间接性。首先是需要一个函数写入指针类型的形参。假设您有如下内容:

void foo( T *ptr ) // for any type T
{
*ptr = new_T_value(); // write a new value to the thing ptr points to
}
void bar( void )
{
T var;
foo( &var ); // write a new value to var
...
}

我们想让foo更新var的值——要做到这一点，我们必须传递一个指向var的指针。现在让我们将T替换为指针类型P *:

void foo( P **ptr )
{
*ptr = new_Pstar_value(); // or **ptr = new_P_value(), assuming **ptr is valid
}
void bar( void )
{
P *var;
foo( &var );
...
}

的语义是完全相同的，所改变的只是我们想要更新的对象的类型。我们可以更进一步，用另一种指针类型Q *:

代替P:

void foo( Q ***ptr )
{
*ptr = new_Qstarstar_value(); // or ***ptr = new_Q_value(), assuming ***ptr is valid
}
void bar( void )
{
Q **var;
foo( &var );
...
}

等等等等。快速检查语言定义似乎没有指出间接的最大级别，但我可能只是错过了它。当然，你做我做的事情不是为了好玩，你这样做是因为你真的在处理多层次的间接，不管出于什么原因。

当你处理多维数据时，多重间接也会出现。不是使用n维数组，而是动态分配内存——创建指向指针序列的指针，每个指针都指向指针序列，等等:

/**
* Dynamically allocate space for an NxMxL array - error checking
* omitted for brevity.
*/
T ***p = malloc( N * sizeof *p );             // Allocates space for N objects of type T **
for ( size_t i = 0; i < N; i++ )
{
p[i] = malloc( M * sizeof *p[i] );          // Allocates space for M objects of type T *
for ( size_t j = 0; j < M; j++ )
p[i][j] = malloc( L * sizeof *p[i][j] );  // Allocates space for L objects of type T
}

给出了这样的结构:

T ***      T **            T *                     T
+---+      +---+           +---+                  +---+
p: |   | ---> |   | p[0] ---> |   | p[0][0] -------> |   | p[0][0][0]
+---+      +---+           +---+                  +---+
|   | p[1] -+   |   | p[0][1] -----+   |   | p[0][0][1]
+---+       |   +---+              |   +---+
...        |    ...               |    ...
|                      | 
|   +---+              |   +---+
+-> |   | p[1][0] ---+ +-> |   | p[0][1][0]
+---+            |     +---+
|   | p[1][1] -+ |     |   | p[0][1][1]
+---+          | |     +---+
...           | |      ...
| |
| |     +---+
| +---> |   | p[1][0][0]
|       +---+
|       |   | p[1][0][1]
|       +---+
|        ...
| 
|       +---+
+-----> |   | p[1][1][0]
+---+
|   | p[1][1][1]
+---+
...

再一次，在我的经验中，我从来没有见过任何需要超过三个维度来存储的东西，但我的经验并不是那么广泛。可能有一些问题域，你真的有9个独立的数据维度(x = a[i][j][k][l][m][n][o][p][q];)，但我只是没有看到它。