由一道C++题所想到的

问题：

前段时间在睿思上@VivianLiu出了如下一道C++题目：

给定一个类：

class mycl
{
     int a;
     public:
     mycl(mycl &acl)
     {
         a = acl.a;
     }
     protected:
     virtual int geta()
     {
         cout<<"a = "<<a<<endl;
         return a;
     }
};

在不改变该类的定义的前提下，如何编写一段完整的程序，使得该程序能够调用该类中定义的函数成员geta()?
如果将访问标号protected换成private，那又该如何编写代码？

以上是题目。

解法一：

首先想到的则是用一个子类继承mycl，再用一个public的方法调用geta()，注意到，mycl类的构造函数比较奇葩，只有复制构造函数，所以生成mycl对象的时候要注意不能调用mycl的默认构造函数(使用new)，否则会编译不通过，所以采用malloc的方法(因为malloc的时候不会调用mycl的构造函数)，代码如下:

class ocl : public mycl
{
public:
	void getmycla()
	{
		mycl::geta();
	}
	

};

int main()
{
	//ocl oclObj;				/* 不采用这种方法，因为没有定义默认构造函数 */
	ocl *oclObj = (ocl *)malloc(sizeof(ocl));
	oclObj->getmycla();
	
	system("pause");
	return 0;
}

可见输出是一个未初始化的a。

解法二：

先上代码吧

class myder:mycl		//同样是派生一个子类
{
public:
	using mycl::geta;
	myder(mycl &base):mycl(base)
	{
		 //geta();
	}
};
int main()
{
	int data[2] = {0, 1};						//为下文修改内存分配策略
	mycl* pacl = reinterpret_cast<mycl*>(data);	//基于位的强制转换
	myder ader(*pacl);	
	ader.geta();
	
	system("pause");
	return 0;
}

从以上代码可以看出，还有第二种方法来绕开默认构造函数的自动调用。

注意到mycl类的大小是8个字节，前四个字节是一个指针，指向虚函数表的地址，后四个字节则是类成员a的大小了。所以可以定义一个大小为8个字节的int型数组:  int data[2] = {0, 1};  再利用强制转换：mycl* pacl = reinterpret_cast<mycl*>(data); 则可以构造一个对象，相应的，后四个字节的值为1，a则被初始化为1(怎么感觉hack进了类的内存，所以这种强制转化要慎用)。

但是这样强制转化之后，类虚函数表指针指向的值为0，也就是说并没有初始化虚函数表，所以还需要一种手段来初始化虚函数表。弄一个子类然后调用复制构造函数，就能实现虚函数表的自动初始化。(注意到子类复制构造函数中有一行注释掉的geta()，把注释去掉的话，直接调用子类复制构造函数便能调用基类的geta()，当然像现在这样，声明了using:mycl::geta(),直接在子类外头调用也行)

解法三：

这种方法不用构建一个子类。可直接hack进类的虚函数表，通过函数指针来调用虚函数，即使该虚函数是private也管用。代码：

int main()
{
	mycl *ba = (mycl *)malloc(sizeof(mycl));
	mycl acl = *ba;							//调用复制构造函数，自动初始化虚函数表
	ba = &acl;		
	typedef void (*func)(void);
	func pF = (func)*((int*)*(int*)ba);
	pF();
	system("pause");
	return 0;
}

这里解释一下虚函数表以及虚函数地址的获取方式：

(int*)ba，获得虚函数表地址；
*(int*)ba，解引，获得虚函数表；
(int*)*(int*)ba，获得第一个虚函数地址；
*((int*)*(int*)ba)，获得第一个虚函数；

但是这种方法还有一种缺陷，就是函数指针pF并不知道ba的this指针的地址，所以通过pF调用的函数，a的值不是正确的，可能是任意内存位置的值。方法是改变函数指针的类型定义以及虚函数地址的传递方式。

int main()
{
	mycl *ba = (mycl *)malloc(sizeof(mycl));
	mycl acl = *ba;							//调用复制构造函数，自动初始化虚函数表
	ba = &acl;		
	typedef void (mycl::*func)(void);
	func pF = (*(func*)(*(int*)ba));
	(ba->*pF)();
	system("pause");
	return 0;
}

可以看出pF定义为 (mycl::*func)(void) 类型，即可以视为mycl的一个成员函数，通过 (*(func*)(*(int*)ba));的方法(获取虚函数表后，通过 *(func*) 的方法获取第一个虚成员函数)，复制给pF。再通过 (ba->*pF)(); 的方式调用，可以认为中间的->就把this指针传给了pF函数。这样就能获得正确的a的值，大家可以拿int data[2] = {0, 1};来初始化ba，再通过hack虚函数表的方式获取a的值，就能发现这种方法是正确的。

陈皓在这篇文章http://blog.csdn.net/haoel/article/details/1948051也说了，c++是有缺陷的，c++也有其危险性，但是了解它的这种危险性能让我们更好的学习这门语言，以下这篇文章也在内存级别分析了C++类的继承原理：

http://www.cnblogs.com/DylanWind/archive/2009/01/12/1373919.html

谢谢大家！！！