C 指向数组/指针数组的指针消歧

Question

以下声明之间有什么区别：

int* arr1[8];
int (*arr2)[8];
int *(arr3[8]);

理解更复杂声明的一般规则是什么？

Answer 1

int* arr[8]; // An array of int pointers.
int (*arr)[8]; // A pointer to an array of integers

第三个与第一个相同。

一般规则是运算符优先级。 当函数指针出现时，它会变得更加复杂。

Answer 2

按照 K&R 的建议，使用 cdecl 程序。

$ cdecl
Type `help' or `?' for help
cdecl> explain int* arr1[8];
declare arr1 as array 8 of pointer to int
cdecl> explain int (*arr2)[8]
declare arr2 as pointer to array 8 of int
cdecl> explain int *(arr3[8])
declare arr3 as array 8 of pointer to int
cdecl>

反之亦然。

cdecl> declare x as pointer to function(void) returning pointer to float
float *(*x)(void )

Answer 3

我不知道它是否有正式名称，但我称之为 Right-Left Thingy(TM)。

从变量开始，然后向右、向左、向右......等等。

int* arr1[8];

arr1 是一个由 8 个指向整数的指针组成的数组。

int (*arr2)[8];

arr2 是一个指向数组的指针（括号左右） 8 个整数。

int *(arr3[8]);

arr3 是一个由 8 个整数指针组成的数组。

这应该可以帮助您处理复杂的声明。

Answer 4

int *a[4]; // Array of 4 pointers to int

int (*a)[4]; //a is a pointer to an integer array of size 4

int (*a[8])[5]; //a is an array of pointers to integer array of size 5 

Answer 5

后两项的答案也可以从C语言的黄金法则中推导出来：

声明遵循使用。

int (*arr2)[8];

如果取消引用 arr2 会发生什么？ 您将得到一个包含 8 个整数的数组。

int *(arr3[8]);

如果从 arr3 中获取一个元素会发生什么？ 你得到一个指向整数的指针。

这在处理函数指针时也很有帮助。 以 sigjuice 为例：

float *(*x)(void )

当您取消引用 x 时会发生什么？ 您将获得一个可以不带参数调用的函数。 当你调用它时会发生什么？ 它将返回一个指向float的指针。

不过，运算符优先级总是很棘手。 然而，使用括号实际上也可能会造成混淆，因为声明紧随使用。 至少，对我来说，直观上 arr2 看起来像是一个由 8 个指向整数的指针组成的数组，但实际上恰恰相反。 只是需要一些时间来适应。 如果你问我的话，有足够的理由总是向这些声明添加注释:)

编辑：示例

顺便说一句，我刚刚偶然发现了以下情况：一个具有静态矩阵并使用指针的函数算术以查看行指针是否越界。 示例：

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

#define NUM_ELEM(ar) (sizeof(ar) / sizeof((ar)[0]))

int *
put_off(const int newrow[2])
{
    static int mymatrix[3][2];
    static int (*rowp)[2] = mymatrix;
    int (* const border)[] = mymatrix + NUM_ELEM(mymatrix);

    memcpy(rowp, newrow, sizeof(*rowp));
    rowp += 1;
    if (rowp == border) {
        rowp = mymatrix;
    }

    return *rowp;
}

int
main(int argc, char *argv[])
{
    int i = 0;
    int row[2] = {0, 1};
    int *rout;

    for (i = 0; i < 6; i++) {
        row[0] = i;
        row[1] += i;
        rout = put_off(row);
        printf("%d (%p): [%d, %d]\n", i, (void *) rout, rout[0], rout[1]);
    }

    return 0;
}

输出：

0 (0x804a02c): [0, 0]
1 (0x804a034): [0, 0]
2 (0x804a024): [0, 1]
3 (0x804a02c): [1, 2]
4 (0x804a034): [2, 4]
5 (0x804a024): [3, 7]

请注意，border 的值永远不会改变，因此编译器可以对其进行优化。 这与您最初可能想要使用的不同：const int (*border)[3]：它将 border 声明为指向 3 个整数的数组的指针，只要变量存在。 但是，该指针可以随时指向任何其他此类数组。 相反，我们希望参数具有这种行为（因为该函数不会更改任何这些整数）。 使用后声明。

（ps：请随意改进此示例！）

Answer 6

typedef int (*PointerToIntArray)[];
typedef int *ArrayOfIntPointers[];

Answer 7

根据经验，右一元运算符（如 []、() 等）优先于左一元运算符。 因此，int *(*ptr)()[];将是一个指针，它指向一个函数，该函数返回一个指向int的指针数组（一旦获得，请尽快获得正确的运算符）括号外）

Answer 8

我认为我们可以使用简单的规则..

example int * (*ptr)()[];
start from ptr 

“ ptr 是一个指向”的指针
向右走..它的“)”现在向左走它的“(”
出来后向右走“()”所以
” 到一个不带参数的函数“ go left ”并返回一个指针“ go right ”
整数数组“向左”

Answer 9

我是这样解释的：

int *something[n];

关于优先级的注意事项：数组下标运算符 ([]) 的优先级高于
取消引用运算符 (*)。

因此，这里我们将在 * 之前应用 []，使语句等效于：

int *(something[i]);

注意声明的意义：int num 表示 num 是 int，int *ptr 或 int (*ptr) 表示（ptr 处的值）是
int，它使 ptr 成为指向 int 的指针。

这可以理解为，（（某物的第 i 个索引处的值）的值）是一个整数。 因此，(something 的第 i 个索引处的值) 是一个 (整数指针)，这使得该 thing 成为一个整数指针数组。

在第二个中，

int (*something)[n];

为了理解这一说法，您必须熟悉以下事实：

关于数组指针表示的注意事项：somethingElse[i] 相当于 *(somethingElse + i)

因此，将 somethingElse 替换为 ( *something)，我们得到*(*something + i)，根据声明它是一个整数。 因此，(*something) 给了我们一个数组，这使得某些东西相当于（指向数组的指针）。

Answer 10

我想第二个声明让很多人感到困惑。 这是一个简单的方法来理解它。

让我们有一个整数数组，即int B[8]。

我们还有一个指向 B 的变量 A。现在，A 的值为 B，即 (*A) == B。 因此 A 指向一个整数数组。 在你的问题中，arr类似于A。

同样，在int* (*C) [8]中，C是一个指向整数指针数组的指针。

Answer 11

int *arr1[5]

在此声明中，arr1 是一个由 5 个整数指针组成的数组。
原因：方括号的优先级高于 *（解引用运算符）。
在这种类型中，行数是固定的（此处为 5），但列数是可变的。

int (*arr2)[5]

在此声明中，arr2 是指向包含 5 个元素的整数数组的指针。
原因：这里，()括号的优先级高于[]。
在这种类型中，行数是可变的，但列数是固定的（此处为 5）。

Answer 12

在指向整数的指针中，如果指针递增，则它会进入下一个整数。

在指针数组中，如果指针递增，它将跳转到下一个数组