c++初级——多态

多态的概念

多态的概念：通俗来讲，就是多种形态。

多态也有类别（我们把编译时⼀般归为静态，运⾏时归为动态）

运行时多态（静态多态）其中包括函数重载和函数模板，它们通过传不同类型的参数就可以调⽤不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，因为它们把实参传给形参的参数匹配是发生在编译时完成的。
编译时多态（动态多态）运⾏时多态，具体点就是去完成某个⾏为(函数)，因为传不同的对象就会完成不同的⾏为，从而达到多种形态。（比如说学生买票，老师买票，普通人买票，等它们的票价是不一样的）

多态的定义及实现

多态的构成条件

多态就是在继承关系下的类对象，去调用同一个函数，所产生的不同行为；

实现多态的重要条件

必须父类的指针或者引用调用虚函数；（因为只有父类的的指针或引用才能既能指向父类对象，又能指向子类对象。
被调用的函数必须是虚函数。且子类的虚函数要对父类的虚函数重写/覆盖。（因为重写或者覆盖了，⽗⼦类才能有不同的函数，多态的不同形态效果才能达到。）

虚函数

虚函数定义：

类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。

注意：

非成员函数不能加virtual修饰。
在继承关系中，类前加关键字virtual，就不能继承这个类；
友元函数不属于成员函数，不能成为虚函数

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

虚函数的重写/覆盖

子类中有⼀个跟父类完全相同的虚函数(即子类虚函数与父类虚函数的返回值类型、函数名字、参数列表完全相同)，称⼦类的虚函数重写了父类的虚函数。

注意：

重写就是三同
在重写⽗类虚函数时，⼦类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后⽗类的虚函数被继承下来了在⼦类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使⽤，不过在考试选择题中，经常会故意买这个坑，让你判断是否构成多态。

class Person {
public:
	virtual void buyticket()
	{
		cout << "全价" << endl;
	}
	
};

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

void func(Person* ptr)
{
	ptr->buyticket();
}

int main()
{
	Person p;
	Student s;
	func(&p);
	func(&s);
	return 0;
}

多态场景的⼀个选择题

输出结果是什么（）

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

class A
{
	public :
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};
class B : public A
{
	public :
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

B->1

这里主要涉及了一个规则：

函数的声明与内容是分离的，因为只有基础引用或者指针才能进行多态，所以test（）中的func的声明还是virtual void func(int val = 1) 但是因为是对象B的调用运行时查找了虚函数表函数内容却是调用 { std::cout << "B->" << val << std::endl; }。

多态中的其他问题

协变(了解)

子类重写父类的虚构函数时，与父类虚构函数的返回值不同即⽗类虚函数返回⽗类对象的指针或者引⽤，⼦类虚函数返回⼦类对象的指针或者引⽤时，称为协变。
协变的实际意义并不⼤，所以我们了解⼀下即可。

class A {};
class B : public A {};

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

class Student : public Person {
public:
	virtual B* BuyTicket()
	{
		cout << "买票-打折" << endl;
	}
};

析构函数的重写

⽗类的析构函数为虚函数，此时⼦类析构函数只要定义，⽆论是否加virtual关键字，都与⽗类的析构函数构成重写。
虽然看起来不符合规则，实际上编译器对继承类的析构函数做了处理, 编译后析构函数的名称统⼀处理成destructor，所有父类的析构函数加了vialtual修饰，子类的析构函数就构成重写。

这里就会有人有疑问；为什么继承类的析构函数一定要构成多态？

下面的代码就能很好的解释：

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

class B : public A {
public:
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};


int main()
{
	A* p1 = new A;
	A* p2 = new B;

	delete a;
	delete b;

	return 0;
}

简单说明一下：

仅看这段代码就能很好的解释为什么编译器要这样做；假设A没有加virtual 函数（也就是没有构成重写，多态），在调用 delete b 时。因为类型是 A 那么调用析构函数就是 A, _p 没有被删除从而造成内容泄露。
若析构函数构成多态，由于 p2 的对象是 B 在调用delete时会先查虚函数表，找到对应对象的函数，从而没有内存泄露。

override 和 final关键字

我们可以看出来，c++对函数重写要求特别严，如果有些情况下，由于我们的疏忽出现函数写错，或者其他错误无法构成重写，在编译期间也不会报错，只有在程序运行时没有才来bug，这种是很恶心的。
所以c++11提供了关键词override可以帮助⽤⼾检测是否重写。
如果我们不想让⼦类重写这个虚函数，那么可以⽤final去修饰。

重载、重写/覆盖、隐藏的对⽐

此外还有重定义：

重写和重定义是两码事,重写即覆盖，针对多态，重定义即隐藏
在同意作用域，两个函数就是重定义函数，这种情况是在预处理阶段会报错的。
编译阶段也会报错，编辑的时候因为融合了很多文件,主要是.c文件和.h文件,因为一个.c文件包括很多.h文件. 这里面很可能出现重定义的问题, 报错的话都是这么报的。多次声明不会报错。

其实我在两个文件中分别 int i; 不会报错

file1: int i = 9;

file2:int i;

也不会报错

file1: int i = 9;

file2:int i = 8;

报错

抽象类

纯虚数：

在虚函数数后面加上 “ = 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;
	}
};

int main()
{
	//C++ 不允许使用抽象类类型 的对象:            
	// 函数 是纯虚拟函数
	//Car car;

	Car* pbenz = new Benz;
	Car* pbmw = new BMW;
	
	pbenz->Drive();
	pbmw->Drive();

	return 0;
}

虚函数表指针

下⾯编译为32位程序的运⾏结果是什么（）

A. 编译报错 B. 运行报错 C. 8 D. 12

如果按照之前学的来计算，类内存大小的存放来算，那就是， C. 8；

但是在虚函数中，存在虚函数表这一概念，会在类对象中另外多储存一个虚函数表指针（实际就是函数指针数组）
⼀个含有虚函数的类中都至少有一个虚函数表指针，因为⼀个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。

多态的原理

多态是如何实现的

在满足多态后，底层调用函数不再是编译时就确定函数的地址，然后直接调用函数；（简单点说就是：指向谁调用谁）
而是运行时到指向对象的虚函数表中，确定虚函数地址，然后调用函数。如此就能指针或引用指向基类就调用基类的虚函数，派生类也是如此。
从对象角度看，所有代码语句都会转译成汇编指令，在编译指令时，看若满足多态，就会去指向的虚表选择对应函数地址；
从内存角度看，ptr一直指向的是person对象；但是由于多态，调用时还是看的是，虚表指针中的指向虚函数地址；

动态绑定与静态绑定

静态绑定：

对不满足多态条件(指针或者引用 + 调、虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。

这⾥就是静态绑定，编译器直接确定调⽤函数地址

动态绑定：

满足多态条件的函数调用是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数的地址，也就做动态绑定。

动态绑定，编译在运行时到ptr指向对象的虚函数表中确定函数地址，并调用这个地址。

（汇编区别就是：动态绑定先把ptr指向对象的虚函数表中对应虚函数地址找出来，然后在调用。静态绑定就是直接找函数地址，然后直接调用）

虚函数表

基类对象的虚函数表中存放基类所有虚函数的地址

派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。
要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。
派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函数地址。
因此可以认为派⽣类的虚函数表中包含：基类的虚函数地址，派⽣类重写的虚函数地址，派⽣类⾃⼰的虚函数地址三个部分。

基类虚表生生成的过程，逻辑上可以认为：