基本信息

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

虚继承

用于解决多重继承的过程中成员访问的二义性(菱形继承)
格式: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 () {//为虚函数,即使没有关键字virtualcout << "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(); // 调用矩形的求面积函数 areashape = &tri;// 存储三角形的地址shape->area(); // 调用三角形的求面积函数 areareturn 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 functionvirtual int area() = 0;
};

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

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