C++的虚函数、多态性

实现多态的三个条件：

（1）要有继承

（2）要有虚函数重写

（3）用父类指针（父类引用）指向子类对象（Parent *p = new Child）

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

首先我们定义两个类：

class Animal
{
public:
	void sayHello()
	{
		cout << "Hello,我是Animal" << endl;
	}

private:

};

class Cat : public Animal
{
public:
	void sayHello()
	{
		cout << "Hello,我是Cat" << endl;
	}

private:

};

Cat继承Animal

int main()
{
	Animal p;
	Cat c;
	p.sayHello();
	c.sayHello();


	system("pause");
	return 0;
}

输出结果：

很正常，但多态的另一个关键之处是父类的指针或引用指向子类的对象，我们添加代码：

int main()
{
	Animal p;
	Cat c;
	p.sayHello();
	c.sayHello();

	cout << "--------------" << endl;

	//基类指针指向子类对象
	Animal *p1 = &p;
	Animal *p2 = &c;

	p1->sayHello();
	p2->sayHello();

	cout << "--------------" << endl;

	system("pause");
	return 0;
}

输出结果：

问题来了：p2明明指向的是Cat的对象但却是调用的Animal的sayHello()函数，这不是我们所期望的结果，那么解决这个问题就需要用到虚函数

class Animal
{
public:
	virtual void sayHello()
	{
		cout << "Hello,我是Animal" << endl;
	}

private:

};

class Cat : public Animal
{
public:
	virtual void sayHello()//这里的virtual有没有都可以
	{
		cout << "Hello,我是Cat" << endl;
	}

private:

};

输出结果：

指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

虚函数是如何做到因对象的不同而调用其相应的函数的呢？

由于这两个类中有虚函数存在，所以编译器就会为他们两个分别插入一段你不知道的数据，并为他们分别创建一个表。那段数据叫做vptr指针，指向那个表。那个表叫做vtbl，每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址。但是Animal::sayHello()是如何被调用的呢？它像普通函数那样直接跳转到函数的代码处吗？No，其实是这样的，首先是取出vptr的值，这个值就是vtbl的地址，再根据这个值来到vtbl这里，由于调用的函数Animal::sayHello()是第一个虚函数，所以取出vtbl第一个里的值，这个值就是Animal::sayHello()的地址了，最后调用这个函数。现在我们可以看出来了，只要vptr不同，指向的vtbl就不同，而不同的vtbl里装着对应类的虚函数地址，所以这样虚函数就可以完成它的任务。

虚函数的实现机理详见：http://blog.csdn.net/haoel/article/details/1948051

对于多态性，多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略。

我们来看个例子：

首先定义三个类，Num2类继承Num类，Base为基数类：

class Num
{
public:
	virtual int numPrint()
	{
		this->a = 10;
		return a;
	}

private:
	int a;
};

class Num2 : public Num
{
public:
	virtual int numPrint()
	{
		this->a = 30;
		return a;
	}

private:
	int a;
};

class Base
{
public:
	int numPrint()
	{
		this->a = 20;
		return a;
	}

private:
	int a;
};

我们实现一个比较的算法

int main()
{
	Num n1;
	Num2 n2;
	Base b;

        //一般写法
	if (n1.numPrint()>b.numPrint())
	{
		cout << "n1:" << n1.numPrint() << endl;
	}
	else
	{
		cout << "n2:" << b.numPrint() << endl;
	}

	if (n2.numPrint() > b.numPrint())
	{
		cout << "n2:" << n2.numPrint() << endl;
	}
	else
	{
		cout << "n3:" << b.numPrint() << endl;
	}


	system("pause");
	return 0;
}

输出结果：

多态写法：

void Polymorphic(Num *n,Base *b)
{
	if (n->numPrint() > b->numPrint())
	{
		cout << "n:" << n->numPrint() << endl;
	}
	else
	{
		cout << "b:" << b->numPrint() << endl;
	}
}

int main()
{
	Num n1;
	Num2 n2;
	Base b;

	Polymorphic(&n1,&b);
	Polymorphic(&n2, &b);


	system("pause");
	return 0;
}

这样一来，以后我们增加子类Num3的话，也可以非常容易的进行比较，具备了良好的扩展性

不写virtual的话是静态联编，C++会根据传入的类型去执行这个类型中的函数，在编译器的编译阶段就已经决定了函数的调用，如果写virtual的话就是动态联编，也叫迟绑定，在程序运行时根据具体的对象（类型）去执行不同的函数，表现成多态