关于基类与派生类之间指针转化关系小结

<pre name="code" class="cpp"><pre name="code" class="cpp">#include <iostream>
#include <vector>
using namespace std;

class A
{
private:
	int val;
public:
	A(int _val = 0):val(_val){cout<<"A构造函数执行"<<endl;}
	virtual ~A(){cout<<"A析构函数执行"<<endl;}

	int Get_val()const {return val;}
	void Set_val(int _val){val = _val;}
};

class B : public A
{
private: 
	int pos;
public:
	B(int _pos):pos(_pos){cout<<"B构造函数执行"<<endl;}
	~B(){cout<<"B析构函数执行"<<endl;}

	int Get_pos()const {return pos;}
	void Set_pos(int _pos) {pos = _pos;}
};
int main()
{
	A* pObjectA;
	B* pObjectB = new B(2);
	pObjectA = pObjectB;
	pObjectA->Get_val();	//基类指针指向派生类，动态绑定，由于Get_val()不是虚函数，只能调用基类中的函数，不能调用派生类中的函数
	//delete pObjectA;	//执行结果：A构造函数执行 B构造函数执行 B析构函数执行 A析构函数执行	
	((B*)pObjectA)->Set_pos(10);	//基类指针转化为派生类，因为指针指向的内存本身是派生类new得到的，所以能够正确访问派生类函数
	cout<<pObjectB->Get_pos()<<endl;//10
	delete ((B*)pObjectA);	//执行结果：A构造函数执行 B构造函数执行 B析构函数执行 A析构函数执行

	A* pObjA = new A();
	int numA = ((B*)pObjA)->Get_pos();//基类指针转化为派生类,打印结果为随机数,因为程序试图访问一个自己并没有的成员  
	cout<<"numA="<<numA<<endl;//随机数
	delete pObjA;

	A* pTestA = new A(5);
	B* pTestB;
	//pTestB = pTestA;	//派生类指向基类不安全，需强制转换才行
	delete pTestA;	
	
	vector<A*> pvClassA;
	B* pNewB = new B(22);
	pvClassA.push_back(pNewB);
	vector<A*>::iterator iter = pvClassA.begin();
	(*iter)->Get_val();	//也是基类指针指向派生类，只能调用基类中的函数
		
	B* pNewB2 = new B(55);
	pvClassA.push_back((A*)pNewB2);
	vector<A*>::iterator iter2 = pvClassA.begin()+1;
	(*iter2)->Get_val(); //先将派生类指针转换为基类指针，也是只能调用基类函数

	delete pNewB;
	delete pNewB2;

	return 0;
}