指向类成员函数指针

1、指向非静态成员的指针

其实指向非静态的类成员的指针很容易，它们与普通指针唯一的区别是，他们受类的限制。如下：

class A
{
       int _val;
       int val();
};

int (A::*p_val) = &A::_val;
int ( A::*p_func )() = &A::val；

看到了吗，是的，和普通的指针的区别是，指向类成员的指针必须把类也一并带上，上面的例子中就是要把A::这个限定符一起带上，然后？用法和普通指针一样的就是了。

2、指向静态成员的指针

指向静态成员的指针，声明的方式和普通指针完全一样，只是赋值的时候，还得加上类的限定符。为什么这样？我想可以这样来理解，对于非静态成员，其存在取决于类，类消亡的时候，非静态成员随之消亡，所以，其声明必须与类的限定符绑在一起，而静态成员对于类而言并无依附关系，所以，不需要类的限定符。如下：

class A
{
       static int _val;
       static int val();
};

int *p_val = &A::_val;
int (*p_func) = &A::val;

3、好处

一个好处是，通过指向成员的函数指针，可以很轻松的调用各个成员函数了，另一个好处是，对于静态成员函数，可以成为C里的回调函数啦。

下面是一个例子，加深一下理解：

#include <iostream>

#include <string>

using namespace std;

typedef void (*funchandler)();

void register_func(funchandler f)

{

    cout << "register_func" << endl;

    (*f)();

}

class A

{

public:

    A() : _val( 0 ) { cout << "create A..." << endl; }

    void test() { cout << "test..." << endl; }

    void test1() { cout << "test1..." << endl; }

    void test2() { cout << "test2..." << endl; }

    int val() { return _val; }

    static void test3() { cout << "test3..." << endl; }

    int _val;

private:

};

int main()

{

    A a;

    int ( A::*p_val ) = 0;

    p_val = &A::_val;

    cout << "a.*p_val: " << a.*p_val << endl;

    

    void (A::*p_func)();

    p_func = &A::test;

    

    a.test();

    (a.*p_func)();

    

    p_func = &A::test1;

    ( a.*p_func )();

    p_func = &A::test2;

    ( a.*p_func )();

    

    void (* pp_func)();

    pp_func = &A::test3;

    (*pp_func)();

    

    register_func( pp_func );

    return 0;

    

}