C++中多态理解

一、多态的概念

• 通俗的说，就是使用相同的接口实现不同的功能。

1.形成多态的条件：

• 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

形成的条件：
（1）子类要继承父类。
（2）子类要重写父类的虚函数。
（3）要用父类的指针或应用调用虚函数。

例如：

class people
{
public:
	virtual void fun()  //虚函数
	{
		printf("this is people::fun()\n");
	}

	virtual void print()  //虚函数
	{
		cout << "this is people::print()" << endl;
	}

private:
	int _val;
};

class student : public people //子类继承父类
{
	void fun()
	{
		cout << "this is student::fun()" << endl;
	}
	void print()
	{
		cout << "this is student::print()" << endl;
	}
private:
	int _sval;
};

void Func(people& pe)//相同的接口
{
	pe.fun();
	pe.print();
}

int main()
{
//实现不同的功能
	people pu;
	Func(pu);

	student stu;
	Func(stu);

	return 0;
}

2.虚函数的重写：

• 虚函数的重写(覆盖)：子类中有一个跟父类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
  例如上述代码。

两个特例：

1. 协变(基类与派生类虚函数返回值类型不同)：
   派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引
   用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

代码如下：

class Person 
{
public:
	virtual Person* f()
	{ 
		cout << "this is Person:f()\n";
		return nullptr;
	}
};
class Student : public Person 
{
public:
	virtual Student* f() 
	{ 
		cout << "this is Student:f()\n";
		return nullptr;
	}
};
void Func(Person& p)
{
	p.f();
}
int main()
{
	Student stu;
	Func(stu);
	return 0;
}

2. 析构函数的重写(基类与派生类析构函数的名字不同)：
   如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

注意：子类重写父类的虚函数，即使没加virtual，子类重写的函数也是虚函数。

3.C++中override和final:

1. final：修饰虚函数，表示该虚函数不能再被继承.

class Car
{
	public:
	virtual void Drive() final //不可被重写
	{}
};
class Benz :public Car
{
public:
	virtual void Drive() 
	{
		cout << "Benz-舒适" << endl;
	}
};

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错.

class Car
{
public:
	virtual void Drive()
	{}
};
class Benz :public Car
{
public:
	virtual void Drive() override//是否重写了基类的虚函数
	{cout << "Benz-舒适" << endl;}
};

二、多态的原理

1.抽象类：

（1）概念：在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Person
{
public:
	virtual Person* f()=0
	{
		cout << "this is Person:f()\n";
		return nullptr;
	}
};
class Student : public Person
{
public:
	virtual Student* f()
	{
		cout << "this is Student:f()\n";
		return nullptr;
	}
};

void Func(Person& p)
{
	p.f();
}
int main()
{
	//Person pe;//错误，基类无法在实例化对象
	Student stu;
	Func(stu);
	return 0;
}

（2）接口继承和实现继承：
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

2.多态原理：

先看下面一段代码：

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person 
{
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
	return 0;
}

调试运行结果：

1.可以看出，对象Mike中有一个_vfptr(虚函数表指针)，大小占四个字节。
2.子类也存在一个_vfptr,它与基类的不同，说明子类也有一个虚函数表指针。
3.虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。

3.动态绑定与静态绑定：

（1）静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
（2）动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。