C详解类成员指针数据成员指针和成员函数指针及应用场合

　　对于类对象对于成员的调用，需要有类对象的限定，一方面是一个类命名空间，另一方面用于传递隐含的this指针。
　　数据和函数，包括类对象的数据成员和成员函数，都是可以寻址的，自然也可以定义一个指针，使其指向类成员或成员函数，然后通过指针来访问类的成员。这包括指向属性成员的指针和指向成员函数的指针。1 指向普通变量和函数的指针变量
　　关于数据的指针变量存储了具有特定数据类型的一个内存空间的首地址，确定了其指向的目标对象的蓝图，核心是由数据类型确定了目标对象所需内存空间大小，数据类型的编码和解码方式。关于代码的指针变量是指指向函数的指针变量，同样是首地址，类型是由函数签名所确定的类型，以及代码的指令集编码及读取和译码方式。#include  using namespace std; void func(int a) {     cout<

2 指向类数据成员和成员函数的指针

2.1 指向类数据成员的指针

2.1.1 定义

<数据类型><类名>::*<指针名>
　　为了区别于普通指针变量，多了一个类名作用域限定，也显示了与类及类成员的相关性。
　　2.1.2 赋值&初始化<数据类型><类名>::*<指针名>[=&<类名>::<非静态数据成员>]
　　指向非静态数据成员的指针在定义时必须和类相关联，在使用时必须和具体的对象关联。
　　2.1.3 解引用
　　由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定类的一个对象，然后，通过对象来引用指针所指向的成员。<类对象名>.*<指向非静态数据成员的指针> <类对象指针>->*<指向非静态数据成员的指针>
　　示例代码：    Student s1(＂zhangsan＂,1002);     string Student::*ps = &Student::name;       // 数据成员指针     cout<*ps<(<类名>::*<指针名>)(<参数列表>)
　　为了区别于全局函数指针，多了一个类名作用域限定，也显示了与类及类成员的相关性。
　　2.2.2 赋值&初始化<数据类型>(<类名>::*<指针名>)(<参数列表>)[=&<类名>::<非静态成员函数>]
　　2.2.3 解引用
　　由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定类的一个对象，然后，通过对象来引用指针所指向的成员。(<类对象名>.*<指向非静态成员函数的指针>)(<参数列表>) (<类对象指针>->*<指向非静态成员函数的指针>)(<参数列表>)
　　示例代码：#include  #include  using namespace std; class Student { public:     Student(string n, int nu):name(n),num(nu){}     void dis()     {         cout<<＂name ＂<*ps<*pf)();         getchar();     return 0; }3 指向类静态成员的指针
　　指向非静态成员时，必须用类名作限定符，使用时则必须用类的实例作限定符。指向静态成员时，声明时则不需要使用类名作限定符。（当然静态成员做右值也需要类名限定）#include  using namespace std; class A { public:     static void print();     static int data;      }; void A::print() {     cout< using namespace std; class Widget { public:     Widget()     {         fptr[0] = f;         fptr[1] = g;         fptr[2] = h;         fptr[3] = i;              }     void select(int idx, int val)     {         if(idx<0 || idx>cnt) return;         (this->*fptr[idx])(val);     }     int count()     {         return cnt;     } private:     void f(int val){cout<<＂void f() ＂<  class CS{ public:     void callback(int n)     {         // ……         printf(＂处理逻辑1, %d ＂,n);         // ……     }     void callback2(int n)     {         // ……         printf(＂处理逻辑2, %d ＂,n);         // ……     }     void callee(void(CS::*csPF)(int))   // 类成员函数指针     {         // ……         printf(＂按不同的处理逻辑操作 ＂);         (this->*csPF)(12);              // 调用成员函数指针与调用普通函数指针不同         // ……     }     void caller() // caller calls callee that calls callback     {         // ……         callee(callback);         // ……     }     void caller2()     {         // ……         callee(callback2);         // ……     }     static void sm_func(int n)     {         printf(＂我是一静态成员函数%d ＂,n);     }     friend void userCSMemFunc(CS &cs, void(CS::*csPF)(int)); private:     int csi; }; void userCSMemFunc(CS &pcs, void(CS::*csPF)(int)) {     pcs.csi = 256;     (pcs.*csPF)(pcs.csi); } void userCSMemFunc2(CS &pcs, void(CS::*csPF)(int)) {     (pcs.*csPF)(128); } int main() {     CS cs, *pcs;     cs.caller();     cs.caller2();     typedef void(CS::*csPF)(int);     csPF cspf = &CS::callback;     (cs.*cspf)(24);             // 调用成员函数指针与调用普通函数指针不同     (pcs->*cspf)(48);     //void(*pf)(int) = cspf; // cannot convert from ＂void (__thiscall CS::*)(int)＂                                                //to ＂void (__cdecl *)(int)＂     void(*pf)(int) = CS::sm_func;     pf(256);     userCSMemFunc(cs,CS::callback2);     userCSMemFunc2(cs,CS::callback2);     void(*pff)(CS &cs, void(CS::*csPF)(int)) = userCSMemFunc;     pff(cs,CS::callback2);     getchar();     return 0; } /* 按不同的处理逻辑操作 处理逻辑1, 12 按不同的处理逻辑操作 处理逻辑2, 12 处理逻辑1, 24 处理逻辑1, 48 我是一静态成员函数256 处理逻辑2, 256 处理逻辑2, 128 处理逻辑2, 256 */
　　https://blog.csdn.net/yyx112358/article/details/78515420
　　－End－