C++基础知识（六：继承）

笨笨小乌龟112024-02-25 6:01

首先我们应该知道C++的三大特性就是封装、继承和多态。

此篇文章将详细的讲解继承的作用和使用方法。

  • 继承

一个类，继承另一个已有的类，创建的过程

父类(基类)派生出子类(派生类)的过程

继承提高了代码的复用性

【1】继承的格式

复制代码 
class 类名:父类名`
`{};

【2】继承的权限

复制代码 
class 类名:继承的权限 父类名`
`{};`

`如果不写继承方式，默认是私有继承
复制代码 
父类中的权限      public|private|protected  public|private|protected   public|private|protected              `
`继承方式                 public                    private                   protected`
`子类中的权限      public|不能访问|protected  private|不能访问|private    protected|不能访问|protected`
`

【3】继承时类中的特殊成员函数

特殊的成员函数不会被继承

构造函数:

  • 需要在子类中显性调用父类的构造函数(初始化列表中)(透传构造)
  • 透传构造
  • 继承构造
  • 委托构造

需要在子类中显性调用父类构造函数的场合:

父类中只有有参构造 ----->子类在创建类对象时，必须手动调用父类的构造函数

复制代码 
#include <iostream>`

`using` `namespace` `std;`

`class` `Father`
`{`
`public:`
    `int age;`
    `char c;`
    `Father(int a,char c):age(a),c(c){cout <<` `"Father有参"` `<< endl;}`
`};`

`class` `Child:public Father    //----->私有继承`
`{`
    `int high;`
`public:`
    `void` `show()`
    `{`
`        cout << c << endl;`
    `}`
`};`

`int` `main()`
`{`
    `//Child c1;  //error，因为父类只有有参构造，而子类中没有提供能够调用父类有参构造的构造函数，不能成功创建父类的空间`
    `//Father f1;`
`    c1.age;`
`    cout <<` `sizeof` `(Father)` `<< endl;`
`    cout <<` `sizeof` `(Child)` `<< endl;`
    `return` `0;`
`}

i）透传构造

在子类构造函数的初始化列表中，显性调用父类的构造函数

ii）继承构造

C++支持

不用在子类中再写一遍父类的构造函数

使用：using Father::Father； ----->在子类中使用父类的构造函数

直接使用继承构造的方式，不能对子类成员初始化

继承构造本质上并不是把父类中的构造函数继承给子类，编译器自动根据父类中构造函数的格式，提供出派生的构造函数(个数和参数都和父类中的构造函数一致)，主要还是通过透传构造创建父类的空间

复制代码 
#include <iostream>`
`using` `namespace std;`

`class` `Father`
`{`
`public:`
    `int age;`
    `char c;`
`//    Father(){cout << "Father无参" << endl;}`
    `Father(int a,char c):age(a),c(c){cout <<` `"Father有参两个参数"` `<< endl;}`
    `Father(char c):c(c){cout <<` `"Father有参一个参数的"` `<< endl;}`
    `Father(Father &other):age(other.age),c(other.c)`
    `{cout <<` `"Father拷贝"` `<< endl;}`
`};`

`class` `Child:public Father    //----->私有继承`
`{`
`private:`
    `int high;`
    `//父类中的public成员age，通过公有继承，仍然是public`
    `using Father::age;`   `//把父类中公有继承下来的age成员，在子类中改成私有权限`
`public:`
    `void` `show()`
    `{`
`        cout << c << endl;`
    `}`
    `//子类的无参构造，但是显性调用父类的有参构造还给了默认值`
    `//透传构造`
`//    Child():Father(12,'a'){cout << "Child无参构造" << endl;}`
`//    Child(int a,char c,int h):Father(a,c),high(h)`
`//    {cout << "Child有参构造" << endl;}`

    `//父类中的所有构造函数，都被继承到了子类中`
    `using Father::Father;`   `//更高效一些`
`};`

`int` `main()`
`{`
`    Child c1(10);`
`    Child c2(20,'z');`
`    Child c3 = c2;`
    `//Father f1;`
    `//c1.age;`
`    cout <<` `sizeof` `(Father)` `<< endl;`
`    cout <<` `sizeof` `(Child)` `<< endl;`
    `return` `0;`
`}`
`

iii）委托构造

一个类的情况，并不直接通过无参构造实例化对象，而是无参构造委托了有参构造，实例化对象

继承时的情况

复制代码 
    Child():Child(10){cout << "Child无参构造" << endl;}   //Child c1`
`    Child(int a):Father(12,'a'),high(a)`
`    {cout << "Child有参构造一个参数" << endl;}

iv）拷贝构造

需要在初始化列表中显性调用父类的拷贝构造，传other对象到父类的拷贝构造中

复制代码 
Father(Father &other):age(other.age),c(other.c){cout << "Father的拷贝构造" << endl;}`
`Child(Child &other):Father(other),high(other.high){}

【4】继承时构造和析构的时机

继承关系，可以理解为包含关系

子类在继承父类时，会把父类中的成员保留一份，再来创建子类自己的成员

父类先构造，子类后构造

子类先析构，父类后析构

复制代码 
#include <iostream>`

`using` `namespace std;`
`class` `F`
`{`
    `int` `*p;`
`public:`
    `F():p(new` `int){cout <<` `"F无参构造"` `<< endl;}`
    `~F()`
    `{`
        `delete p;`
`        cout <<` `"F析构函数"` `<< endl;`
    `}`
`};`
`class` `C:public F`
`{`
    `int` `*p;`
`public:`
    `C():p(new` `int){cout <<` `"C无参构造"` `<< endl;}`
    `~C()`
    `{`
        `delete p;`
`        cout <<` `"C析构函数"` `<< endl;`
    `}`
`};`

`int` `main()`
`{`
`    C *p1 =` `new C;`
    `delete p1;`   `//空间释放时，会自动调用析构函数，无需手动调用`
`    p1 =` `nullptr;`
    `return` `0;`
`}`
`

【5】父子类中存在同名成员问题

访问时不会发生冲突，默认访问子类的

复制代码 
#include <iostream>`
`using` `namespace std;`
`class` `F`
`{`
`public:`
    `int` `*p;`
    `F():p(new` `int){cout <<` `"F无参构造"` `<< endl;}`
    `~F()`
    `{`
        `delete p;`
`        cout <<` `"F析构函数"` `<< endl;`
    `}`
`};`
`class` `C:public F`
`{`
`public:`
    `int` `*p;`
    `C():p(new` `int){cout <<` `"C无参构造"` `<< endl;}`
    `~C()`
    `{`
        `delete p;`
`        cout <<` `"C析构函数"` `<< endl;`
    `}`
`};`

`int` `main()`
`{`
`    C *p1 =` `new C;`
    `*(p1->p)` `=` `90;`
`    cout <<` `*(p1->p)` `<< endl;`   `//子类成员和父类成员同名，默认优先访问子类成员`
`    cout <<` `*(p1->F::p)` `<< endl;`  `//通过域限定符访问父类的成员`
    `delete p1;`   `//空间释放时，会自动调用析构函数，无需手动调用`
`    p1 =` `nullptr;`
    `return` `0;`
`}
  • 多重继承

一个子类，继承自多个基类

【1】格式

复制代码 
class 类名:继承权限 父类名,继承权限 父类名····`
`{}

【2】当多个父类中包含同名成员

多个父类中包含同名成员，通过域限定符访问指定的父类中成员

复制代码 
#include <iostream>`

`using` `namespace std;`

`class` `Room`
`{`
`public:`
    `void` `clean()`
    `{`
`        cout <<` `"打扫房间"` `<< endl;`
    `}`
`};`
`class` `BedRoom`
`{`
`public:`
    `void` `play()`
    `{`
`        cout <<` `"可以玩游戏"` `<< endl;`
    `}`
    `void` `clean()`
    `{`
`        cout <<` `"打扫卧室"` `<< endl;`
    `}`
`};`

`//Home类公共继承字Room和BedRoom类`
`class` `Home:public Room,public BedRoom`
`{`
`};`

`int` `main()`
`{`
`    Home h1;`
`    h1.play();`
`    h1.Room::clean();`
`    h1.BedRoom::clean();`
    `return` `0;`
`}
  • 菱形继承(钻石继承)

【1】格式

复制代码 
     A                ----->公共基类`
   `/   \`
`  B     C             ------>中间子类`
`   \   /`
`     D                ------>汇集子类

汇集子类中，会包含两份公共基类中的内容

【2】菱形继承存在的问题

  1. 会发生二义性的问题(同一个变量或者函数，可以通过两种方法访问)
  2. 如果公共基类，过大，会造成汇集子类中的代码膨胀/冗余
复制代码 
#include <iostream>`

`using` `namespace std;`
`class` `A`
`{`
`public:`
    `int a;`
    `//A(int a):a(a){cout << "A" << endl;}`
`};`

`class` `B:public A`
`{`
`public:`
    `int c;`
    `//B(int a,int c):A(a),c(c){cout << "B" << endl;}`
`};`

`class` `C:public A`
`{`
`public:`
    `//C(int a):A(a){cout << "C" << endl;}`
`};`

`class` `D:public C,public B`
`{`
`public:`
    `//D(int a,int c):B(a,c),C(a),A(a){cout << "D" << endl;}`
`};`

`int` `main()`
`{`
`    D d1;`
`    d1.B::a =` `90;`   `//二义性，还可以直接通过中间子类访问，直接访问B中的a成员`
    `//cout << d1.C::A::a << endl;  //会发生二义性，因为访问A，但是有两条路径都访问到A`
    `return` `0;`
`}

【3】虚继承(virtual)

虚继承指对公共基类的虚继承。

主要用于解决菱形继承问题，

采用虚继承后，公共基类中的内容，只会在汇集子类中存在一份，在汇集子类中，可以通过任意一条路径访问到公共基类中的成员

复制代码 
#include <iostream>`

`using` `namespace std;`
`class` `A`
`{`
`public:`
    `int a;`
`};`

`class` `B:virtual public A`
`{`
`public:`
    `int c;`
`};`

`class` `C:virtual public A`
`{`

`};`

`class` `D:public B,public C`
`{`

`};`

`int` `main()`
`{`
`    D d1;`
`    d1.B::A::a =` `90;`
`    cout << d1.C::A::a << endl;`
    `return` `0;`
`}`
`
相关推荐
学习前端的小z1 分钟前
【前端】深入理解 JavaScript 逻辑运算符的优先级与短路求值机制
开发语言·前端·javascript
神仙别闹8 分钟前
基于C#和Sql Server 2008实现的（WinForm）订单生成系统
开发语言·c#
XINGTECODE10 分钟前
海盗王集成网关和商城服务端功能golang版
开发语言·后端·golang
我们的五年19 分钟前
【Linux课程学习】：进程程序替换，execl，execv，execlp，execvp，execve，execle，execvpe函数
linux·c++·学习
zwjapple26 分钟前
typescript里面正则的使用
开发语言·javascript·正则表达式
小五Five27 分钟前
TypeScript项目中Axios的封装
开发语言·前端·javascript
前端每日三省29 分钟前
面试题-TS(八)：什么是装饰器（decorators）？如何在 TypeScript 中使用它们？
开发语言·前端·javascript
凡人的AI工具箱42 分钟前
15分钟学 Go 第 60 天 ：综合项目展示 - 构建微服务电商平台（完整示例25000字）
开发语言·后端·微服务·架构·golang
做人不要太理性1 小时前
【C++】深入哈希表核心：从改造到封装，解锁 unordered_set 与 unordered_map 的终极奥义！
c++·哈希算法·散列表·unordered_map·unordered_set
程序员-King.1 小时前
2、桥接模式
c++·桥接模式
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10量化方法怎么选？如何评估量化后的大模型LLM？