C++_虚继承_虚函数_纯虚函数(多继承的二义性,多态)

基本信息

每一个类都有一个虚表,以及虚表指针; 虚表的内容是编译器决定的,虚表中用于存放虚函数的指针, 程序运行时的类型信息等;
每个多态对象都存放着一个指向当前类型的虚表的指针, 该指针在构造函数中被赋值, 一般来说当调用当前这个类的构造函数, 则虚表指针就指向当前类的虚表

虚继承

用于解决多重继承的过程中成员访问的二义性(菱形继承)
格式:class 类名 : virtual 继承方式 基类类名
注:在虚继承的过程中,编译器会为子类创建一个虚表,以及一个虚基表指针(占用对象空间)指向虚表(不占用对象空间)
例:

#include<iostream>
using namespace std;
class A{
    private:
        int a;
    public:
        A(){cout<<"A()"<<endl;}
        ~A(){cout<<"~A()"<<endl;}
};
class B:virtual public A{
    private:
        int b;
    public:
        B(){cout<<"B()"<<endl;}
        ~B(){cout<<"~B()"<<endl;}
};
class C:virtual public A{
    private:
        int c;
    public:
        C(){cout<<"C()"<<endl;}
        ~C(){cout<<"~C()"<<endl;}
};
class D:public B,public C{
    private:
        int d;
    public:
        D(){cout<<"D()"<<endl;}
        ~D(){cout<<"~D()"<<endl;}
};
int main(){//64位虚表指针为8个字节
cout<<sizeof(A)<<endl; //输出4
cout<<sizeof(B)<<endl;//输出  B本身(4)+A(4)+虚表指针(8)=16
cout<<sizeof(C)<<endl;//输出与B相同
cout<<sizeof(D)<<endl;//输出 B+C+D本身-A(一份的A)=32    

上述代码中: B, C虚继承于A, 他们二者”共享”一份A(用集合的方式理解,A属于B, C的交集), 当D继承B,C的时候只会保留一份A在D中
若未采用虚继承在D创建对象的时候,会创建2份的A,出现冗余, 使用虚继承继承基类的两个虚指针,并调整虚指针与虚基类首地址的偏移量,使得继承过程中只保留一份的A
当使用虚继承的过程中,虚基类被共享,无论继承多少次,虚表指针都只会指向一份的虚基类,对象模型中只会存有一份的虚基类对象

虚函数

在基类中使用virtual修饰的成员函数,当函数声明为虚函数时,告诉编译器不要静态链接到该函数,而是根据程序的运行过程中动态地根据该对象类型来调用函数, 就所谓的多态
注:当基类成员函数声明为virtual, 子类进行对virtual重写,那么重写后的函数都为虚函数(即使该函数前面没写virtual关键字); 虚函数成员的virtual关键字只能出现在类中定义的函数原型前面, 不能出现在类外成员函数实现的前面
虚函数一般不声明为inline函数, inline函数属于静态绑定, 而虚函数的调用是动态绑定, 如果将虚函数作为inline函数也不会出错
构造函数, 静态函数, 复制构造函数不可做为虚函数, 原因只在于虚函数为动态绑定;

#include <iostream> 
using namespace std;
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0){
         width = a;
         height = b;
      }
    virtual  int area(){//编译时,生成一个虚表以及虚表指针
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
     virtual int area () {//为虚函数,即使没有关键字virtual
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
     virtual int area (){
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
   shape = &rec;
   shape->area(); // 调用矩形的求面积函数 area
   shape = &tri;// 存储三角形的地址
   shape->area(); // 调用三角形的求面积函数 area
   return 0;
}

此时，编译器看的是指针的内容(决定了能够调用哪些虚函数)，它指向的对象类型决定了该调用谁的虚函数。因此，由于 tri 和 rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。

动态绑定的底层实现:
虚表指针需要初始化才能调用虚函数,虚表指针在构造对象的时候初始化(初始化顺序与构造函数的调用顺序一致),当构造函数发现BASE具有虚函数,虚指针指向BASE的虚表中的虚函数,当执行构造子类对象的时候,子类中虚指针指向子类虚表中的虚函数;当对象创建好后,虚表指针指向的是子类的虚函数,从而对象调用虚函数时,实现多态

注:虚表会被继承,当子类重写虚函数的时候,那么虚表中的虚函数地址则会改变
在动态分配内存的时候,析构函数必须是虚函数(利用动态绑定)防止不会调用所需的析构函数
使用虚函数意味着多态,多态必须具备的三个条件:继承关系; 继承的过程中必须有同名的虚函数; 存在基类的指针或引用,通过该指针或引用调用虚函数

虚析构函数
析构函数可作为虚函数, 方便父类指针知道该调用哪个子类的析构函数(析构函数的多态)
一般情况下, 如果涉及到多态, 则将析构函数设置为virtual

#include<iostream>
using namespace std;
class BASE{
 public:
    ~BASE(){cout<<"父类析构函数"<<endl;}
};
class Derive:public BASE{
 public:
    Derive(){} 
    ~Derive(){cout<<"子类析构函数"<<endl;}
};
int main(){
    BASE *b=new Derive();
    delete b;
    return 0;
} 

//上述代码输出:父类析构函数,由于BASE指针偏移量的问题,未将父类析构函数设置为虚析构函数,导致静态绑定只会释放父类内存区,不会释放子类内存区,导致内存泄漏;
为了避免这种错误应将父类,子类的析构函数设置为virtual,则会解决这个问题
注: 子类对象析构函数的调用顺序,先调用子类析构函数, 然后调用父类析构函数, 调用顺序与构造函数调用顺序相反

纯虚函数 (抽象类)

在基类重定义纯虚函数,以便在派生类中重新定义该函数来适用于对象,纯虚函数就相当于接口,用于规范派生类行为
包含纯虚函数的类是抽象类,不能实例化, 当子类继承抽象类时,若没有实现纯虚函数, 则子类还是抽象类
语法: virtual void function()=0;
等于0表示没有函数体,

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

注: C++中,父类中的纯虚函可以有实现方式, 但是编译器会忽略, 父类依旧为抽象类, 由于抽象类不能实例化, 但是可以定义指针或引用, 通过指针和引用依旧能实现多态, 与Java中抽象类实现多态的方式一致
总结:

• 虚继承: 虚表基表, 虚基指针主要用来记录偏移量(虚基指针在虚基表上),以保证多继承的过程中只复制一份的基类
• 虚函数: 虚表,虚指针主要用于指向虚函数(虚指针指向虚表中的虚函数地址)
• 纯虚函数: 就是接口, 规范子类行为