虚继承的作用：防止产生二义性

先来看一看下面的一段代码吧：

#define _CRT_SECURE_NO_WARINGS
#include<iostream>
#include<string>
using namespace std;
class Grandfather
{
public:
	Grandfather() { cout << "爷爷的构造函数" << endl; }
	~Grandfather() { cout << "爷爷的析构函数" << endl; }
};
class Father :public Grandfather
{
public:
	Father() { cout << "爸爸的构造函数" << endl; }
	~Father() { cout << "爸爸的析构函数"<<endl; }
};
class Mother :public Grandfather
{
public:
	Mother() { cout << "妈妈的构造函数" << endl; }
	~Mother() { cout << "妈妈的析构函数" << endl; }
};
class Children :public Father, public Mother
{
public:
	Children() { cout << "儿子的构造函数" << endl; }
	~Children() { cout << "儿子的析构函数" << endl; }
};
int main()
{
	Children me;
	return 0;
}

下面我们再来看一看他的输出结果：

现在我们对运行结果进行分析不难得出：执行Children时必须先执行Father类（因为Children公有继承了Father）但是往前面找到Father类我们又发现它公有继承了Grandfather类，因此最先执行的是Grandfather的构造函数，再执行Father和Mother的构造函数，最后执行自己的构造函数。析构函数的话与构造函数的顺序相反。

在这条代码的输出结果中我们发现，Children继承了两次爷爷类，这无疑会增加程序的运行时间，如果我们只想继承一次爷爷类就要使用到虚继承的知识。虚继承可以使子类只继承一次父类的父类。实现方法很简单：就是在Father和Mother继承爷爷类之前加一个virtual即可

代码：

#define _CRT_SECURE_NO_WARINGS
#include<iostream>
#include<string>
using namespace std;
class Grandfather
{
public:
	Grandfather() { cout << "爷爷的构造函数" << endl; }
	~Grandfather() { cout << "爷爷的析构函数" << endl; }
};
class  Father :virtual public Grandfather
{
public:
	Father() { cout << "爸爸的构造函数" << endl; }
	~Father() { cout << "爸爸的析构函数"<<endl; }
};
class  Mother :virtual public Grandfather
{
public:
	Mother() { cout << "妈妈的构造函数" << endl; }
	~Mother() { cout << "妈妈的析构函数" << endl; }
};
class Children :public Father, public Mother
{
public:
	Children() { cout << "儿子的构造函数" << endl; }
	~Children() { cout << "儿子的析构函数" << endl; }
};
int main()
{
	Children me;
	return 0;
}

运行结果：

为什么析构函数必须是虚函数

首先我们先来复习一下

多态的三要素：

一、要有子类继承父类

二、要有虚函数

三、父类指针指向对象

来看看这个代码：

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

他的运行结果：

从运行结果我们可以发现：子类的析构函数没有被调用，子类的资源内存没有被释放，这会造成内存泄漏，解决方法很简单，我们把Father类的析构函数写成虚函数即可

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

模板类的继承（继承子类的所有属性）

继承的遗传性（继承基类的所有属性）

#include<iostream>
using namespace std;
class A
{
public:
	A(int a):a(a){}
	int a;
};

class B:public A
{
public:
	//B需要调用A的构造函数A（）
	B(int a,int b):b(b),A(a){}
	//int a; 有a的属性
	int b;
};
class C :public B
{
public:
	//C需要调用B的构造函数但是不需要调用A的构造函数
	C(int a,int b,int c):c(c),B(a,b){}
	//int a ,b;有a b 的属性
	int c;
};
class D :public C
{
public:
	//D只需要调用C的构造函数
	D(int a,int b,int c,int d):d(d),C(a,b,c){}
	//int a,b,c;有a b c的属性
	int d;

	void print()
	{
		cout << "a= " << a << " b= " << b << " c= " << c << " d= " << d << endl;
	}
};


int main()
{
	cout << "I Love You" << endl;
	D object(1, 2, 3, 4);
	object.print();
	return 0;
}

输出：

I Love You
a= 1 b= 2 c= 3 d= 4

214135

虚继承：多个派生类保存相同基类的同名成员时，虽可以在不同的数据成员中分别存放不同的数据 ，但我们只需要相同的一份。

解决了多父类重复成员只保留一份的问题。

比如现在有一个沙发床，它既有床的属性又有沙发的属性，它们都有长宽高的属性，但是我们却只需要知道它的一个状态的属性。

它的一个长宽高能体现多个状态。

家具{

属性：长，宽，高；

}

沙发床：public 沙发，public 床{

属性：长，宽，高；

}

沙发：public 家具   ----》改为：沙发：virtual public 家具

{

属性：长，宽，高；

}

床：public 家具   ----》改为：床：virtual public 家具

{

属性：长，宽，高；

}

我们只需要他们的共同属性长宽高就行了，我们可以把共同属性提出来作为家具类，再由不同状态继承（虚继承），但最后都归总于沙发床。

#include <iostream>
using namespace std;

class Base{
public:
    Base(int d=100):data(d){
        cout<<"Base()"<<data<<endl;
    }
    int data;
};

class A :virtual public Base{
public:
    A():Base(){
        cout<<"A()"<<data<<endl;
    }
    void setD(int d)
    {
        data = d;
    }
};

class B :virtual public Base{
public:
    B():Base(){
        cout<<"B()"<<data<<endl;
    }
    int getD()
    {
        return data;
    }
};

class C :public A,public B{
public :
    C():A(),B(),Base(100){
        cout<<"C()"<<data<<endl;
    }
    void dis(){
        cout<<data<<endl;
        cout<<A::data<<endl;
        cout<<B::data<<endl;
    }
};

int main(){
    C c;
    c.dis();
    c.setD(10000);
    c.setD(2000);
    cout<<c.getD()<<endl;
    c.dis();
}

更改床、沙发、沙发床的长宽高它们的不同状态的长宽高都会发生变化。

覆盖

覆盖就是子类会覆盖与父类相同的虚函数，下来看一个覆盖的代码：

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

class B :public A
{
public:
	void virtual f()
	{
		cout << "B" << endl;
	}
};

int main()
{
	A* pa = new A();
	pa->f();    //A
	B* pb = (B*)pa;
	pa->f();   // A
	
	delete pa, pb;
	pa = new B();
	pa->f();   //B
	pb = (B*)pa;
	pb->f();   //B
	return 0;
}

这是一个虚函数覆盖虚函数的问题，A中f是一个虚函数，虚函数是被子类同名函数所覆盖的。送一A类中的f函数会被B类中的f函数覆盖。很明显第一个输出是输出“A”，但是在 B* pb = (B*)pa;里面，该语句的意思是转化pa为B类型并新建一个pb指针，将pa赋值到pb，所以pa在这里是没有发生任何变化的，所以第二个pa->f也指向的是“A”。

delete pa,pb删除了pa,pb指向的地址，但pa，pb指针并没有被删除，这就是野指针（悬浮指针）,现在重新指向B类，而pa指针类型是A类的，父类的指针指向子类的对象，在这里就会发生覆盖。第三个打印的是“B”.pb=(B*)pa;转化pa为B类指针给pb赋值，但pa所指向的f函数是B类的f函数，所以pb所指向的f函数是B类的f函数，打印“B”。

虚继承

虚继承是多重继承中特有的概念，虚基类是为了解决多重继承而出现的。例如B继承A，C继承A,D同时继承BC，因此出现了交叉继承，在D类中会出现两个A，为了节省空间，可以将B，C对A的继承定义为虚拟继承，而A就成了虚基类，这就是所谓的菱形继承。

class A;
class B :public virtual A;
class C :public virtual A;
class D :public B, public C;

虚函数继承

下面看一段代码：

class A
{
public:
	virtual void a()
	{}
};
class B :public virtual A
{

public:
	virtual void b()
	{}
};
class C:public virtual A
{
public:
	virtual void c()
	{}
};
int main()
{
	cout << sizeof(A) << endl;   // 4
	cout << sizeof(B) << endl;   // 12
	cout << sizeof(C) << endl;   // 20
	return 0;  
}

A类中有一个虚函数，所以必须有一个对应的虚函数表来记录对应的函数入地址。所以有虚函数的类生成对象的前四个字节是一个指针，指向的是虚函数生成的虚函数表，所以A类的大小是4个字节。

对于B类，虚继承了A类，同时还拥有自己的系函数，那么B类有一个B类vfptr指针指向自己的虚函数表，这里大小是4个字节。可虚继承需要通过加入一个虚类指针记为vfptr_B_A来指向父类，这里大小也是4个字节，同时还有继承父类的所有内容sizeof(A)是4个字节大小，所以B类的大小是12个字节。

C类的话也有一个自己的vfptr_C指向自己的虚函数表，然后是一个虚类指针vfptr_C_B_A，同时还继承了B类的所有内容，所以大小是12字节+4+4 = 20字节。

这就是虚函数继承，虚继承不仅继承了所有父类内容，还有一个虚类指针来指向父类。这里的大小是在gcc编译下的结果，如果父类有一个指向自己虚函数的指针，会和子类共享这个父类的虚函数表的空间，不会占用子类的内存。在VC条件下编译不共享这个虚函数指针空间

纯虚函数

看下面代码有什么问题？

class A
{
public:
	A()
	{}
	~A()
	{}
	virtual void f() = 0;
};

int main()
{
	A a;

	return 0;
}

这个代码的问题出在A a;这里，因为A类中的f函数是一个纯虚函数，所以A类不能实例化对象。解决方法是将f（）函数修改成一般函数。