指向类成员的指针

1、指向类的数据成员的指针:
   声明格式如下:
   <类型说明符> <类名>::* <指针变量名>;
2、指向类的成员函数的指针:
   声明格式如下:
   <类型说明符> (<类名>::*<指针名>)(<参数表>);
如:
class A
{
  private:
    int a;
  public:
    int c;
  public:
    A(int i) { a = i;};
    int Fun(int b) { return ((a * c) + b); };
};

定义一个指向类A的数据成员c的指针,其格式如下:
int A::* pc = &(A::c);

定义一个指向类A的成员函数Fun()的指针,其格式如下:
int (A::*pFun)(int) = A::fun;
或
int A::*pFun(int);

pFun = A::fun;

由于类不是运行时存在的对象,所以在使用这类指针的时候,要定义类的一个对象,然后通过这个对象来访问这类指针所指向的成员;
如: 
A a;
a.*pc = 8;    //为对象a的数据成员c赋值8;

A* pa;
pa = &a;
pa->*pc = 9;  //通过指向对象的指针来为指向对象成员的指针所指向的数据成员赋值;

其中,运算符".*"和"->*"都是通过指向类成员的指针来操作对象成员的运算符;
3.指向普通函数的指针的定义格式:
 <类型说明符> (*<指向函数的指针名>)(<参数表>);
 赋值:
 <指向函数的指针名> = <函数名>;
 调用:
 (*<指向函数的指针名>)(<实参表>);
例如:
class B
{
  private:
    int a;
  public:
    int c;
  public:
    A(int i) { a = i;};
    int Fun(int b) { return ((a * c) + b); };
};

int main(int argc, char** argv)
{
  B x(8)
  int B::* pc = NULL;     //声明指向类数据成员的指针pc;
  pc = &(A::c);           //为指向类数据成员的指针pc赋值;
  x.*pc = 9;              //通过指向类数据成员的指针pc为对象的成员赋值;
  
  int (B::*pFun)(int);    //声明指向类成员函数的指针pFun;
  pFun = A::Fun;          //为指向类成员函数的指针pFun赋值为A::Fun;
  
  A* px = &x;             //声明指向类的对象x的指针px;
  cout << (px->*pFun)(5); //通过指向对象x的指针px来访问指向对象x的成员函数的指针pFun,并调用指向对象的成员函数指针所指向的成员函数;
  return 0;
}

自理解指向类数据成员的指针的结合性:
<类型说明符> (<类名>::*) <指针名> = &(<类名>::<数据成员名>)
int (A::*) pc = &(A::c);
或
(<类型说明符> <类名>::)* <指针名> = &(<类名>::<数据成员名>)
(int A::)* pc = &(A::c);
或
(<类型说明符> <类名>::) (*<指针名>) = &(<类名>::<数据成员名>)
(int A::) (*pc) = &(A::c);
可以把(*pc)作为整体,看作是对类A的数据成员c的引用,或者是 (*pc)<==>c;
即: (*<指针名>) <==> <数据成员名>
所以, A::(*pc) <==> A::c;

自理解指向类成员函数的指针的结合性:
<类型说明符> (<类名>::*<指针名>)(<参数表>) = <类名>::<成员函数名>;
int (A::*pFun)(int) = A::Fun;
或
<类型说明符> <类名>::*<指针名>(<参数表>) = <类名>::<成员函数名>;
int A::*pFun(int) = A::Fun;
或
<类型说明符> <类名>::(*<指针名>)(<参数表>) = <类名>::<成员函数名>;
int A::(*pFun)(int) = A::Fun;

可以把(*pFun)作为整体,看作是类A的成员函数名Fun;
即: (*pFun) <==> Fun;
所以,A::(*pFun) <==> A::Fun;

 

转自哥哥的日志：http://bdxnote.blog.163.com/blog/static/8444235200962581540799/