为什么要做以下工作?
void foo() {
cout << "Foo to you too!\n";
};
int main() {
void (*p1_foo)() = foo;
void (*p2_foo)() = *foo;
void (*p3_foo)() = &foo;
void (*p4_foo)() = *&foo;
void (*p5_foo)() = &*foo;
void (*p6_foo)() = **foo;
void (*p7_foo)() = **********************foo;
(*p1_foo)();
(*p2_foo)();
(*p3_foo)();
(*p4_foo)();
(*p5_foo)();
(*p6_foo)();
(*p7_foo)();
}
这里有几个部分允许所有这些运算符的组合以相同的方式工作。
所有这些工作的根本原因是函数(如foo)可以隐式转换为指向该函数的指针。这就是为什么void (*p1_foo)() = foo;Works: foo被隐式转换为一个指向自身的指针,该指针被赋值给p1_foo。
一元&当应用于一个函数时,产生一个指向该函数的指针,就像它应用于一个对象时产生一个对象的地址一样。对于指向普通函数的指针,由于隐式函数到函数指针的转换,它总是冗余的。在任何情况下,这就是void (*p3_foo)() = &foo;的工作原理。
一元*当应用于函数指针时,产生指向函数,就像它应用于指向对象的普通指针时产生指向对象一样。
这些规则可以组合在一起。考虑倒数第二个例子,**foo:
首先,foo被隐式转换为指向自身的指针,第一个*被应用于该函数指针,再次产生函数foo。
然后,结果再次隐式转换为指向自身的指针,并应用第二个*,同样产生函数foo。
然后它再次隐式转换为函数指针并赋值给变量。
你可以添加多少*,结果总是一样的。*越多越快乐。
我们也可以考虑你的第五个例子&*foo:
首先,foo被隐式转换为一个指向自身的指针;应用一元*,再次产生foo。
然后,&被应用于foo,产生一个指向foo的指针,foo被赋值给变量。
不过,&只能应用于函数,而不能应用于已转换为函数指针的函数(当然,除非函数指针是变量,在这种情况下,结果是指针到指针到函数的指针;例如,你可以在列表中添加void (**pp_foo)() = &p7_foo;)。
这就是为什么&&foo不起作用:&foo不是一个函数;它是一个右值函数指针。但是,&*&*&*&*&*& &*foo可以工作,&******&foo也可以,因为在这两个表达式中&总是应用于函数而不是右值函数指针。
还要注意,您不需要使用一元*来通过函数指针进行调用;(* p1_foo) ();和(p1_foo) ();同样的结果,还是因为函数到函数指针的转换。
&和*是在C语言中声明为函数的符号上的幂等运算,这意味着func == *func == &func == *&func,因此*func == **func,但它们有不同的类型,所以你会得到警告。
传递给函数的函数地址的参数类型可以是int()或int(*)(),并且可以传递为*func, func或&func。调用(&func)()与func()或(*func)()相同。Godbolt链接。
* and & have no meaning on a function symbol, and instead of producing an error, the compiler chooses to interpret it as the address of func in both cases. The function does not exist as a separate pointer, like an array symbol, therefore &arr is the same as arr, because it is not a physical pointer with an address at runtime, it's a logical pointer at compiler level. Furthermore *func would read the first byte of the function code, which is an a code section, and rather than produce a compiler error or allow it to be a runtime error segmentation fault, it's just interpreted by the compiler as the address of the function.
声明为函数指针的符号上的&将获得指针的地址(因为它现在是一个实际的指针变量,显示在堆栈或数据部分),而funcp和*funcp仍将被解释为函数的地址。
如果你仍然不太相信@JamesMcNellis的答案,这里有一个证明。这是Clang编译器的AST(抽象语法树)。抽象语法树是编译器内部程序结构的内部表示形式。
void func1() {};
void test() {
func1();
(*func1)();
(&func1)();
void(*func1ptr)(void) = func1;
func1ptr();
(*func1ptr)();
//(&func1ptr)();//error since func1ptr is a variable, &func1ptr is its address which is not callable.
}
AST:
//func1();
|-CallExpr //call the pointer
| `-ImplicitCastExpr //implicitly convert func1 to pointer
| `-DeclRefExpr //reference func1
//(*func1)();
|-CallExpr //call the pointer
| `-ImplicitCastExpr //implicitly convert the funtion to pointer
| `-ParenExpr //parentheses
| `-UnaryOperator //* operator get function from the pointer
| `-ImplicitCastExpr //implicitly convert func1 to pointer
| `-DeclRefExpr //reference func1
//(&func1)();
|-CallExpr //call the pointer
| `-ParenExpr //parentheses
| `-UnaryOperator //& get pointer from func1
| `-DeclRefExpr //reference func1
//void(*func1ptr)(void) = func1;
|-DeclStmt //define variable func1ptr
| `-VarDecl //define variable func1ptr
| `-ImplicitCastExpr //implicitly convert func1 to pointer
| `-DeclRefExpr //reference func1
//func1ptr();
|-CallExpr //call the pointer
| `-ImplicitCastExpr //implicitly convert func1ptr to pointer
| `-DeclRefExpr //reference the variable func1ptr
//(*func1ptr)();
`-CallExpr //call the pointer
`-ImplicitCastExpr //implicitly convert the function to pointer
`-ParenExpr //parentheses
`-UnaryOperator //* get the function from the pointer
`-ImplicitCastExpr //implicitly convert func1ptr to pointer
`-DeclRefExpr //reference the variable func1ptr
这里有几个部分允许所有这些运算符的组合以相同的方式工作。
所有这些工作的根本原因是函数(如foo)可以隐式转换为指向该函数的指针。这就是为什么void (*p1_foo)() = foo;Works: foo被隐式转换为一个指向自身的指针,该指针被赋值给p1_foo。
一元&当应用于一个函数时,产生一个指向该函数的指针,就像它应用于一个对象时产生一个对象的地址一样。对于指向普通函数的指针,由于隐式函数到函数指针的转换,它总是冗余的。在任何情况下,这就是void (*p3_foo)() = &foo;的工作原理。
一元*当应用于函数指针时,产生指向函数,就像它应用于指向对象的普通指针时产生指向对象一样。
这些规则可以组合在一起。考虑倒数第二个例子,**foo:
首先,foo被隐式转换为指向自身的指针,第一个*被应用于该函数指针,再次产生函数foo。
然后,结果再次隐式转换为指向自身的指针,并应用第二个*,同样产生函数foo。
然后它再次隐式转换为函数指针并赋值给变量。
你可以添加多少*,结果总是一样的。*越多越快乐。
我们也可以考虑你的第五个例子&*foo:
首先,foo被隐式转换为一个指向自身的指针;应用一元*,再次产生foo。
然后,&被应用于foo,产生一个指向foo的指针,foo被赋值给变量。
不过,&只能应用于函数,而不能应用于已转换为函数指针的函数(当然,除非函数指针是变量,在这种情况下,结果是指针到指针到函数的指针;例如,你可以在列表中添加void (**pp_foo)() = &p7_foo;)。
这就是为什么&&foo不起作用:&foo不是一个函数;它是一个右值函数指针。但是,&*&*&*&*&*& &*foo可以工作,&******&foo也可以,因为在这两个表达式中&总是应用于函数而不是右值函数指针。
还要注意,您不需要使用一元*来通过函数指针进行调用;(* p1_foo) ();和(p1_foo) ();同样的结果,还是因为函数到函数指针的转换。