接上一回C++：补继承漏洞+多态原理（带图详解）

引子：接上一回我们讲了继承的分类与六大默认函数，其实继承中的菱形继承是有一个大坑的，我们也要进入多态的学习了。

注意：我学会了，但是讲述上可能有一些不足，希望大家多多包涵

继承复习：

1，继承中的友元函数不能继承！（就比如说，你爸爸的朋友不是你朋友，你朋友不时你爸爸的朋友）

2，继承中的static：基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例（可以通过地址来看是否一样）

继承补漏洞（数据冗余与二义性）：

1. 什么是菱形继承？菱形继承的问题是什么？

菱形继承：菱形继承是多继承的一种特殊情况。

菱形继承有数据冗余和二义性的问题

如下图：西红柿，里面就有二个植物的属性，这与我们常识不符

2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的

关键字：virtual ，虚拟继承可以解决菱形继承的二义性和数据冗余的问题

3. 继承和组合的区别？什么时候用继承？什么时候用组合？

继承其实是is a的关系，组合其实是has a 的关系，

组合耦合度更低，关联性较低，比较适用与接口，继承耦合度更高，关联性比较强，比较收到父类的较大影响，往往一发而牵全身，故在现实生活，公司里能用组合就用组合，在继承的情况下就使用继承，（其实也是一种"黑箱白盒"的思想），白盒要求更高，黑盒则只要功能实现，故黑盒难度更低，而我们组合本质上就是一种黑盒，实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

多态基础知识：

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

多态的构成条件

1. 必须通过基类的指针或者引用调用虚函数

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

虚函数：

即被virtual修饰的类成员函数称为虚函数，虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

抽象类：

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

虚函数重写的两个例外：

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

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

试例代码：

class person
{
public:
   //virtual void ticket() = 0
   //在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口
   //类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生
       //类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承
   virtual void ticket()
   {
       cout << "买全票" << endl;
   }
   virtual ~person()
   {
       cout << "~person" << endl;
   }
};
class children :public person
{
public:
   virtual void ticket()
   {
       cout << "买半票" << endl;
   }
   ~children()
   {
       cout << "~children" << endl;
   }
};
class soldier :public person
{
public:
   virtual void ticket()
   {
       cout << "优先买票" << endl;
   }
   ~soldier()
   {
       cout << "~soldier" << endl;
   }
};
//产生多态的条件(语法规定）
//1,虚函数重写
//2，必须是父类引用调用虚函数或者父类指针

void func1(person &p)
{
p.ticket();
}
void func2(person*p)
{
p->ticket();
}

//协变
//析构函数的重写，编译器在编译的时候，统一变为destructor;
int main()
{
   person s1;
   children s2;
   soldier s3;
   func1(s1);
   func1(s2);
   func2(&s1);
   func2(&s2);
   func1(s3);
   func2(&s3);
   //隐藏关系大于重写
   s2.ticket();
   person* s4 = new soldier;
   person* s5 = new person;
   person* s6 = new children;
   delete s5;
   delete s4;
   delete s6;

return 0;

}

多态的原理：

我们先看一下以下代码的结果：

//查看虚拟函数的地址-->虚表
//虚函数开辟有一定的空间消耗
   //参看各个虚函数的地址，与普通函数的区别
class Base
{
public:
   virtual void Func1()
   {
       cout << "Base::Func1()" << endl;
   }
   virtual void Func2()
   {
       cout << "Base::Func2()" << endl;
   }
   void Func3()
   {
       cout << "Base::Func3()" << endl;
   }
private:
   int _b = 1;
};
class Derive : public Base
{
public:
   virtual void Func1()
   {
       cout << "Derive::Func1()" << endl;
   }
private:
   int _d = 2;
};
void func(Base& p)
{
   //这是动态的一个（直接在虚表中找到的func）
   p.Func1();
   //静态编译的func(是在链接产生的符号表！)
   p.Func3();
}
//切割父类的那一部分！
int main()
{
   Base b;
   Base b2;
   Base b3;
   Derive d;
   func(b);
   func(d);
   int h1=2;
   static int h2=3;
   int* h3 = new int;
   const int h4=1;
   printf("栈区%p\n", &h1);
   printf("静态区：%p\n", &h2);
   printf("堆区：%p\n", &h3);
   printf("常量区：%p\n", &h4);
   //相关关系关联的成度
   printf("%p\n", *((int*)&b));
   printf("%p\n", *((int*)&d));
   /*printf("%p ", &Base::Func1);
   printf("%p ", &Base::Func2);
   printf("%p ", &Base::Func3);
   printf("%p ", &Derive::Func1);*/
   return 0;
}

结果运行如下：

一：虚函数指针存在对象中，有一个void**的指针

二：虚函数的地址相对其他非常相近，都是在代码区，

三，（1），多个虚函数地址如果类型一样，他们的地址都是一样的，就是共享虚表（2），注意取出前四位地址是（（int）&b）;（3），虚函数表，存在常量区

四，继承的虚函数地址没有改变，重写的虚函数地址改变，

多态原理文字解释（虚表本质是函数指针数组）：

void->虚函数，存在代码区

void*->虚函数表，存在常量区

void**->虚函数表的指针，存在对象中

看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

其实多态本质上是一种动态绑定又称后期绑定。普通函数是静态绑定又称为前期绑定(早绑定)，

什么是动态绑定与静态绑定？如下

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载 2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。 3. 本小节之前(5.2小节)买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑定。