类成员指针

Q1：相关简要概述

• 希望获得特定成员的指针，然后从一个对象或别的对象获得该成员时，使用类成员指针

• 成员指针包含类的类型以及成员类型

• 成员指针只用于类的非static成员，因为静态成员不属于任何一个对象，因此不需要用特殊的语法来获取静态成员

• 数据成员的指针需要指明两点： 1.成员类型， 2.所属类类型。如：

class X
        {
            public:
                Type val;
        };

        Type X:: * p = &X::val;

• 函数成员的指针需要与函数成员有以下三点匹配： 1.形参类型和数目（包括成员是否为const）, 2.返回类型， 3.所属类类型。如：

class X
        {
            public:
                typedef int type;
                void  func(type,type)const;
        };

        void (X::* p)(X::type, X::type)const = &X::func;

Q2：使用类成员的指针

• .* 与 ->* 能将成员指针绑定到实际对象，其中左操作数必须是类类型的对象或类类型的指针，右操作数是该类型的成员指针

• 使用数据成员指针，按上述定义，如：

        X x;
        X xptr = &x;
        Type y = x.*p;           //成员指针在使用前必须先初始化，即 p = &X::val;
        Type z = xptr->*p;

• 使用成员函数的指针，按上述的类定义，如：

        X x;
        X xptr = &x;        
        (x.*p)();            //成员指针在使用前必须先初始化，即 p = &X::func;
        (xptr->*p)();

Q3：成员指针在函数表中的使用

• 当一个类具有几个有相同类型的成员时，可以考虑使用函数表来简化函数调用。如下例：

class X
        {
        public:
            void output1()
            {
                cout << "1" << endl;
            }
            void output2()
            {
                cout << "2" << endl;
            }
            void output3()
            {
                cout << "3" << endl;
            }
        };

该类含有三个类型完全一样的成员函数，在调用过程中不方便，可以通过函数表的方法进行简化。1.先定义成员函数指针类型，2.定义函数表。即增加以下操作：

        class X
        {
        public:
            typedef void(X::* Action)();        //定义成员函数指针，该指针指向 X 中的成员函数，该函数无形参且无返回值
            static Action action[];                 // 声明函数表
        };

定义枚举类型作为函数表的索引值，并定义接口函数来调用函数表中的函数，即增加以下操作：

class X
        {
        public:
            enum Choice{GO1,GO2,GO3};
            void move(Choice i)
            {
                (this->*action[i])();          //根据索引值调用对应的函数表中的函数
            }
        };

需要在类外部定义 X 中的静态成员 action,如下：

X::Action X::action[] = {&output1,&output2,&output3};

此时，类 X 中的函数调用被简化了，通过同一个接口函数 move，根据传入的枚举值的不同，执行不同的函数，如：

    X x;
        x.move(X::GO1);      //执行X::output1()
        x.move(X::GO2);      //执行X::output2()
        x.move(X::GO3);      //执行X::output3()