C++中的继承关系

                        C++中的继承关系

一、继承概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

简单的说，如果用继承关系来描述手机的发展的话，就如下图所示的关系：

    上图描述的是某手机的A、B、C三个版本，后一个版本总是在保持原有版本功能的情况下增加了自己新的功能。

下面我们来说说继承在C++中的作用：

通过继承联系在一起的类构成一种层次关系，通常在层次关系的根部有一个基类，其他类则直接或间接地从基类继承而来，这些继承得到的类成为派生类，基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类定义各自特有的成员。注意，基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此。

二、继承的定义格式

class  DeriveClassName : acess-lable  BaseClassName

        派生类类名    继承权限    基类（父类）名

继承权限：指三种继承关系，public（公有继承）、protected（保护继承）、    private（私有继承）。

三、继承关系

在继承中，根据继承权限的不同，基类成员的访问权限会在派生类中发生适当的改变，下面我们对三种不同访问权限对基类成员在派生类中的访问权限的影响。

①继承权限为public时：

#include<iostream>

using namespace std;

class Base

{

public:

Base()

{

cout << "Base()" << endl;

}

virtual ~Base()

{

cout << "~Base()" << endl;

}

void showBase()

{

cout << "_pub=" << _pub << endl;

}

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :public Base

{

public:

Derive()

{

cout << "Derive()" << endl;

}

void showDerive()

{

cout << "_D_pub=" << _D_pub << endl;

}

virtual ~Derive()

{

cout << "~Derive()" << endl;

}

void FunTest1()

{

Derive d1;

d1._pro = 10;   //可以访问

d1._pub = 11;   //可以访问

d1._pri = 12；      //不能访问

}

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

void FunTest2()

{

Derive d1;

d1._pro = 10;   //不能访问

d1._pub = 11;   //可以访问

d1._pri = 12;   //不能访问

}

分析：

  这了给出了一个基类Base类和一个派生类Dierived类，我们来简单分析一下这两个类

这个函数是上面派生类中的一个测试函数，我们可以看到，在派生类中，基类的公有成员和保护成员可以访问，但私有成员是不能被访问的。

 

FunTest2函数是类外的一个测试函数，可以看到，在类外通过创建的派生类对象可以对基类中的公有成员进行访问，但保护成员和私有成员都不能被访问。

②继承权限为protected时：

#include<iostream>

using namespace std;

class Base

{

public:

Base()

{

cout << "Base()" << endl;

}

virtual ~Base()

{

cout << "~Base()" << endl;

}

void showBase()

{

cout << "_pub=" << _pub << endl;

}

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :protected Base

{

public:

Derive()

{

cout << "Derive()" << endl;

}

void showDerive()

{

cout << "_D_pub=" << _D_pub << endl;

}

virtual ~Derive()

{

cout << "~Derive()" << endl;

}

void FunTest1()

{

Derive d1;

d1._pro = 10;   //可以访问

d1._pub = 11;   //可以访问

d1._pri = 12;     //不能访问

}

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

class D :public Derive

{

public:

D()

{}

virtual ~D()

{}

void FunTest3()

{

D d;

d._pro = 10;   //可以访问

d._pub = 11;   //可以访问

d._pri = 12;     //不能访问

}

private:

int data;

};

分析：

    

    从截图中我们可以看见，派生类中的FunTest1函数中创建的对象可以对基类中的公有和保护成员变量进行访问，但不能对私有成员变量进行访问。

 

FunTest3是派生类D中的一个函数，D是Deriver的一个派生类，可以看出，在D中，对象对基类Base中的公有、保护类型成员可以访问，而私有成员不能访问。

 

在类外的测试函数FunTest2中，Base基类中的所有成员都不能被D类的对象进行访问。

由此可以看出，Base基类中的成员变量在Derive继承下来后都把公有访问权限改成保护类型。

③继承权限为private时：

#include<iostream>

using namespace std;

class Base

{

public:

Base()

{

cout << "Base()" << endl;

}

virtual ~Base()

{

cout << "~Base()" << endl;

}

void showBase()

{

cout << "_pub=" << _pub << endl;

}

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :private Base

{

public:

Derive()

{

cout << "Derive()" << endl;

}

void showDerive()

{

cout << "_D_pub=" << _D_pub << endl;

}

virtual ~Derive()

{

cout << "~Derive()" << endl;

}

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

class D :public Derive

{

public:

D()

{}

virtual ~D()

{}

void FunTest3()

{

D d;

d._pro = 10;   //不能访问

d._pub = 11;   //不能访问

d._pri = 12;     //不能访问

}

private:

int data;

};

void FunTest2()

{

Derive d1;

d1._pro = 10;   //不能访问

d1._pub = 11;   //不能访问

d1._pri = 12;   //不能访问

}

分析：

 

FunTest3是派生类D中的一个函数，D是Deriver的一个派生类，可以看出，在D中，对象对基类Base中的公有、保护和私有类型也都不可以访问。由此可以看出，Base基类中的成员变量在Derive继承下来后都把访问权限改成了私有；类型。

总结：

通过对三种继承权限不同情况的分析，我们可以得出下列结论：

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

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

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

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

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

6. 在实际运用中一般使用都是public继承，极少场景下才会使用protetced/private继承.

四、派生类的默认成员函数

类的六个默认的成员函数，他们分别是构造函数、拷贝构造函数、析构函数、赋值操作符重载、取地址操作符重载、const修饰的取地址操作符重载。

在继承关系里面，在派生类中如果没有显示定义这六个默认构造函数，编译器系统会默认合成这六个成员函数。

 

继承关系中构造函数的调用顺序

首先我们先来看一段代码，看看编译器的运行结果：

#include<iostream>

using namespace std;

class Base

{

public:

Base()

{

cout << "Base()" << endl;

}

~Base()

{

cout << "~Base()" << endl;

}

void showBase()

{

cout << "_pub=" << _pub << endl;

}

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :public Base

{

public:

Derive()

{

cout << "Derive()" << endl;

}

void showDerive()

{

cout << "_D_pub=" << _D_pub << endl;

}

~Derive()

{

cout << "~Derive()" << endl;

}

 

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

void FunTest()

{

Derive d;

d._pub = 10;

}

int main()

{

FunTest();

system("pause");

return 0;

}

运行结果：

 

从运行结果看，是先调用基类的构造函数，然后调用派生类的构造函数，再调用派生类的析构函数，最后调用基类的析构函数。可实际上编译器是不是按照这个顺序呢？我们来看看此程序的汇编代码一查究竟。

 

 

 

 

    从截图中可以看出来，在地址为37D0处调用了Derive的构造函数，而在地址在3815处才调用了Base类的构造函数，具体的大家也可以把程序复制到自己的编译器上调试一步一步跟一下。

所以说编译器实际上是先调用派生类的构造函数的，但编译器是在什么时候调用的呢？其实编译器是先进入派生类的构造函，然后在初始化列表处调用了基类的构造函数，然后再回来执行自己的函数体。构造函数说清楚了，析构函数的调用顺序似乎还是很模糊，编译器为什么会先调用派生类的析构函数呢？这个编译器是根据生命周期的长短来调用的，派生类中构造函数生命周期比基类的生命周期短，所以就先调用派生类的析构函数。

【说明】

1、基类没有缺省构造函数，派生类必须要在初始化列表中显式给出基类名和参数列表。

2、基类没有定义构造函数，则派生类也可以不用定义，全部使用缺省构造函数。

3、基类定义了带有形参表构造函数，派生类就一定定义构造函数。

五、继承体系中的作用域

1. 在继承体系中基类和派生类是两个不同作用域。

2. 子类和父类中有同名成员，子类成员将屏蔽父类对成员的直接访问。（在子类成员函数中，可以使用 基类::基类成员 访问）--隐藏--重定义

      验证：

   class Base

{

public:

int _Data;

};

class Derive :public Base

{

public:

int _Data;

};

void FunTest()

{

Derive d;

d._Data = 10;

}

int main()

{

FunTest();

system("pause");

return 0;

}

     

    从截图中看出，只改变了派生类中成员的值，这就是由于基类和派生类中使用了同名的成员变量，而派生类中的成员变量对基类中的同名成员变量形成了覆盖/重定义。

3. 注意在实际中在继承体系里面最好不要定义同名的成员。

六、继承与转换--赋值兼容规则--public继承

1. 子类对象可以赋值给父类对象（切割/切片）。

2. 父类对象不能赋值给子类对象。

      验证1,2：

     #include<iostream>

using namespace std;

class Base

{

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :public Base

{

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

void FunTest()

{

Base b;

Derive d;

b = d;    //能赋值

d = b;    //不能赋值

}

int main()

{

FunTest();

system("pause");

return 0;

}

 

    我们可以看到，编译器会在第二次赋值报错，这说明子类对象可以赋值给父类对象，而父类对象不能赋值给子类对象。其实这里面的原因很简单，我们前面说过，public继承是保持is-a的原则，每个子类对象也是一个父类对象，但由于子类对象添加了新的功能，所以，一个父类对象并不是一个子类对象，所以父类对象不能给子类对象赋值。

3. 父类的指针/引用可以指向子类对象

4. 子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）

下面我们用一段代码来证明：

   验证3,4：

在这里我首先提示一下，3和4的验证尽量不要放在同一段代码中，我看的一些文章中把这四个放在一块证明，不小心的话会遇到一些不必要的麻烦，因为前两个的赋值如果没屏蔽的话会对后面两个造成影响。

#include<iostream>

using namespace std;

class Base

{

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :public Base

{

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

void FunTest()

{

Base b;

Derive d;

Base* pb1 = &b;

pb1 = &d;

Derive* d1 = &d;

d1 = &b;     

d1 = (Derive*)&b;

}

int main()

{

FunTest();

system("pause");

return 0;

}

 

我们可以看到，父类的指针可以指向子类的对象，而子类的对象不可以指向父类的对象，编译器会报错，但最后一句中，我们可以通过强制类型转换的方式实现，但建议大家尽量别使用，因为那种方式可能造成程序崩溃，而这种错误是很难找出来的。

七、友元于继承

友元关系不能继承，也就是说基类友元不能访问子类的私有和保护成员。

   验证：

  #include<iostream>

using namespace std;

class Base

{

friend void show(Base &b,Derive d);

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :public Base

{

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

void show(Base b,Derive d)

{

cout << b._pub << endl;

cout << b._pro << endl;   //无法访问protected成员，因为友元关系未继承

cout << d._D_pub << endl;

}

void FunTest1()

{

Base b;

Derive d;

show(b, d);

}

int main()

{

FunTest1();

system("pause");

return 0;

}

 

     正如截图中显示的那样，对于基类的保护类成员是无法访问的，原因就是友元关系未继承。但是下面这种情况就要注意了，输出运算符的重载，这个例子并不能说明友元被继承了。这个是因为参数发生类型转换，派生类对象赋值给基类对象。

#include<iostream>

using namespace std;

class Base

{

friend ostream& operator<<(ostream& _cout,Base& b)

{

_cout << b._pri << endl;

return _cout;

}

public:

int _pub;

protected:

int _pro;

private:

int _pri;

};

class Derive :public Base

{

public:

int _D_pub;

protected:

int _D_pro;

private:

int _D_pri;

};

void FunTest1()

{

Base b;

Derive d;

cout << b << endl;

cout << d << endl;

}

int main()

{

FunTest1();

system("pause");

return 0;

}

八、继承与静态成员

如果基类定义了static成员，则整个继承体系里面只有一个这样的成员，无论派生出多少个子类，都只有一个static成员实例。

九、单继承&多继承&菱形继承

  

    单继承：一个子类只有一个直接父类时称为单继承

     

 

     多继承：一个子类有两个或者两个以上父类的继承关系称为多继承

 

 

菱形继承：

 

菱形继承的对象模型：

 

  从对象模型中我们可以发现，菱形继承具有二义性和数据冗余的问题，图中显示Base被存了两份，那么要解决这个问题，C++中引入了我们下面要讨论的一种继承方式——虚继承。

十、虚继承

    1. 虚继承解决了在菱形继承体系里面子类对象包含多份父类对象的数据冗余&浪费空间的问题。

2. 虚继承体系看起来好复杂，在实际应用我们通常不会定义如此复杂的继承体系。一般不到万不得已都不要定义菱形结构的虚继承体系结构，因为使用虚继承解决数据冗余问题也带来了性能上的损耗。

#include<iostream>

using namespace std;

class Base

{

public:

int data1;

};

class Derive :virtual public Base

{

public:

int data2;

};

class E :virtual public Base

{

public:

int data4;

};

class F :public Derive,public E

{

public:

int data5;

};

 

void FunTest1()

{

cout << sizeof(Derive) << endl;

}

int main()

{

FunTest1();

system("pause");

return 0;

}

 

上述代码计算的是Derive类的大小，结果是12，我们不禁就会想，大小=自己的成员变量大小+基类成员变量大小，为什么会多出来个四呢？其实是多存放了一个指针。而这个指针是干什么用的呢？我们通过代码验证一下：

#include<iostream>

using namespace std;

class Base

{

public:

int data1;

};

class Derive :virtual public  Base

{

public:

int data2;

};

class E :virtual public  Base

{

public:

int data3;

};

class F :public  Derive,public E

{

public:

int data4;

};

void FunTest()

{

 

F f;

f.data1 = 1;

f.data2 = 2;

f.data3 = 3;

f.data4 = 4;

}

int main()

{

 

FunTest();

system("pause");

return 0;

}

 

上图为我们取到的对象f的地址，从内存可以看出第一个存了一个指针，下面才是赋值，那我们再看一下这个指针指向了哪：

 

 

 

我们看到里面有个0，有个20，这正好是到Base类的偏移量，所以，这个表中存的是此类到基类的偏移量，而不用把Base类存两遍。解决了冗余问题。

 

   从内存中f各个变量的存储我们不难看出虚拟继承的模型图，如下图所示：