成员函数指针是C++最少用到的语法之一，甚至有经验的C++码农有时候也会被它搞晕。这是一篇针对于初学者的教程，同时也给有经验的码农分享了一些我个人对底层机制的挖掘。在开始之前，让我们先看一段在第一次看时一定会高呼“我++”的代码（说明，这些代码都是翻译君重新手敲的，改正了原文代码中的一些不太好的空格、缩进，下同）：

//mem_fun1.cpp
#include <iostream>

class Foo {
public:
    Foo(int i = 0) { _i = i; }
    void f() {
        std::cout << "Foo::f()" << std::endl;
    }
private:
    int _i;
};

int main() {
    Foo *p = 0;
    p->f();
}

// Output:
// Foo::f()

为什么我们能通过一个空指针调用成员函数？看起来好像编译器根本不鸟p的值是什么，只介意p的类型。别着急，咱先吊吊胃口，把答案留到后面的章节。现在，我们所能知道的是，编译器准确地知道要调用哪个函数。这就是所谓的“静态绑定”。因为成员函数可以静态绑定（并不是总能静态绑定，待会儿讨论），所以它们的地址是在编译阶段决定的（同样并不是永远如此）。直观地讲，应该有一种方法可以保存成员函数的地址。而且，真有这么一种方法，那就是——成员函数指针。

下面的语法展示了如何声明一个成员函数指针：

Return_Type (Class_Name::* pointer_name) (Argument_List);

Return_Type:   member function return type.
Class_name:    name of the class in which the member function is declared.
Argument_List: member function argument list.
pointer_name:  a name we'd like to call the pointer variable.

例如，我们定义一个类 Foo 和一个成员函数 f ：

int Foo::f(string);

我们可以给这个成员函数指针起一个“高大上”的名字 fptr ，所以我们就有了下面的内容：

Return_Type:   int
Class_Name:    Foo
Argument_List: string

declaration of a  pointer-to-member function named "fptr":
  int (Foo::*fptr) (string);

现在，指定一个成员函数给我们“高大上”的 fptr ：

fptr = &Foo::f;

当然，就连脑残都知道可以将声明和初始化结合起来：

int (Foo::*fptr) (string) = &Foo::f;

为了通过函数指针来调用成员函数，我们使用成员指针选择操作符（翻译君表示也不知道该怎么翻译，原文是pointer-to-member selection operators）， .* 或者 ->* 。下面的代码演示了基本用法：

#include <iostream>
#include <string>

using namespace std;

class Foo {
public:
    int f(string str) {
        cout << "Foo::f()" << endl;
        return 1;
    }
};

int main(int argc, char *argv[]) {
    int (Foo::*fptr) (string) = &Foo::f;
    Foo obj;
    (obj.*fptr)("str"); // 通过对象来调用 Foo::f()
    Foo *p = &obj;
    (p->*fptr)("str"); // 通过指针来调用 Foo::f()
}

注意： .*fptr 绑定fptr到对象obj，而 ->*fptr 则绑定fptr到指针p所指向的对象。（还有一个 重要的区别 是：我们可以重载后者，却不能重载前者）。在 (obj.*fptr) 和 (p->*fptr) 两边的括号是语法所强制要求的。

成员函数指针不像常规指针那样保存某个“准确”的地址。我们可以把它想像成保存的是成员函数在类布局中的“相对”地址。让我们来展示一下二者的不同。我们只对类 Foo 做一个小手术：将成员函数 f 变成 static ：

#include <iostream>
#include <string>

using namespace std;

class Foo {
public:
    static int f(string str) {
        cout << "Foo::f()" << endl;
        return 1;
    }
};

int main(int argc, char *argv[]) {
    // int (Foo::*fptr) (string) = &Foo::f; // 错误
    int (*fptr) (string) = &Foo::f; // 正确
    (*fptr)("str"); // 调用 Foo::f()
}

一个静态成员函数没有 this 指针。除了它和其它的类成员共享命名空间Foo（在我们的例子中命名空间是 Foo:: ）之外，它和常规全局函数是一样的。所以，静态成员函数不是类的一部分，成员函数指针的语法对常规函数指针并不成立，例如上面例子中的静态成员函数指针。

int (Foo::*fptr) (string) = &Foo::f;

上面这行代码在g++ 4.2.4中编译的错误信息为：“不能将 int (*)(std::string) 转化成 int (Foo::*)(std::string) ”。这个例子证明了成员函数指针不是常规指针。另外，为什么C++如此费心地去发明这样的语法？很简单，因为它和常规指针是不同的东西，而且这样的类型转换也是违反直觉的。

成员函数指针的一个重要应用就是根据输入来生成响应事件，下面的 Printer 类和指针数组 pfm 展示了这一点：

#include <stdio.h>
#include <string>
#include <iostream>

class Printer { // 一台虚拟的打印机
public:
    void Copy(char *buff, const char *source) { // 复制文件
        strcpy(buff, source);
    }

    void Append(char *buff, const char *source) { // 追加文件
        strcat(buff, source);
    }
};

enum OPTIONS { COPY, APPEND }; // 菜单中两个可供选择的命令

typedef void(Printer::*PTR) (char*, const char*); // 成员函数指针

void working(OPTIONS option, Printer *machine,
             char *buff, const char *infostr) {
    PTR pmf[2] = { &Printer::Copy, &Printer::Append }; // 指针数组

    switch (option) {
    case COPY:
        (machine->*pmf[COPY])(buff, infostr);
        break;
    case APPEND:
        (machine->*pmf[APPEND])(buff, infostr);
        break;
    }
}

int main() {
    OPTIONS option;
    Printer machine;
    char buff[40];

    working(COPY, &machine, buff, "Strings ");
    working(APPEND, &machine, buff, "are concatenated!");

    std::cout << buff << std::endl;
}

// Output:
// Strings are concatenated!

在上述代码中， working 是一个用来执行打印工作的函数，它需要几个参数：1. 菜单选项；2. 可用的打印机；3. 字符串目的地；4. 字符串来源。上述代码中字符串来源是两个字符串常量"Strings "和"concatenated!"，而成员函数指针数组被用来根据菜单选项执行相应的打印动作。

成员函数指针另外一个重要的应用可以在STL的 mem_fun() 中找到。（翻译君去看了一下 mem_fun() 的源代码，原来是用成员函数来构造仿函数functor的。）

现在我们回到文章最开始的地方。为什么一个空指针也能调用成员函数？对于一个非虚函数调用，例如： p->f() ，编译器会生成类似如下代码：

Foo *const this = p;
void Foo::f(Foo *const this) {
    std::cout << "Foo::f()" << std::endl;
}

所以，不管p的值是神马，函数 Foo::f 都可以被调用，就像一个全局函数一样！p被作为 this 指针并当作参数传递给了函数。而在我们的例子中 this 指针并没有被解引用，所以，编译器放了我们一马（翻译君表示，这其实跟编译器没有关系，即使我们在成员函数中使用this指针，编译照样能通过，只不过在运行时会crash）。假如我们想知道成员变量 _i 的值呢？那么编译器就需要解引用 this 指针，这只有一个结果，那就是我们的好兄弟——未定义行为（undefined behavior）。对于一个虚函数调用，我们需要虚函数表来查找正确的函数，然后， this 指针被传递给这个函数。

这就是非虚函数、虚函数、静态函数的成员函数指针使用不用实现方式的根本原因。

简单总结一下，通过上述文章，我们学到了：

1. 成员函数指针声明和定义的语法
2. 使用成员指针选择操作符来调用成员函数的语法
3. 使用 typedef 写出更加清晰的代码
4. 非虚成员函数、虚函数、静态成员函数之间的区别
5. 成员函数指针和常规指针的对比
6. 不同情形下的成员函数指针转换规则
7. 如何使用成员函数指针数组来解决特定的设计问题
8. 编译器是如何解释成员函数调用的

我衷心希望这篇教程能打开通往上述要点的相关高级技巧的大门，例如多重继承、虚继承下的成员函数指针，以及编译器的相关实现，例如“巨硬”家的Thunk技术（原文这里有链接，但翻译君去看了一下，不仅又老又旧（还在讲Windows 98和16位程序），而且只是巨硬的support性质的文章，所以就不贴链接了，免得浪费各位看官宝贵的青春:-p）。

那么，就到这里了，谢谢各位的围观，希望能对各位有所帮助。（翻译君表示，这哥们怎么这么啰嗦，和天朝棺猿有得一拼:-p）