类的内部数据类型成员指针以及operator->*

//指向成员的指针(成员指针)  pointer-to-member
//成员指针的语法要求:选择一个对象的同时,间接引用成员指针

#include <iostream>

class ObjectClass
{
public:
int a;
int b;
ObjectClass(){ a = 0; b = 0; }
friend std::ostream& operator<<(std::ostream& os, const ObjectClass& OC)
{
return std::cout << "a= " << OC.a << ";  b= " << OC.b;
}
};

int main()
{
int ObjectClass::*pointerToMember = &ObjectClass::a;//成员指针定义


//通过成员指针访问对象:
ObjectClass OC;
ObjectClass* OC_Pointer(&OC);
OC.*pointerToMember = 1;
std::cout << OC << std::endl << std::endl;
OC_Pointer->*pointerToMember = 2;
std::cout << OC << std::endl << std::endl;


//成员指针可以改变
pointerToMember = &ObjectClass::b;
OC.*pointerToMember = 3;
std::cout << OC << std::endl << std::endl;
OC_Pointer->*pointerToMember = 4;
std::cout << OC << std::endl << std::endl;

std::cin.get();
return 0;

}

//operator->* 指针成员间接引用
//operator->* 比 operator->稍微简单一点,因为不存在传递链,而且operator->*的形式更符合常规的函数调用
//现在我们来剖析operator->* 重载时到底需要为当前类补充哪些内容


//假设成员指针指向的是类中的函数

#include <iostream>
class Object
{
public:
int fun(int i)
{
std::cout << typeid(*this).name() << "::fun( " << i << " )" << std::endl;
return i;
}
typedef int(Object::*pointer_to_function_Object)(int);
class pointer_to_function
{
Object* op;
pointer_to_function_Object function;
//这两者是必要的信息
public:
pointer_to_function(){}
pointer_to_function(Object* OP, pointer_to_function_Object FUNCTION)
{
op = OP;
function = FUNCTION;
}
//operator()
int operator()(int i)
{
return (op->*function)(i);
}
};
//返回当前类
pointer_to_function operator->*(pointer_to_function_Object FUNCTION)
{
return pointer_to_function(this, FUNCTION);
}
};
int main()
{
Object ob;
Object::pointer_to_function_Object/*prefix"Object::" is necessary*/ pO = &Object::fun;
std::cout << (ob->*pO)(1) << std::endl;


//default
std::cout << (ob.*pO)(1) << std::endl;
std::cout << ((&ob)->*pO)(1) << std::endl;
//
std::cin.get();
}


//vs2013 c++
/*
结果:
class Object::fun( 1 )
1
class Object::fun( 1 )
1
class Object::fun( 1 )
1
*/

//这个例子举得不是很恰当(《thinking in c++》),因为对象访问成员指针用的是操作符.*，而不是操作符.->*

//但是operator->* 确实比 operator->  好理解