C++指針與成員

先看一個例子：
//統一的接口

include <iostream>

using namespace std;

struct Point{

int plus(double x, double y){
    return x + y;
}
int minus(double x, double y){
    return x - y;
}
int mul(double x, double y){
    return x*y;
}
int div(double x, double y){
    return x/y;
}

};

int oper(Point & point, int (Point::*pfun)(double x, double y),

double x, double y){
return (point.*pfun)(x, y);

}

int main()
{

Point pt;
int (Point::*pfun)(double, double);
pfun = &Point::plus;
cout<<oper(pt, pfun, 10, 20);
pfun = &Point::minus;
cout<<oper(pt, pfun, 10, 20);
return 0;

}

再看一個例子：
//更加隱蔽的接口

include <iostream>

using namespace std;

class Widget{
public:

Widget(){
    pf[0] = &Widget::f;
    pf[1] = &Widget::g;
    pf[2] = &Widget::h;
    pf[3] = &Widget::i;
}
int getCount(){
    return cnt;
}
void select(int val, int sec){
    if(sec<0 && sec>3)
        return;
    (this->*pf[sec])(val);
}

private:

void f(int val){
    cout<<"void f()"<<val<<endl;
}
void g(int val){
    cout<<"void g()"<<val<<endl;
}
void h(int val){
    cout<<"void h()"<<val<<endl;
}
void i(int val){
    cout<<"void i()"<<val<<endl;
}

enum{cnt = 4};
void (Widget::*pf[4])(int);

};

int main()
{

Widget w;
w.select(100, 2);
return 0;

}

/指向靜態成員的指針/
//指向靜態成員的指針的定義和使用與普通指針相同,在定義時無須和類相關聯
//在使用時也無需和具體對象相關聯

//聲明 <數據類型>*<指針名>
//初始化 <數據類型>*<指針名> [=& <類名>::<靜態數據成員>]
//解引用 (*<指向靜態數據成員的指針>)

//聲明 <數據類型>(*<指針名>)(<參數列表>)
//初始化 <數據類型>(*<指針名>)(<參數列表>) [=&<類名>::<靜態成員函數>]
//解引用 (*<指向靜態成員函數的指針>)(<參數列表>
//和普通函數指針,惟一的區別是: 在初始化時,&classname::member,要加上類名限定

include <iostream>

using namespace std;

class A{
public:

static void dis();
static int data;

};

void A::dis(){

cout<<data<<endl;

}

int A::data = 100;

int main()
{

int *pa = &A::data;
cout<<*pa<<endl;    //100

void (*pf)() = A::dis;
pf();   //100
return 0;

}

/指向類成員函數的指針 /
//定義一個指向非靜態成員函數的指針必須在三個方面與其指向的成員函數保持一致
//參數列表相同,返回類型要相同,所屬的類型(類名)要相同
//因爲類不是運行時存在的對象,所以,在使用這類指針時,須要首先指定類的一個對象
//而後,經過對象來引用指針所指的成員
//聲明 <數據類型>(<類名>::*<指針名>)(<參數列表>)
//初始化 <數據類型>(<類名>::*<指針名>)(<參數列表>) [=&<類名>::<非靜態成員函數>]
//解引用 (<類對象名>.*<指向非靜態成員函數的指針>)(<參數列表>)
// (<類對象指針>->*<指向非靜態成員函數的指針>)(<參數列表>)

include <iostream>

using namespace std;

class Student{
public:

Student(string n, int nu): name(n), num(nu){}
void dis(){
    cout<<"name: "<<name<<" num: "<<num<<endl;
}

private:

string name;
int num;

};

int main()
{

Student s("zhangtong", 30);
Student s2("lidan", 26);
Student *ps = new Student("zhaolanni", 35);

void (Student::*pf)() = &Student::dis;

(s.*pf)();  //name: zhangtong num: 30
(s2.*pf)(); //name: lidan num: 26
(ps->*pf)();    //name: zhaolanni num: 35
return 0;

}

/指向類數據成員的指針/
//是類層面的指針,而不是對象層面的指針
//跟普通意義上的指針用法有很大的差異
//定義格式上,必須有類別限定 type className::*pointName
//初始化,也必須有類名限定&className::member
//而且定義的指針,只有經過具體的對象或對象指針才能夠調用

//聲明 <數據類型><類名>::*<指針名>
//初始化 <數據類型><類名>::*<指針名> [=& <類名>::<非靜態數據成員>]
//解引用 <類對象名>.<指向非靜態數據成員的指針> <類對象指針>-><指向非靜態數據成員的指針>

include <iostream>

using namespace std;

class Student{
public:

Student(string n, int nu): name(n), num(nu){}

string name;
int num;

};

int main()
{

Student s("zhangtong", 29);
Student s2("lisa", 43);

string Student::*pn = &Student::name;
cout<<s.*pn<<endl;  //zhangtong
cout<<s2.*pn<<endl; //lisa

Student *ps = new Student("zhaoliu", 35);
cout<<ps->*pn<<endl;    //zhaoliu

return 0;

}