C++中关于子类指针指向基类对象

在C++的学习过程中，不可避免的我们会遇上基类指针指向子类对象的情况，这种情况是这样的，当成员函数被声明为虚函数时，通过基类指针或引用调用该虚函数时，被调用的函数是属于子类的那一个，这其实就是我们所说的多态。

今天，我们讨论另外一种不是特别常见的情形：子类指针指向基类对象。

我们知道：子类指针或引用转化为基类指针或引用是可隐式转化的，我们称这为上行转换。

但是下行转换呢，即基类指针转为子类指针。

隐式转换是行不通的，必须强制转换。举例如下：

#include <iostream>
using namespace std;

class Rectangle
{
protected:
	int chang;
	int kuang;
public:
	Rectangle(int a = 5, int b = 3) :chang(a), kuang(b) {}
	~Rectangle() {}

	virtual int print()
	{
		cout << "Rectangle" << endl;
		return 0;
	}
};

class   Square :public Rectangle
{
public:
	Square(int b) :Rectangle(b, b) {}
	~Square() {}

	virtual int print()
	{
		cout << "Square" << endl;
		return 0;
	}	
};

int main()
{

	Rectangle *rec = new Rectangle();
	Square* squ1 = (Square*)(rec);
	Square* squ2 =static_cast<Square*>(rec);     // squ2 不为 NULL, 不安全
	Square* squ3 = dynamic_cast<Square*>(rec);   // squ3 为 NULL,
	if (squ3 == NULL)
		cout << "squ3 is null" << endl;
	system("pause");
	return 0;
}

至于static_cast与dynamic_cast的区别，有兴趣的同学可以另找资料学习，这里我们暂且略过。

我们要讨论的问题是：这个指向基类对象的指针调用成员函数时调用的是谁的成员函数。

这里我们先放结论：成员函数是虚函数时，调用的是基类的成员函数，成员函数为一般函数时，调用的是子类的成员函数。

例子如下：

#include <iostream>
using namespace std;

class Rectangle
{
protected:
	int chang;
	int kuang;
public:
	Rectangle(int a = 5, int b = 3) :chang(a), kuang(b) {}
	~Rectangle() {}

	virtual int print()
	{
		cout << "Rectangle" << endl;
		return 0;
	}
	int get()
	{
		cout << "Rec" << endl;
		return 0;
	}
};

class   Square :public Rectangle
{
public:
	Square(int b) :Rectangle(b, b) {}
	~Square() {}

	virtual int print()
	{
		cout << "Square" << endl;
		return 0;
	}	
	int get()
	{
		cout << "Squ" << endl;
		return 0;
	}
};
int main()
{

	Rectangle *rec = new Rectangle();
	Square* squ = (Square*)(rec);
	squ->print();    // 调用 Rectangle::print();
	squ->get();      // 调用 Square::get();
	system("pause");
	return 0;
} 

解释如下：

1. 子类指针指向基类对象

2. 虚函数调用时，会先找到对象，而该对象是基类对象，基类对象中含有指向基类虚函数表的指针，所以调用的是基类的虚函数

3. 普通成员函数的调用和普通函数的调用实质上没有区别，只是传参调用，参数是指向子类的指针，自然调用的是子类的成员函数。