为什么只有指向函数的指针而不是函数的var？

Question

在C/C++中，我们可以声明/定义一个函数指针类型，然后声明/定义一些这种类型的变量。 但我认为这是模棱两可的。

例如：

typedef void ( *pFunc )();
// typedef void ( aFunc )();
void theFunc() {
   cout << "theFunc has been called successfully." << endl;
};

int main() {
   pFunc pf0 = theFunc;
   pFunc pf1 = &theFunc;

   pf0();
   ( *pf0 )();
   pf1();
   ( *pf1 )();
};

理论上只有pFunc pf1 = &theFunc;和(*pf1)();是合法的，但以上都可以通过编译。

在Pascal syntax中，我们需要分别定义函数的vars或者函数指针的vars，它们的含义是不同的，而且更清晰（至少我是这么认为的）！

此外，我们不能声明/定义函数的 var 来代替函数指针的 var！ 我尝试跟随但失败了。

typedef void ( aFunc )();
aFunc af0 = theFunc;

如果使用其他类型，例如 int/double，则有非常严格的语法限制我们正确使用它们。 （如果int*与int不同，为什么*pf0与pf0相同？！）

那么，我可以认为这是 C/C++ 标准的错误吗？

Answer 1

一些声明的类型：

// decltype of theFunc is void ()
// decltype of &theFunc is void (*) ()
// decltype of *theFunc is void (&) ()

现在，关于您的代码，由于函数可以隐式转换为指向该函数的指针，因此我们有：

using pFunc = void(*)();
using rFunc = void(&)();

pFunc p_fct = &theFunc; // no conversion
pFunc p_fct = theFunc;  // conversion lvalue to pointer
pFunc p_fct = *theFunc; // conversion lvalue reference to pointer

rFunc r_fct = *theFunc; // no conversion
rFunc r_fct = theFunc;  // conversion lvalue to lvalue reference
rFunc r_fct = &theFunc; // ERROR: conversion pointer to lvalue reference not allowed

到目前为止的转换。现在，pFunc 或 rFunc 类型的任何对象都是可调用对象。另外，请注意(*p_fct) 和(*r_fct) 都是rFunc 类型。因此，您可以按照问题中的描述调用您的函数：

p_fct();    // callable object of type pFunc
r_fct();    // callable object of type rFunc
(*p_fct)(); // callable object of type rFunc
(*r_fct)(); // callable object of type rFunc

请注意，以下内容等价于上述内容：

using Func = void ();
Func* p_fct = &theFunc; // no conversion
Func& r_fct = *theFunc; // no conversion
p_fct();                // callable of type Func* or pFunc
r_fct();                // callablel of type Func& or rFunc

编辑要从以下评论中回答问题：“为什么以这种方式排列它们”：无法复制函数（如@JohnBurger 的回答中所述）。这就是为什么你的代码：

typedef void ( aFunc )();
aFunc af0 = theFunc;

不起作用。如上所述，您可以执行以下操作：

typedef void ( aFunc )();
aFunc* af0 = &theFunc; // or theFunc, or even *theFunc

或者你可以这样做：

auto myFct = theFunc;

但请记住，myFct 的 decltype 仍然是 void (*)()。

Answer 2

暂时忽略函数：想想struct。

你可以有一个struct，或者一个指向struct的指针：

typedef struct {
    int x;
    int y;
} Point;

Point origin = { 0, 0 };
Point here   = { 1, 1 };
Point there  = { 2, 2 };

int main() {
   Point  centre  =  origin;
   Point *myPoint = &origin;

   centre  =  here;
   myPoint = &here;

   centre  =  there;
   myPoint = &there;
} // main()

全球共有三个Points：origin、here 和there。

main() 有两个变量：centre 和 myPoint。

centre 复制origin、here 和there 的值。

myPoint 指向 origin、here 和 there - 它确实不复制它们。

这两种思路有很大区别：一种是复制整个对象，另一种只指向另一个对象。

现在考虑函数。函数由编译器在代码中定义，并且永远不能被复制。所以没有函数变量是有意义的——它们会有多大？唯一明智的想法是指向函数的指针——这就是 C 语言提供的全部内容。

如果要定义 C 函数 typedef，请使用以下语法：

// Fn is a function that accepts a char and returns an int
int Fn(char c);

// FnType is the type of a function that accepts a char and returns an int
typedef int FnType(char c);

// Here is the definition of Fn
int Fn(char c) {
    return c + 1;
} // Fn(c)

// Now here is how you can use FnType
int main() {
    FnType *fn = &Fn;
    return fn('A');
} // main()

Answer 3

我想我找到了答案。

确实，c++ 标准提供了一种无需指针帮助即可声明函数类型的方法。

示例：

#include <functional>

using AFunc_t = function<void( int )>;

void theFunc( int );

AFunc_t afunc = theFunc;

我希望这可以帮助某人。