不允许成员函数的非指针 typedef？

Question

在得到这个问题的答案后，我发现有两个typedef 函数指针的有效方法。

typedef void (Function) ();
typedef void (*PFunction) ();

void foo () {}

Function * p = foo;
PFunction  q = foo;

我现在更喜欢 Function * p 而不是 PFunction q 但显然这不适用于指向成员函数的指针。考虑这个人为的例子。

#include <iostream>

struct Base {
    typedef void (Base :: *Callback) ();
                        //^^^ remove this '*' and put it below (i.e. *cb)
    Callback cb;

    void go () {
        (this->*cb) ();
    }

    virtual void x () = 0;

    Base () {
        cb = &Base::x;
    }
};

struct D1 : public Base {
    void x () {
        std :: cout << "D1\n";
    }
};

struct D2 : public Base {
    void x () {
        std :: cout << "D2\n";
    }
};  

int main () {
    D1 d1;
    D2 d2;
    d1 .go ();
    d2 .go ();
}

但是，如果我将其更改为新的首选样式： typedef void (Base :: Callback) () 和 Callback * cb，我会在 处收到编译器错误代码>类型定义

成员“Callback”上的额外限定“Base::”

错误演示。

为什么这是不允许的？这只是一个疏忽还是会导致问题？

Answer 1

对于非成员函数，诸如 typedef void(Function)() 之类的类型有多种用途，但对于成员函数，唯一的应用是声明一个保存函数指针的变量。因此，除了风格偏好之外，没有严格需要允许这种语法，并且它已从标准中省略。

背景

:: 是范围解析运算符，语法 X::Y 保留用于 static 成员访问，如果 X< /code> 是一个类类型。因此，X::*Z 是另一种为定义指向成员的指针而发明的语法。

暂时忘记成员函数，只考虑成员数据，看看这段代码：

struct X
{
   int a;
};

int X::*pa = &X::a; //pointer-to-member
X x = {100}; //a = 100
cout << (x.*pa) << endl;

它定义了指向成员数据的指针 >，并且 cout 使用它来打印对象 x 的 a 的值，并打印：

100

Demo : http://www.ideone.com/De2H1

现在想想，如果 X::pa （而不是 X::*pa) 被允许这样做，那么您将上面的内容编写为：

int X::pa = X::a; //not &X::a

看到这个语法，您如何判断 X::a 是否是 static 成员或非静态成员？这就是标准提出指向成员的指针语法的原因之一，并将其​​统一应用于非静态成员数据以及非静态成员函数。。

事实上，您不能编写X::a，您必须编写&X::a。语法 X::a 会导致编译错误（请参阅此）。

---

现在将成员数据的这个参数扩展到成员函数。假设您的 typedef 定义为：

typedef void fun();

那么您认为以下代码会做什么？

struct X
{
   fun a;
};

好吧，它定义了 fun 类型的成员 a（这是不带参数、返回 void 的函数），并且等价于：

struct X
{
   void a();
};

惊讶吗？请继续阅读。

struct X
{
   fun a; //equivalent to this: void a();
};

void X::a() //yes, you can do this!
{
     cout << "haha" << endl;
}

我们可以使用完全相同的语法来引用现在是成员函数的 a：

X x;
x.a(); //normal function call

void (X::*pa)() = &X::a; //pointer-to-member
(x.*pa)(); //using pointer-to-member

相似之处在于右侧的语法：&X::a 。无论a是指成员函数还是成员数据，语法都是相同的。

演示： http://www.ideone.com/Y80Mf

结论：

作为我们知道，无论a是成员数据还是成员函数，我们都不能在RHS上编写X::a。唯一允许的语法是 &X::f ，这使得目标类型（LHS 上）也必须是 pointer ，这反过来又使得语法 void (X::*pa)() 绝对必要且基本，因为它与该语言中的其他语法相匹配。

Answer 2

准确地说，在非成员指针的情况下，两个 typedef 是不同的：

typedef void function();
typedef void (*fptr)();

第一个将 function 定义为不带参数并返回 void 的函数，而第二个将 ftpr 定义为指向不带参数并返回 void 的函数的指针。由于函数类型在许多上下文中将隐式转换为指针类型，因此可能会出现混乱。但并非全部：

function f;            // declares void f();
struct test {
   function f;         // declares void test::f()
};
void g( function f );  // declares g( void (*f)() ): function decays to pointer to function in declaration
g( f );                // calls g( &f ): function decays to pointer to function
void f() {}            // definition of f
// function h = f;     // error: cannot assign functions
function *h = f;       // f decays to &f

Answer 3

让我们暂时跳过“函数”部分。在 C++ 中，我们有 int、int* 和 int Foo::* 类型。这是一个常规整数、指向整数的指针和指向整数成员的指针。不存在第四种“整数成员”。

这同样适用于函数：尽管有函数类型、函数指针类型和成员函数指针类型，但只是没有“成员函数”类型。