C++之多态

C++之多态

1.多态概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
例如：买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2.分类

静态多态：

程序在编译期间已经确定了函数的行为（静态绑定||早绑定）
例如：函数重载

动态多态：

在程序运行时，才可以确定函数的行为，即在编译阶段无法确定到底要调用哪个函数（动态绑定||晚绑定）
例如：使用基类的引用或指针调用一个虚函数

3.动态多态实现条件

• 必须在继承体系之下
• 必须通过基类的指针或者引用调用虚函数
• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

如：

4.虚函数

虚函数：被virtual修饰的类成员函数称为虚函数
如：

class Person {
public:
		virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

1.虚函数的重写

重写（覆盖）：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类函数的返回值类型、函数名字、参数列表完全相同），称子类的虚函数重写了基类的虚函数
如：

class Person {
public:
		virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
		virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
//再重写虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了在派生类中依然保持虚函数属性，但是这种写法并不规范，所以不建议使用）

void Func(Person& p){
	p.BuyTicket();
}

int main(){
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

2.虚函数重写的两个例外

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

如：

class Person {
public:
	virtual A* f() {return new A;}
};
class Student : public Person {
public:
	virtual B* f() {return new B;}
};

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

代码：

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};

class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main(){
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	system("pause");
	return 0;
}

3.C++11 override 和 final

C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

• final:修饰虚函数，表示该虚函数不能再被重写

class Person{
public:
	virtual void fun() final{}
};

class Student:public Person
{
public:
	virtual void fun() {
		cout<<"学生"<<endl;
	}
};

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

class Person{
public:
	virtual void fun(){}
};

class Student:public Person{
public:
	virtual void fun() override {cout<<"学生"<<endl;}
};

4.重载、重写、重定义的对比

5.抽象类

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

class Car
{
public:
	virtual void Drive() = 0;
};
class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};
void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
    pBMW->Drive();
}
int main(){
	Test();
	system("pause");
	return 0;
}

接口继承和实现继承：

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现
虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口
因此如果不是要实现多态，就不要定义虚函数

6.多态原理

如果访问的为虚函数，则通过指针/引用找到实际指向的实体，获取实体中的虚表指针，通过虚表指针访问虚表，在虚表中找到需要执行的虚函数指针，通过虚函数指针执行具体函数行为

7.虚函数表

虚函数表，称为V-Table。虚函数表是一片连续的内存区域，每个内存单元存放着JMP指令地址。
虚函数表实际上是一个数组，其中存储了为类对象进行声明的虚函数的地址。
我们在声明了一个虚函数类的对象的同时，这个对象被添加了一个隐式成员。该成员保存了指向虚函数地址数组的指针,如下图所示：

只要包含虚函数的类就会有一个虚函数表，当这个表是基类时，它的派生类也会有相应的虚函数表，当一个类有多个对象时，这些对象共享一个虚函数表

具体过程：

class Base{
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b;
};

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main(){
	Base b;
	Derive d;
	//虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
	//所以取出b、d对象的头4bytes就是虚表的指针
	//1.先取b的地址，强转成一个int*的指针
	//2.再解引用取值，就取到了b对象头4bytes的值，这个指针就是指向虚表的指针
	//3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型（虚函数指针类型）的数组
	//4.虚函数指针传递给PrintvTable进行打印虚表
	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	system("pause");
	return 0;
}

如多对子类重写的虚函数进行注释：

则结果为：

可见：派生类重新实现了基类中的虚函数，那么派生类的虚函数表将保存新的函数地址。如果派生类并未对虚函数做改动，那么虚函数表将保存原始函数地址。也就是说，派生类的虚函数表进行改动并不会对基类的虚函数表有影响。

总结：

影响： 每个对象的大小都会增大一个存储地址的空间，用来存放隐藏成员代表指向的地址。
对于每个含有虚函数的类，编译器都会创建一个虚函数表；
每次调用虚函数，都需要经历一次寻址过程，到虚函数表中寻找虚函数地址，耗费了时间。
构造函数不能是虚函数。当初始化派生类对象的时候，将调用派生类的构造函数，之后派生类的构造函数又会调用基类中的构造函数，这种顺序不同于继承机制，所以派生类不能继承基类的构造函数，因此将构造函数声明称虚函数没有用。
析构函数应该声明为虚函数。
友元不能是虚函数，因为虚函数必须是成员函数，而友元不是成员类。但是友元函数可以使用虚函数