我应该如何理解这些 C 语法？ [复制]

Question

如下面的代码，函数指针y、z、b的行为相同。即使*x 会被理解为指针x 的数据，&x 也会被理解为指向x 的指针。

typedef void (*func)(void);

void x(void){
    printf("asdsag\n");
    return;
}

int main(int argc, char const *argv[])
{
    func y = *x;
    func z = x;
    func b = &x;
    y();
    z();
    b();
    return 0;
}

现在看看这段代码。

void test(int **p){
    printf("%p\n",p);
    return;
}
int main(int argc, char const *argv[])
{
    int * p[5];
    test(p);
    test(&p);
    return 0;
}

此代码为所有 3 种情况打印相同的指针。 这是上面代码编译后的汇编

main:
    @ args = 0, pretend = 0, frame = 32
    @ frame_needed = 1, uses_anonymous_args = 0
    push    {r7, lr}
    sub sp, sp, #32
    add r7, sp, #0
    str r0, [r7, #4]
    str r1, [r7]
    ldr r3, [r7, #12]
    mov r0, r3
    bl  test
    add r3, r7, #12
    mov r0, r3
    bl  test
    add r3, r7, #12
    mov r0, r3
    bl  test
    movs    r3, #0
    mov r0, r3
    adds    r7, r7, #32
    mov sp, r7
    @ sp needed
    pop {r7, pc}
    .size   main, .-main

似乎他们对所有三种情况都采用相同的r7+#12。

[问题] 对于以上给出的所有信息，我应该如何理解 C99 中的 p,*p,&p？

[信息] 这是使用 gcc-linaro-7.2.1-2017.11-x86_64_arm-linux-gnueabihf 构建的

[更新]@tadman 关于不兼容指针的更新

#include <stdio.h>

void test1(void **p){
    printf("%p\n",p);
    return;
}

void test2(void *p){
    printf("%p\n",p);
    return;
}

int main(int argc, char const *argv[])
{
    void * p[5] = {0};
    test1(p);
    test2(&p);
    return 0;
}

即使-Wall 也没有警告 这是输出：

0x7fff5615bb20
0x7fff5615bb20

P/S 第一种情况我错了，所以我删除它。

Answer 1

不要混淆函数指针和常规指针的间接级别。这是关于 C 标准的一个特别古怪的事情。

§ 6.3.2.1

左值、数组和函数指示符

...

4. 函数指示符是具有函数类型的表达式。除非它是 sizeof 运算符,67) 或一元 & 运算符，类型为“函数返回”的函数指示符 type”被转换为具有“指向函数返回类型的指针”类型的表达式。

强调-

具有“函数返回”类型的函数指示符 type”被转换为具有“指向函数返回类型的指针”类型的表达式。

（提及标准的正确部分，感谢@John Bollinger）

这基本上意味着a、b和c在这里都是一样的

func a = p;
func b = *p;
func c = &p;

它们都可以被视为一个常规函数，并使用(...) 调用。

不过，常规指针的行为有很大的不同 - 就像在你的下一个示例中一样。

int * p[5];
test(*p);
test(p);
test(&p);

所以int* p[5] 声明了一个包含 5 个指针的数组。所以p的类型是int*[5]，p中每个元素的类型（比如p[0]）都是int*。

所以，对于test(*p)，你只是传递了p[0]（因为*(p + 0) == p[0] == *p）——它的类型是int*。从int* 到int** 的转换是未定义的，因此这是一个很大的禁忌。

使用test(&p)，您将传递int*(*)[5] 类型的值。再一次，不同级别的间接 - 而不是函数类型 - 真正的规则适用于此。行为未定义。

test(p) 很好，p，因为类型 int*[5] 衰减为 int**，这是 test 的有效参数

（编辑以反映指针类型的非衰减版本，感谢@John Bollinger）

此外，由于我们谈论的太多未定义的行为，以防您感到困惑。这基本上意味着该行为没有明确定义的结果 - 您可能会在您的 PC 和您的环境中观察到明显定义的东西 - 但不能在全局范围内保证相同的行为。

3.4.3

未定义的行为

在使用不可移植或错误程序结构或错误数据时的行为 本文件无任何要求

Answer 2

在第一种情况下，您有一个函数，如下所示：

typedef void (*f)(void);

void p(void) {
}

int main(int argc, char const *argv[]) {
    func a = p;
    func b = *p;
    func c = &p;
    a();
    b();
    c();

    return 0;
}

所有这三个都有效，因为p 和&p 是同一件事，函数上的& 运算符是可选的，基本上是“什么都不做”运算符。在铿锵声中，至少* 也是一个无操作，没有记录，但似乎是这样。因此，您可以执行 &p 或 *p 或 &*p 或 ****&&**&*p 并得到相同的结果。

在第二种情况下，您有实际数据：

void test(int **p) {
}

int main(int argc, char const *argv[]) {
    int *p[5];

    test(p);  // Valid: int** -> int**
    test(&p); // Invalid: Incompatible pointer int*** -> int**
    test(*p); // Invalid: incompatible pointer int* -> int**

    return 0;
}

第一个是定义的行为，你传递了一个相同的指针类型，所以它可以工作。后两个只是垃圾代码。也许他们会编译，但行为是未定义的。无论他们做什么都是完全随意的。