同样，C ++函数指针。关于语法的困惑

Question

在this page上，我找到了一个很好的C ++函数指针示例（以及函子，但是这个问题与函子无关）。以下是该页面上的一些副本。

#include <iostream>

double add(double left, double right) {
  return left + right;
}

double multiply(double left, double right) {
  return left * right;
}

double binary_op(double left, double right, double (*f)(double, double)) {
  return (*f)(left, right);
}

int main( ) {
  double a = 5.0;
  double b = 10.0;

  std::cout << "Add: " << binary_op(a, b, add) << std::endl;
  std::cout << "Multiply: " << binary_op(a, b, multiply) << std::endl;

  return 0;
}

我一般地理解代码，但是有些事情我总是感到困惑。函数binary_op()带有一个函数指针*f，但是当使用它时，例如在第19行binary_op(a, b, add)上，函数符号add被传入，而不是人们想的那样&add作为指针。现在您可能会说这是因为符号add 是的指针；它是与功能add()相对应的代码位的地址。很好，但是这里似乎仍然存在类型差异。函数binary_op()使用*f，这意味着f是指向某物的指针。我传入add，它本身就是代码的指针。 （对吗？）然后为f分配了add的值，这使f成为代码的指针，这意味着f就像{{1 }}，这意味着add的调用应像f一样，确切地说应该如何调用f(left, right)，但是在第12行，它的命名应像add一样，对我来说似乎很对，因为就像编写(*f)(left, right)一样，而(*add)(left, right)不是函数，它是*add指向的代码的第一个字符。 （对吗？）

我知道用以下内容替换add的原始定义也可以。

binary_op()

事实上，这对我来说意义更大，但是原始语法没有我上面解释的那样。

那么，为什么在语法上使用double binary_op(double left, double right, double f(double, double)) { return f(left, right); } 而不是仅仅使用(*f)是正确的？如果符号f本身就是一个指针，那么短语“函数指针”或“函数指针”到底是什么意思？就目前的原始代码而言，当我们编写func时，double (*f)(double, double)是什么一类？指向指针的指针（因为f本身就是指向一些代码的指针）？符号(*f)与add是同一种事物，还是(*f)是同一种事物？

现在，如果这一切的答案是“是的，C ++语法很奇怪，只需记住函数指针语法，不要质疑它。” ，那么我会很不情愿地接受它，但是我真的很想对我在这里的错有一个适当的解释。

我已经读过this question，并且我认为我理解这一点，但是并没有发现它有助于解决我的困惑。我还读过this question，它也无济于事，因为它不能直接解决我的类型差异问题。我可以继续阅读互联网上的信息之海，以找到答案，但是，嘿，那是Stack Overflow的正确选择吗？

Answer 1

这是因为C函数指针是特殊的。

首先，表达式add将衰减为一个指针。就像对数组的引用会衰减为指针一样，对函数的引用也会衰减为函数的指针。

然后，那里有奇怪的东西：

return (*f)(left, right);

  

那么，为什么在语法上使用(*f)而不是仅仅使用f是正确的？

两个都有效，您可以这样重写代码：

return f(left, right);

这是因为取消引用运算符将​​返回对函数的引用，并且对函数的引用或函数指针都被视为可调用的。

有趣的是，函数引用的衰减非常容易，以至于在调用取消引用运算符时它将衰减回指针，从而可以根据需要多次取消引用函数：

return (*******f)(left, right); // ah! still works

Answer 2

  

就目前的原始代码而言，当我们写double (*f)(double, double)时，f是什么一类？

f的类型为double (*)(double, double)，即它是指向类型为double(double,double)的函数的指针。

  

因为(*f)本身就是一个指针

不是。

问：通过指针间接进行操作（例如在*f中）时，您会得到什么？答：您会得到一个左值参考。例如，给定对象指针int* ptr，表达式*ptr的类型为int&，即对int的左值引用。

对于函数指针也是如此：当您通过函数指针间接访问时，您将获得指向所指向函数的左值引用。对于*f，类型为double (&)(double, double)，即对类型为double(double,double)的函数的引用。

  

符号add是和(*f)一样的东西，还是f是吗？

不合格的id表达式add与*f的含义相同，即它是一个左值：

  

标准草案[expr.prim.id.unqual]

     

...如果实体是函数，则表达式为左值...

---

  

传入了函数符号add，而不是传入它的指针&add。现在您可能会说这是因为符号add是一个指针；

不。那不是原因。

add不是指针。它是一个左值。但是函数类型的左值会隐式转换为指针（这称为衰减）：

  

标准草案[转换功能]

     

可以将函数类型T的左值转换为“指向T的指针”的前值。结果是指向该函数的指针。

因此，以下在语义上是等效的：

binary_op(a, b,  add); // implicit function-to-pointer conversion
binary_op(a, b, &add); // explicit use of addressof operator

---

  

那么，为什么在语法上使用(*f)而不是仅仅使用f呢？

事实证明，调用函数左值与调用函数指针具有相同的语法：

  

标准草稿[expr.call]

     

函数调用是一个后缀表达式，后跟括号，其中包含可能为空的逗号分隔的初始化程序子句列表，这些子句构成了函数的参数。   后缀表达式应具有函数类型或函数指针类型。   对于非成员函数或静态成员函数的调用，后缀表达式应为引用函数的 lvalue （在这种情况下，函数到指针的标准转换为[[ conv.func]）在后缀表达式上被抑制），或具有函数指针类型。

这些都是相同的函数调用：

add(parameter_list);    // lvalue
(*f)(parameter_list);   // lvalue

(&add)(parameter_list); // pointer
f(parameter_list);      // pointer

---

P.S。这两个声明是等效的：

double binary_op(double, double, double (*)(double, double))
double binary_op(double, double, double    (double, double))

这是由于以下规则，它与隐式衰减到函数指针互补：

  

标准草稿[dcl.fct]

     

使用以下规则确定函数的类型。   每个参数（包括功能参数包）的类型由其自己的decl-specifier-seq和声明符确定。   确定每个参数的类型后，将“ T的数组”类型的任何参数或函数类型T的调整为“指向T的指针” ...

Answer 3

首先，当编译器确定参数的类型时，将指定为函数声明的函数参数调整为指向该函数的指针。因此，例如下面的函数声明

void f( void h() );
void f( void ( *h )() );

是等效的，并且声明相同的一个函数。

请考虑以下演示程序

#include <iostream>

void f( void h() );
void f( void ( *h )() );

void h() { std::cout << "Hello Ray\n"; }

void f( void h() ) { h(); }

int main()
{
    f( h );
}

从c ++ 17 Standard（11.3.5函数）开始：

  

5使用以下规则确定函数的类型。的   每个参数的类型（包括功能参数包）为   由自己的decl-specifier-seq和声明符确定。后   确定每个参数的类型，“数组”类型的任何参数   T或功能类型T调整为“指向T的指针”。

另一方面，根据C ++ 17标准

  

9如果给定参数没有参数，则参数为   以接收函数可以获取值的方式传递   通过调用va_arg（21.11）来确定参数。 [注意：本段   不适用于传递给函数参数包的参数。   在模板实例化期间扩展功能参数包   （17.6.3），因此当   函数模板专业化实际上是被调用的。 —尾注]   左值到右值（7.1），数组到指针（7.2）和函数到指针（7.3）   对参数表达式执行标准转换

那么这两个声明有什么区别

void f( void h() );
void f( void ( *h )() );

对于第一个声明，您可以像在函数指针的typedef中那样考虑函数体内的参数h。

typedef void ( *H )();

例如

#include <iostream>

void f( void h() );
void f( void ( *h )() );

void h() { std::cout << "Hello Ray\n"; }


typedef void ( *H )();

void f( H h ) { h(); }

int main()
{
    f( h );
}

根据C ++ 17标准（8.5.1.2函数调用）

  

1函数调用是后缀表达式，后跟括号   包含一个可能为空且以逗号分隔的列表   构成函数参数的初始化子句。   后缀表达式应具有函数类型或函数指针   输入。

因此，您也可以将函数定义为

void f( void h() ) { ( *h )(); }

甚至喜欢

void f( void h() ) { ( ******h )(); }

因为当将运算符*应用于函数名称时，该函数名称会隐式转换为该函数的名称。