【C++】浅析C++中的继承

目录

1. 继承基本概念

2. 派生类的默认成员函数

3. 继承体系内的作用域

4. 继承与转换–赋值兼容规则–public继承

5. 友元与继承&继承与静态成员

6. 单继承&多继承&菱形继承

7. 虚拟继承&菱形虚拟继承（重要）

---

1.继承基本概念

1.1 【继承含义】

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

1.2 【继承定义格式】

1.3 【继承关系&访问限定符】

三种类成员访问限定符
* public（公有）
* private（私有）
* protected（保护）

三种继承关系
* public （公有继承）
* private（私有继承）
* protected（保护继承）

【继承关系 与 访问限定符 的关系】

继承方式	基类的public成员	基类的protected成员	基类的private成员	继承引起的访问关系变化概括
public继承	仍为public成员	仍为protected成员	不可见	基类的非私有成员在子类的访问属性都不变
protected继承	变为protected成员	变为protected成员	不可见	基类的非私有成员都成为子类的保护成员
private继承	变为private成员	变为private成员	不可见	基类的非私有成员都成为子类的私有成员

【实例引入】

（在这里因为篇幅原因，只列举一个public继承 关系的实例，其他的两种大家感兴趣了，可以自己试试哦）

#include<stdio.h>
#include<Windows.h>
#include<iostream>

class base
{
public:
    int _b1;
protected:
    int _b2;
private:
    int _b3;
};
class derived:public base
{
public:
private:
    int _d;
};

void test1(){
    derived D;
    D._b1 =10;
}

int main(){
    test1();
    system("pause");
    return 0;
}

这里我用VS2012编译器可以直接查看对象的成员变量状态：

【结论】：
基类的public成员变量状态在派生类中仍为public，基类的protected成员变量状态在派生类中仍为protected，基类的private成员变量状态在派生类中不可访问，因此 基类的非私有成员在子类的访问属性都不变。

1.4 【注意】

• 基类的private成员在派生类中是不能被访问的。但如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就可以定义为protected。（可以看出保护成员限定符是因继承才出现）。
• public继承是一个接口继承，保持is-a原则，每个父类可用的成员对子类也可用，因为每个子类对象也都是一个父类对象。
• protected/private继承是一个实现继承，基类的部分成员并非完全成为子类接口的一部分，是 has-a 的关系原则，所以非特殊情况下不会使用这两种继承关系，在绝大多数的场景下使用的都是公有继承。私有继承意味着is-implemented-in-terms-of(是根据……实现的)。通常比组合(composition)更低级，但当一个派生类需要访问基类保护成员或需要重定义基类的虚函数时它就是合理的。
• 不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存在但是在子类中不可见（不能访问）。
• . 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
• 在实际运用中一般使用都是public继承，极少场景下才会使用protetced/private继承。

注：
is-a原则：is-a（英语：subsumption，包含架构）指的是类的父子继承关系，例如类D是另一个类B的子类（类B是类D的父类），是一个的原则；is-a基于类继承或接口实现，is-a是表达这句话的一种方式：“这个东西是那个东西的一种”。例如苹果是水果的一种。
has-a原则：代表的是对象和它的成员的从属关系。同一种类的对象，通过它们的属性的不同值来区别，是有一个的原则；has-a关系是基于用法（即引用）而不是继承。has a 是如果A中有B，那么，B就是A的组成部分。

未完~

---

2. 派生类的默认成员函数

代码：

#include<stdio.h>
#include<Windows.h>
#include<iostream>

class base
{
public:
    base()
    {

    }
    ~base()
    {}
public:
    int _b1;
protected:
    int _b2;
private:
    int _b3;
};
class derived:public base
{
public:
    derived()
        :base()//不自己初始化基类，编译器也会在初始化列表初始化基类
    {

    }
    ~derived()
    {}
private:
    int _d;
};

void test1(){
    derived D;
}

int main(){
    test1();
    system("pause");
    return 0;
}

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

结果：
第一步

第二步

第三步

【结论】：
根据以上试验结果可知：
派生类的构造函数–>在派生类构造函数初始化列表调用基类构造函数–>继续进行派生类构造函数。

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

结果：
第一步：

第二步：

第三步：

第四步：

【结论】：
根据以上试验结果可知：
调用派生类析构函数–>销毁派生类自己管理的资源–>调用基类析构函数–>销毁基类管理的资源。

2.3 总结 说明：

• 基类没有缺省构造函数，派生类必须要在初始化列表中显式给出基类名和参数列表。
• 基类没有定义构造函数，则派生类也可以不用定义，全部使用缺省构造函数。
• 基类定义了带有形参列表构造函数，派生类就一定定义构造函数。

---

3.继承体系内的作用域

3.1 同名隐藏

【例】：

#include<stdio.h>
#include<Windows.h>
#include<iostream>

class base
{
public:
    base()
    {

    }
    ~base()
    {}
public:
    int _b1;
    int _b2;
    int _b3;
private:

};
class derived:public base
{
public:
    derived()
    {

    }
    ~derived()
    {}
public:
    int _d;
    int _b1;
private:

};

void test1(){
    derived D;
    D._b2 = 1;
    D._b3 = 2;
    D._d = 3;
    D._b1 = 4;
}

int main(){
    test1();
    system("pause");
    return 0;
}

【结果】：

这时候我们会发现，当基类和派生类中含有同名成员变量时，对象调用同名成员函数会优先调用派生类的成员函数。这就是继承体系中的同名隐藏。

---

【同名隐藏含义】：
在继承体系中，基类和派生类有相同名字的成员（同名成员变量 & 同名成员函数）（和类型没有关系）。如果使用派生类对象调用同名称的类成员，优先调用派生类自己。

【函数重载】：
函数重载是指在同一作用域内，可以有一组相同函数名，不同参数列表（个数，类型，次序（类型））的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染。

【为什么需要函数重载】：
* 减少函数名的数量，避免了名字空间的污染
* 类的构造函数跟类名相同，也就是说，构造函数都同名，如果没有函数重载机制，要想实例化不同的对象，会十分麻烦。
* 操作符重载，本质就是函数重载，它大大丰富了已有操作符的含义。

3.2 继承体系中的作用域

• 在继承体系中基类和派生类是两个不同作用域。
• 子类和父类中有同名成员，子类成员将屏蔽父类对成员的直接访问。（在子类成员函数中，可以使用 基类::基类成员 访问）–隐藏 –重定义
• 注意在实际中在继承体系里面最好不要定义同名的成员。

---

4.继承与转换–赋值兼容规则–public继承

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

②父类对象不能赋值给子类对象

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

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

---

5.友元与继承&继承与静态成员

5.1 友元与继承

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。
【实例引入】

#include<stdio.h>
#include<Windows.h>
#include<iostream>

class Base
{
    friend void PrintB();
public:
    void test_b(){

    }
public:
    int _b1;
protected:
    int _b2;
private:
    int _b3;
};

class Derived:public Base

{
public:
    void test_d(){

    }
private:
    int _d;
};
void PrintB(Base B){
    B.test_b();
    B._b1 = 1;
}

【结果】：

友元类只能调用基类的成员变量，成员函数，无法访问派生类。

---

5.2 继承与静态成员

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

【实例】：

#include<stdio.h>
#include<Windows.h>
#include<iostream>
#include<string.h>

using namespace std;

class Person
{
public :
    Person()
    {++ _count;}
protected :
    string _name ; // 姓名
public :
    static int _count; // 统计人的个数。
};

int Person::_count = 0;

class Student : public Person
{
protected :
    int _stuNum ; // 学号
};
class Graduate :public Student
{
protected:
    string _seminarCourse; // 研究科目
};
void TestPerson1()
{
    Student s1;
    Student s2;
    Student s3;
    Graduate s4;
    cout<<"人数:"<<Person::_count<<endl;
    Student ::_count = 0;
    cout<<"人数:"<<Person::_count<<endl;
}


int main(){
    TestPerson1();
    system("pause");
    return 0;
}

【结果】：

---

6. 单继承&多继承&菱形继承

6.1 单继承

单继承只有一个基类base，派生类在保持基类原有性质的同时自身又创建了成员变量或成员函数，这种继承方式称为单继承。

【实例引入】：

#include<stdio.h>
#include<Windows.h>
#include<iostream>
#include<string.h>

using namespace std;

class B
{
public:
    void fun1()
    {
        cout<<"B::fun1()"<<endl;
    }
public:
    int _b1;
};

class D:public B
{
public:
    void fun2()
    {
        cout<<"D::fun3()"<<endl;
    }
public:
    int _d1;
};

int main()
{
    D d;
    cout<<sizeof(d)<<"字节"<<endl;
    d._b1 = 1;
    d._d1 = 2;
    system("pause");
    return 0;
}

单继承内存分配模型：

6.2 多继承

多继承有一个以上的父类。也就是说：一个派生类有两个或两个以上的直接父类时，这种继承方式称为多继承。

【实例引入】：

#include<stdio.h>
#include<Windows.h>
#include<iostream>
#include<string.h>

using namespace std;

class B1
{
public:
    void fun1()
    {
        cout<<"B::fun1()"<<endl;
    }
    void fun2()
    {
        cout<<"B::fun2()"<<endl;
    }
public:
    int _b1;
};

class B2
{
public:
    void fun1()
    {
        cout<<"B::fun1()"<<endl;
    }
public:
    int _b2;
};

class D:public B1,public B2
{
public:
    void fun3()
    {
        cout<<"D::fun3()"<<endl;
    }
public:
    int _d1;
};

int main()
{
    D d;
    cout<<sizeof(d)<<"字节"<<endl;
    d._b1 = 1;
    d._b2 = 2;
    d._d1 = 3;
    system("pause");
    return 0;
}

运行结果：

多继承内存分配：

多继承内存分配模型：

6.3 菱形继承

两个子类继承同一个父类，而又有子类同时继承这两个子类，也被称为钻石继承。
【模型】：

也就是C1,C2以单继承的方式继承基类B，D以多继承的方式分别继承C1,C2,这就是菱形继承，也就是钻石继承。

【实例引入】：

#include<stdio.h>
#include<Windows.h>
#include<iostream>
#include<string.h>

using namespace std;

class B
{
public:
    void fun1()
    {
        cout<<"B::fun1()"<<endl;
    }
public:
    int _b1;
};


class C1:public B
{
public:
    void fun2()
    {
        cout<<"C1::fun3()"<<endl;
    }
public:
    int _c1;
};

class C2:public B
{
public:
    void fun3()
    {
        cout<<"C2::fun3()"<<endl;
    }
public:
    int _c2;
};
class D:public C1,public C2
{
public:
    void fun4()
    {
        cout<<"D::fun4()"<<endl;
    }
public:
    int _d;
};
int main()
{
    D d;
    cout<<sizeof(d)<<"字节"<<endl;
    d._b1 = 1;
    d._c1 = 2;
    d._c2 = 3;
    d._d = 4;
    system("pause");
    return 0;
}

【程序运行结果】：

这里会报一个错误，显示B类的成员变量有两份。我们先用加上作用域的方法暂时解决这个问题（d.C1::_b1 = 1），先了解菱形继承的内存分配。

以上程序主函数调整为：

int main()
{
    D d;
    cout<<sizeof(d)<<"字节"<<endl;
    d.C1::_b1 = 1;
    d.C2::_b1 = 2;
    d._c1 = 3;
    d._c2 = 4;
    d._d = 5;
    system("pause");
    return 0;
}

菱形继承内存分配：

菱形继承内存分配模型：

【菱形继承缺陷】：
从以上的菱形继承内存分配模型分析里，我们可以发现菱形继承还存在有一个问题，就是它的派生类D类里，存在着两份B类。也就是说菱形继承存在二义性和数据冗余。虚拟继承可以解决菱形继承的这些问题。

---

7虚拟继承&菱形虚拟继承

7.1 虚拟继承

【实例引入】

#include<stdio.h>
#include<Windows.h>
#include<iostream>
#include<string.h>

using namespace std;

class B
{
public:
    void fun1()
    {
        cout<<"B::fun1()"<<endl;
    }
public:
    int _b1;
};


class C1:virtual public B
{
public:
    void fun2()
    {
        cout<<"C1::fun3()"<<endl;
    }
public:
    int _c1;
};
int main()
{
    C1 c;
    cout<<sizeof(c)<<"字节"<<endl;
    c._b1 = 1;
    c._c1 = 2;
    system("pause");
    return 0;
}

【对象模型】

基于以上虚拟继承的内存分配，我们可以大致画一个虚拟继承的内存分配模型。

【形式】：

class D：virtual public B ；

【实现过程】：

【构造函数】：

首先编译器会给虚拟继承合成构造函数

目的是为了填偏移量表格的地址

push 1；//是一个标记，判断是否是虚拟继承的标记

【访问基类成员变量的形式】：

普通继承：

mov dword ptr [ebp-0Ch],2;//直接赋值

虚拟继承：
mov eax,dword ptr [c] //取对象前四个字节

mov ecx,dword ptr [eax+4]

mov dword ptr c[ecx],1

【总结】：
虚继承—–解决菱形继承的二义性和数据冗余的问题

1. 虚继承解决了在菱形继承体系里面子类对象包含多份父类对象的数据冗余&浪费空间的问题。
2. 虚继承体系看起来好复杂，在实际应用我们通常不会定义如此复杂的继承体系。
3. 一般不到万不得已都不要定义菱形结构的虚继承体系结构，因为使用虚继承解决数据冗余问题也带来了性能上的损耗。

7.2 菱形虚拟继承

【模型】：

【实例引入】：

#include<stdio.h>
#include<Windows.h>
#include<iostream>
#include<string.h>

using namespace std;

class B
{
public:
    void fun1()
    {
        cout<<"B::fun1()"<<endl;
    }
public:
    int _b1;
};


class C1:virtual public B
{
public:
    void fun2()
    {
        cout<<"C1::fun3()"<<endl;
    }
public:
    int _c1;
};

class C2:virtual public B
{
public:
    void fun3()
    {
        cout<<"C2::fun3()"<<endl;
    }
public:
    int _c2;
};
class D:public C1,public C2
{
public:
    void fun4()
    {
        cout<<"D::fun4()"<<endl;
    }
public:
    int _d;
};
int main()
{
    C1 c;
    cout<<sizeof(c)<<"字节"<<endl;
    c._b1 = 1;
    c._c1 = 2;
    system("pause");
    return 0;
}

【菱形虚拟继承内存模型分析】：

通过内存监视，我们可以发现菱形虚拟继承在内存中存放了两个类似地址的东西。我们假设它是指针，来看看它里面放的是什么东西。

【菱形虚拟继承内存模型】：

【思考】：
* 设计一个类不能被任何类继承？
* 用C语言来模拟实现继承？