C++拾遗--类成员指针
类成员的类型与一般类型不同，那么类成员的指针类型自然与一般类型的指针有所区别。我们有必要来探讨下类成员指针的使用。
类成员指针是指可以指向类的非静态成员的指针。它的类型包括了类类型和所指向的成员类型。一般而言，指针指向的是对象，而类成员指针指向的是类成员而非类对象。
需要指出，类成员指针不是可调用对象，要想通过类成员指针调用类成员，需结合类对象或类指针。静态类型成员属于类，类型与普通指针相似。
一般的声明形式：
成员类型 classname::*p;
它的赋值形式:
p = &classname::类数据成员;
这里的取地址符&，是必须的。
#include <iostream>
using namespace std;
class Myclass
{
public:
int a;
const char c;
Myclass(int a, int c) :a(a), c(c)
{
}
};
int main(void)
{
int Myclass::*pa;
pa = &Myclass::a;
const char Myclass::*pc;
pc = &Myclass::c;
Myclass my(520, 'C'), *p = &my;
cout << my.*pa << endl;
cout << p->*pa << endl;
cout << my.*pc << endl;
cout << p->*pc << endl;
cin.get();
return 0;
}运行
在这个例子中，我们定义了两个成员指针pa和pc。其中pc的声明必须加上const，否则，稍后的赋值会发生类型不匹配的错误。我们还定义了类的对象和指针，它们分别通过成员指针访问运算符.*和->*，对类成员指针进行访问。
和数据成员指针类似，它的声明同样得指定类类型和函数成员类型。
返回类型 (classname::*pfun)(参数类型列表);
它的赋值形式:
pfun = &classname::类函数成员;
#include <iostream>
using namespace std;
class Compute
{
public:
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b) const
{
return a - b;
}
};
int main(void)
{
int (Compute::*pfun1)(int, int);
pfun1 = &Compute::add;
int (Compute::*pfun2)(int, int) const;
pfun2 = &Compute::sub;
Compute com, *p = &com;
cout << (com.*pfun1)(100, 10) << endl;
cout << (p->*pfun1)(100, 10) << endl;
cout << (com.*pfun2)(100, 10) << endl;
cout << (p->*pfun2)(100, 10) << endl;
cin.get();
return 0;
}运行
这个例子就不多解释了。只说一句：访问限定符仍然有效，可在类外访问的数据和函数才可以使用类成员指针调用。
通过mem_fn对类函数成员指针进行包装，来返回一个可调用对象。使用时，包含头文件functional。
#include <iostream>
#include <functional>
using namespace std;
class Compute
{
public:
Compute(int a, int b) :a(a), b(b)
{
}
int add()
{
return a + b;
}
int sub() const
{
return a - b;
}
private:
int a;
int b;
};
int main(void)
{
Compute com(100, 10), *p = &com;
auto fun1 = mem_fn(&Compute::add);
cout << fun1(com) << endl;
cout << fun1(p) << endl;
auto fun2 = mem_fn(&Compute::sub);
cout << fun2(com) << endl;
cout << fun2(p) << endl;
cin.get();
return 0;
}运行
由于add方法是参数是void的，所有调用时，只传递类对象fun(com)或指针fun(p)即可。
若成员方法是带参数的，该如何使用呢？看下面的代码：
#include <iostream>
#include <functional>
using namespace std;
class Compute
{
public:
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b) const
{
return a - b;
}
};
int main(void)
{
Compute com, *p = &com;
auto fun1 = mem_fn(&Compute::add);
cout << fun1(com, 100, 10) << endl;
cout << fun1(p, 110, 10) << endl;
auto fun2 = mem_fn(&Compute::sub);
cout << fun2(com, 120, 10) << endl;
cout << fun2(p, 130, 10) << endl;
cin.get();
return 0;
}运行
这个示例显示了，若是带参数的，参数跟在类对象或类指针后面即可。
mem_fn会根据传入的参数类型，自动选择调用.*或->*：
Compute com, *p = &com;
auto fun = mem_fn(&Compute::add);
fun(com); //传入对象，这一句会被解释成 auto padd = &Compute::add; (com.*padd)();
fun(p); //传入指针，这一句会被解释成 auto padd = &Compute::add; (p->*padd)();
使用函数适配器bind，绑定类函数成员，返回可调用对象。
在bind函数绑定中，已经有了详细介绍。
本专栏目录
所有内容的目录
原文地址：http://blog.csdn.net/zhangxiangdavaid/article/details/44410799
