C++继承部分总结

    C++是一门面向对象的语言，所以它的大部分操作都与类和方法息息相关，而C++语言也具有三大特性：封装、继承和多态。刚好我学习到的内容涉及到了继承，为了防止遗忘在此进行一下相关的总结。

    继承从字面上的意思来看就是子承父业，继承首先需要的是一个子类和一个父类。从一个类派生出另一个类时，原始类称为基类，继承类称为派生类。为说明继承首先需要一个基类。

class A
{
public:
	A()
	{

		cout<<"establish:A()"<<endl;
	}
	~A()
   {
	   cout<<"des A()"<<endl;
	}
	int _a=2;
};
class B:virtual public A
{
	public:
	B()
	{

		cout<<"establish:B()"<<endl;
	}
	~B()
   {
	   cout<<"des B()"<<endl;
	}
	int _b=3;
};
int main()
{
    B b;
    cout<<b._a<<endl;
    return 0;
}

   打印结果是2。

   由此我们可以看出一点，B中有A的成员_a,在这个简单的函数中，我们把A称为基类，B继承了A我们把B类称为派生类，因为B使用的是A的部分成员。这样做的目的就是为了减少重复的工作量。在B中我们可以看到属于B特有的成员_b。在C++中，所谓继承就是在一个已有类的基础上建立一个新的类。已存在的类称为基类，或父类。新建立的类称为“派生类”或者子类，类的每一次派生都继承了其基类的基本特征，同时又根据需要调整和扩充原有的特征。

  一个派生类不仅可以从一个基类派生，也可以从多个基类派生，也可以说一个派生类可以有两个或多个基类。

    关于基类和派生类的关系，简单来讲就是：派生类是基类的具体化，而基类则是派生类的抽象。

    接着来讲继承，继承有三种继承方式，公有继承，私有继承和保护继承。

    继承的函数写法如下：

     class 派生类名：[继承方式]基类名

     {

        派生类新增加成员

       }；

     三种继承方式也有着各自不同的特点：

    然而私有继承和保护继承在我们正常使用中并非经常被使用到，因为私有继承和保护继承在使用中经常容易被搞错，所以使用时一定要格外注意。

     使用三种继承方式时需要注意以下几个方面：

     1. 基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要 在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

     2. public继承是一个接口继承，保持is-a原则，每个父类可用的成员对子类也可用，因为每个子类 对象也都是一个父类对象。

     3. protected/private继承是一个实现继承，基类的部分成员并非完全成为子类接口的一部分， 是 has-a 的关系原则，所以非特殊情况下不会使用这两种继承关系，在绝大多数的场景下使用的 都是公有继承。私有继承以为这is-implemented-in-terms-of(是根据……实现的)。通常比 组合(composition)更低级，但当一个派生类需要访问基类保护成员或需要重定义基类的虚函 数时它就是合理的。

      4. 不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存 在但是在子类中不可见（不能访问）。 

      5. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

      诚然，类中拥有的构造函数，析构函数等在继承中同样也会被调用。只不过在其中有着些许的不同。函数编译时，先按照继承列表中的顺序调用基类构造函数，然后再调用派生类中对象构造函数，最后调用派生类构造函数体。而在继承关系中析构函数调用过程，首先调用派生类的析构函数，再调用派生类包含成员对象析构函数，最后调用基类析构函数。  但是需要注意的是，基类没有缺省构造函数，派生类必须要在初始化列表中显式给出基类名和参数列表。如果基类没有定义构造函数，则派生类也可以不用定义，全部使用缺省构造函数。  而如果基类定义了带有形参表构造函数，派生类就一定定义构造函数。

    在各种各样的继承中，我们会发现许多问题，首先就是同名问题，如果在基类和派生类中存在同名函数，子类成员将屏蔽父类成员的直接访问，因为在继承体系中存在这不同的作用域，基类和派生类是两个不同的作用域，派生类在访问函数时，会隐藏基类的同名函数，这就是函数的同名隐藏。说到访问，同样需要注意的是子类对象可以赋值给父类对象，但是父类对象不可以给子类对象赋值（毕竟先构造基类，基类已经构造好如何再去赋值）。父类的指针（引用）可以指向子类对象，同理子类的指针不可以指向父类对象。

    继承的使用大大缩减了我们对于一些重复工程花费的有用时间，但是多重继承也会带来一些问题，它大大地增加了程序的复杂程度，使程序的编写和维护出现了许多未知的问题。最为显著的问题就是二义性的问题。例如：

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

		cout<<"establish:A()"<<endl;
	}
	~A()
   {
	   cout<<"des A()"<<endl;
	}
	int _a;
};
class B:virtual public A
{
	public:
	B()
	{

		cout<<"establish:B()"<<endl;
	}
	~B()
   {
	   cout<<"des B()"<<endl;
	}
	int _b;
};
class C:public A
{
	public:
	C()
	{

		cout<<"establish:C()"<<endl;
	}
	~C()
   {
	   cout<<"des C()"<<endl;
	}
	int _c;
};
class D:publicB,public C
{
	public:
	D()
	{

		cout<<"establish:D()"<<endl;
	}
	~D()
   {
	   cout<<"des D()"<<endl;
	}
	int _d;
};
int main()
{
	D d;
	d._a=1;
	d._b=2;
	d._c=3;
	d._d=4;
	cout<<d._a<<endl;
	system("pause");
	return 0;
}

     这个程序在编译的时候系统会报错：对A的访问不明确。

      为什么会这样说呢。我们可以看看下图

      那么按照这个图来讲的话 我们在从派生类D中调用基类A的成员项时，因为派生类D中的成员继承的是派生类B和C中从基类A中继承的。所以当我们需要访问这个成员的时候，我们无法判断这个继承下来的成员是从B中还是从C中继承而来的。编译器无法判断便会报错。应对这样的问题我们可以使用d.A::_a来访问这个成员。但是这样需要在一个类中保留间接共同基类的多份同名成员，不仅占用较多的储存空间，还增加了访问这些成员时的困难，极容易出错。所以C++提供了虚拟继承来解决这个问题。只需要在需要继承的派生类前加virtual.就可以使该继承成为虚拟继承。我们将上面的类改造一下。

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

		cout<<"establish:A()"<<endl;
	}
	~A()
   {
	   cout<<"des A()"<<endl;
	}
	int _a;
};
class B: virtual public A
{
	public:
	B()
	{

		cout<<"establish:B()"<<endl;
	}
	~B()
   {
	   cout<<"des B()"<<endl;
	}
	int _b;
};
class C:  virtual  public A
{
	public:
	C()
	{

		cout<<"establish:C()"<<endl;
	}
	~C()
   {
	   cout<<"des C()"<<endl;
	}
	int _c;
};
class D:public B,public C
{
	public:
	D()
	{

		cout<<"establish:D()"<<endl;
	}
	~D()
   {
	   cout<<"des D()"<<endl;
	}
	int _d;
};
int main()
{
	D d;
	d._a=1;
	d._b=2;
	d._c=3;
	d._d=4;
	cout<<d._a<<endl;
	system("pause");
	return 0;
}

这样我们就可以方便的访问我们需要访问的成员。我们来分析一下虚拟继承。我们可以先计算一下虚拟继承使用前后的大小。经过计算，我们测试出在加vitrual时所占空间为
24个字节，没有加virtual时，sizeof出的值是20个字节。空间增加了四个字节。我们打开内存查看一下这多余的四个字节是什么

在这里我晕了一下 自认为多了两个指针应该多了八个字节，其实不然，因为原来内存中保存了两个成员，但是现在我们只需要保存一个成员值，这时候获取值得方法我们下面说，但是此时我们保存了两个指针，相对于原来的内存空间多了一个指针的空间的大小。刚好四个字节。

为什么这里会保存两个指针呢？为了搞清这一点我们直接打开这里所指向的空间。

上图展示了整个派生类的内部空间的情况，从中我们可以很明显地看出两个地址指向的内容，第一个地址打开后显示了一个数字14也就是十进制的20，而第二个地址显示的是一个0c对应十进制数字的12，可以看到B类的虚指针偏移20个字节刚好是基类A里的成员_a;可以看到C类的虚指针偏移12个字节刚好是基类A里的成员_a。这样就解决了我们前面所提到的重复存储以及派生类的二义性问题。虚拟继承实际上是存储了一个地址，地址中保存了相对于当前地址偏移量，节省了我们整体派生类D的空间。