虚函数的使用

基类：

 

class Base
{
public:
	 void add();
	 ~Base();
};


Base::~Base()
{
	std::cout << "father is dying...\n";
}

void Base::add()
{
	std::cout << "I am father!" << std::endl;
}

 

 

 

派生类：

 

class derive :public Base
{
public:
	~derive();
	void add();//与基类同名的函数
};

derive::~derive()
{
	std::cout << "son is dying...\n";
}

void derive::add()
{
	std::cout << "I am son!" << std::endl;
}

 

 

测试代码：

int _tmain(int argc, _TCHAR* argv[])
{
	
	Base b1;
	derive b2;

	Base& a1 = b1;
	Base& a2 = b2;

	Base* a3 = &b1;
	Base* a4 = &b2;


	a1.add();
	a2.add();

	a3->add();
	a4->add();
	
	system("pause");
	return 0;
}

 

运行后结果：
I am father!
I am father!
I am father!
I am father!
由此可见，基类的引用或者指针，不论指向派生类还是基类，都只会调用基类的函数。
如果将基类的add()改成虚函数：

 

 

 

 

class Base
{
public:
	 virtual void add();
	 ~Base();
};

结果：
I am father!
I am son!
I am father!
I am son!
由此可见，在基类中，将可能重新定义的函数定为虚函数，之后会根据指针或引用指向的对象类型调用相应函数。这就是多态公有继承。

 

 

 

 

 

 

 

 

 

 

 

 

 

虚析构函数：

非虚析构函数情况下测试程序：

 

 

int _tmain(int argc, _TCHAR* argv[])
{
	Base* b1 = new derive;
	b1->add();
	delete b1;
	
	system("pause");
	return 0;
}

结果：
I am son!
father is dying...
由此可见，虽然删除的是派生类对象，但它调用的是基类的析构函数！
为了避免这种情况，在基类的析构函数前加上virtual：

 

 

class Base
{
public:
	virtual void add();
	virtual ~Base();
};

 

 

 

结果：
I am son!
son is dying...
father is dying...


由此可见，析构时，先调用了派生类的析构函数，然后调用了基类的析构函数。一般情况下，基类默认使用虚析构函数。