C++虚函数

转载自：黑凤梨の博客

虚函数

虚函数的定义

虚函数是C++实现多态性的主要手段之一。

对于发送消息的类的对象来说，不论它们属于什么类，发送的消息形式都一样，而对于处理信息的类的对象对同一信息反应不同称为多态性。

在基类中定义一个虚函数，其派生类继承该基类的虚函数，并且实现该函数。对于不同派生类的对象接受同一个信息，调用相同的函数名，操作不同。

#include <iostream>
using namespace std;
class base
{
public:
	virtual void vfunc()
	{
		cout << "This is base's vfunc()" << endl;
	}
};
class derived1 :public base
{
public:
	void vfunc()
	{
		cout << "This is derived1's vfunc()" << endl;
	}
};
class derived2 :public base
{
public:
	void vfunc()
	{
		cout << "This is dervied2's vfunc()" << endl;
	}
};
int main()
{
	base* p, d;
	derived1 d1;
	derived2 d2;
	p = &d;
	p->vfunc();

	p = &d1;
	p->vfunc();

	p = &d2;
	p->vfunc();
	cout << "-------------------------" << endl;
	d.vfunc();
	d1.vfunc();
	d2.vfunc();

	system("pause");
	return 0;
}

动态绑定和静态绑定

静态绑定的是对象的静态类型，在编译是绑定，然后通过对象来调用。
动态绑定的是对象的动态类型，在运行时绑定，然后通过地址来实现。

只有采用“指针->函数（）”或“引用变量.函数（）”的方式调用C++类中的虚函数才会执行动态绑定。

#include <iostream>
using namespace std;

class CBase
{
public:
	virtual int func() const
	{
		cout << "CBase function!" << endl;
		return 100;
	}
};

class CDerive :public CBase
{
public:
	int func() const
	{
		cout << "CDerive function!" << endl;
		return 200;
	}
};

int main()
{
	CDerive obj1;
	CBase* p1 = &obj1;//指针
	CBase& p2 = obj1;//引用变量
	CBase obj2;
	//静态绑定：调用对象本身（派生类CDerive对象）的func函数
	obj1.func();

	//动态绑定：调用被引用对象所属类（派生类CDerive）的func函数
	p1->func();//指针->函数（）

	//动态绑定：调用被引用对象所属类（派生类CDerive）的func函数
	p2.func();//引用变量.函数（）

	//静态绑定：调用对象本身（派生类CBase对象）的func函数
	obj2.func();

	system("pause");
	return 0;
}

抽象类和纯虚函数

在基类中不能对虚函数给出有意义的实现，而把它说明为纯虚函数，它的实现留给该基类的派生类去做。

带有纯虚函数的类称为抽象类。

纯虚函数：

#include <iostream>
using namespace std;

class shape
{
public:
	shape() {};
	virtual void draw() = 0;//纯虚函数
};
class rectangle :public shape
{
public:
	rectangle() {};
	void draw()
	{
		cout << "绘制一个矩形！" << endl;
	}
};
class round1 :public shape
{
public:
	round1() {};
	void draw()
	{
		cout << "绘制一个圆！" << endl;
	}
};
int main()
{
	shape* s;//基类指针对象
	s = new rectangle();
	s->draw();
	s = new round1();
	s->draw();


	system("pause");
	return 0;
}

抽象类的作用：
一个抽象类是不能定义对象的，只能作为基类来被继承，由它作为一个公共的接口，每个派生类都是从这个公共接口派生出来的。

#include <iostream>
using namespace std;

class Base
{
public:
	Base() { cout << "Base的构造函数！" << endl; };
	virtual ~Base() { cout << "Base的析构函数！" << endl; };
	virtual void HBJ() = 0;
};
class CBase :public Base
{
public:
	CBase() :Base() { cout << "CBase的构造函数！" << endl; };
	~CBase() { cout << "CBase的析构函数！" << endl; };
	void HBJ()
	{
		cout << "HBJ大帅比！" << endl;
	}
};
void H()
{
	CBase h;
	h.HBJ();
	cout << "---" << endl;
}
int main()
{

	H();

	system("pause");
	return 0;
}

抽象类的多重继承

一个派生类可以有多个基类，这样的继承机构称为多重继承。
子类多重继承了抽象类，并且实现了每个基类的纯虚函数。

#include <iostream>
using namespace std;

class AbstractClass
{
public:
	AbstractClass() {};
	virtual ~AbstractClass() {};
	virtual void toString() = 0;
};
class BbstractClass
{
public:
	BbstractClass() {};
	virtual ~BbstractClass() {};
	virtual void toDouble() = 0;
};
class SubClass :public AbstractClass, public BbstractClass
{
public:
	SubClass() :AbstractClass(), BbstractClass() {};
	~SubClass() {};
	void toString()
	{
		cout << "Sub::toString()"<<endl;
	}
	void toDouble()
	{
		cout << "Sub::Double()\n";
	}
};
int main()
{
	SubClass s;

	s.toString();

	s.toDouble();

	system("pause");
	return 0;
}