C++ ——继承

news2025/2/23 4:25:55

体现的是代码复用的思想

1、子类继承父类，子类就拥有了父类的特性（成员方法和成员属性）

2、已存在的类被称为“基类”或者“父类”或者“超类”；新创建的类被称为“派生类”或者“子类”

注意：

        （1）子类继承了父类，子类就拥有了父类的属性和方法

        （2）如果子类重写了父类的同名方法，子类对象默认调用的是子类自己的成员方法，如果想调用父类的同名方法，要添加父类作用域限定符

#include <iostream>

using namespace std;

class Father{
public:
    int num1=88;
    int num2=99;
public:
    //成员方法
    void show()const{
        cout<<"num1="<<num1<<",num2="<<num2<<endl;
    }
    void cook(){
        cout<<"做水煮鱼"<<endl;
    }
};
class Son:public Father{  //public：放在继承的地方，表示继承方式是公有继承
public:
    void sing(){
        cout<<"唱歌"<<endl;
    }
    void cook(){
        cout<<"做红烧肉"<<endl;
    }
};

int main(){
    Son s1;
    s1.cook();  //默认子类调用的是自己的成员方法
    s1.show();
    s1.sing();
    s1.Father::cook();  //子类可以使用添加父类作用域限定符，来调用父类的同名方法
    return 0;
}

1、构造函数

1.1 派生类的构造函数

继承中的无参构造函数

（1）基类（父类）中的构造函数不能被继承

（2）派生类（子类）中必须要调用基类中的构造函数来完成属性的初始化

（3）默认情况下，编译器会自动在派生类中调用父类的无参构造函数

（4）子类继承了父类，子类独有的属性需要在自己的构造函数进行初始化，而子类从父类继承过来的属性，必须通过子类构造函数调用父类构造函数进行初始化

#include <iostream>

using namespace std;

class Father{
public:
    int num1=88;
    int num2=99;
public:
    //编译器默认的无参构造函数
    Father(){}
    //有参构造函数
    Father(int num1,int num2)
        :num1(num1),num2(num2){}
};
class Son:public Father{  //public：放在继承的地方，表示继承方式是公有继承
public:
    int a;
public:
    //编译器默认的子类无参调用父类无参构造函数
    Son():Father(){}
    //子类有参构造函数调用父类有参构造函数，来完成继承下来的属性的初始化
    Son(int num1,int num2,int a):Father(num1,num2),a(a){}
};

int main(){
    Son s2(10,55,66);
//    s2.show();
    cout<<s2.a<<endl;  //66
    return 0;
}

1.2 派生类调用基类构造函数

（1）目的：因为构造函数和析构函数，不能继承，所以派生类的构造函数通过调用基类的构造函数完成部分属性的初始化

（2）派生类的构造函数调用基类的构造函数的方式：透传构造、委托构造、继承构造

1.2.1 透传构造

派生类的构造函数直接调用基类的构造函数

class Father{
public:
    int num;
public:
    //无参构造函数---->委托构造
    Father():Father(90){}
    //有参构造函数
    Father(int num)
        :num(num){}
};
class Son:public Father{  //public：放在继承的地方，表示继承方式是公有继承
public:
    int num1;
public:
    //委托构造
    Son():Son(2,88){}
    //透传构造
    Son(int num1,int num):Father(num),num1(num1){}
};

1.2.2 委托构造

可维护性好，但效率相对较低

思想：一个类中的构造函数是可以调用这个类中的其他构造函数

父类的无参构造函数调用父类的有参构造函数；子类的无参构造函数调用子类的有参构造函数；子类的有参构造函数透传父类的有参构造函数

注意：委托构造离不开透传构造

class Father{
public:
    int num;
public:
    //无参构造函数---->委托构造
    Father():Father(90){}
    //有参构造函数
    Father(int num)
        :num(num){}
};
class Son:public Father{  //public：放在继承的地方，表示继承方式是公有继承
public:
    int num1;
public:
    //委托构造
    Son():Son(2,88){}
    //透传构造
    Son(int num1,int num):Father(num),num1(num1){}
};

1.2.3 继承构造

透传构造的简写方式，一句话自动实现透传构造，编译器会自动给派生类添加n个构造函数（n取决于基类中构造函数的个数），并实现自动透传其基类构造函数

class Father{
public:
    int num;
    int age;
    string addr;
public:
    //无参构造函数---->委托构造
    Father():Father(90){}
    //有参构造函数
    Father(int num)
        :num(num){}
    Father(int age,string addr)
        :age(age),addr(addr){}
};
class Son:public Father{  //public：放在继承的地方，表示继承方式是公有继承
public:
    int num1=99;
public:

    //继承构造
    using Father::Father;
};

2、对象的构建和销毁的过程

（1）成员对象：类中有一个成员，该成员是对象类型，叫做对象成员

                先调用成员对象的构造函数，再调用自己的构造函数；析构函数则相反

（2）父子类继承时

                先调用父类的构造函数，再调用子类的构造函数；析构函数则相反

（3）静态成员对象：类中有一个静态成员，该成员是一个对象类型

                静态成员对象的构造函数先执行，再执行自己的构造函数；析构函数则相反

顺序：

        构造函数：静态成员对象---->成员对象---->父类---->子类

        析构函数：子类---->父类---->成员对象---->静态成员对象

2.1 成员对象

class Demon{
public:
    //构造函数
    Demon(){
        cout<<"成员对象的构造函数"<<endl;
    }
    ~Demon(){
        cout<<"成员对象的析构函数"<<endl;
    }
};

class Test{

public:
    Test(){
        cout<<"构造函数"<<endl;
    }
    ~Test(){
        cout<<"析构函数"<<endl;
    }
};

2.2 父子类继承时

class Father{
public:
    Father(){
        cout<<"父类构造"<<endl;
    }
    ~Father(){
        cout<<"父类析构"<<endl;
    }
};
class Son:public Father{
public:
    Son():Father(){
        cout<<"子类构造"<<endl;
    }
    ~Son(){
        cout<<"子类析构"<<endl;
    }
};

2.3 静态成员对象

class P{
public:
    P(){
        cout<<"静态成员对象的构造"<<endl;
    }
    ~P(){
        cout<<"静态成员对象的析构"<<endl;
    }
};
class Phone{
public:
    //类内声明
    static P p1;  //静态成员变量的声明
    Phone(){
        cout<<"构造函数"<<endl;
    }
    ~Phone(){
        cout<<"析构函数"<<endl;
    }
};
P Phone::p1=P();  //类外初始化

3、权限 

3.1 权限修饰符

C++中成员的权限修饰符有3种：

        （1）public：共有的        类内、子类内、类外可以访问

        （2）private：私有的        只能类内访问

        （3）protected：受保护的        类内、子类内可以访问

注意：如果权限修饰符可以省略，默认是private

#include <iostream>

using namespace std;

class Father{
public:
    int num1;
private:
    int num2;
protected:
    int num3;
public:
    //构造函数
    Father(int num1,int num2,int num3)
        :num1(num1),num2(num2),num3(num3){}
    void show()const{
        cout<<this->num1<<" ";  //public 类内可以访问
        cout<<this->num2<<" ";  //private 类内可以访问
        cout<<this->num3<<" ";  //protected  类内可以访问
        cout<<"*******"<<endl;
    }
};
class Son:public Father{
public:
    using Father::Father;
    void fun()const{
        cout<<this->num1<<" "<<this->Father::num1<<" ";  //public 子类内可以访问
        cout<<this->num3<<" "<<this->Father::num3<<" ";  //protected  子类内可以访问
        cout<<"*******"<<endl;
    }
};

int main(){
    Father f1(1,2,3);
    f1.show();
    Son s1(4,5,6);
    s1.fun();
    cout<<s1.num1<<endl;  //public 类外可以访问
    return 0;
}

3.2 继承方式

3.2.1 public（共有继承）

（1）父类是public---->子类也是public

（2）父类是protected---->子类也是protected

（3）父类是private---->子类也是private，但是类内不可以直接访问，可以间接访问

#include <iostream>

using namespace std;

class Father{
public:
    int num1;
protected:
    int num2;
private:
    int num3;
public:
    Father(int num1,int num2,int num3)
        :num1(num1),num2(num2),num3(num3){}
    void fun()const{}
    int get_num3()const{
        return num3;
    }
};
class Son:public Father{
public:
    Son(int num1,int num2,int num3)
        :Father(num1,num2,num3){}
    void show(){
        cout<<this->num1<<endl;  //父类public---->子类也是public，类内可以访问
        cout<<this->num2<<endl;  //父类protected---->子类也是protected
//        cout<<this->num3<<endl;  //报错，父类private---->子类也是private，但是类内不可以直接访问
        cout<<this->Father::get_num3()<<endl;  //父类private---->子类也是private，可以间接访问
        cout<<"******"<<endl;
    }
};
class Sunzi:public Son{
public:
    Sunzi(int num1,int num2,int num3)
        :Son(num1,num2,num3){}
    void fun()const{
        cout<<this->num1<<" "<<this->Son::num1<<endl;  //父类public---->子类也是public，派生类内可以访问
        cout<<this->num2<<" "<<this->Son::num2<<endl;  //父类protected---->子类也是protected
        cout<<"******"<<endl;
    }
};

int main(){
    Son s1(1,2,3);
    s1.show();
    cout<<s1.num1<<endl;  //父类public---->子类也是public，类外可以访问
    Sunzi sz(4,5,6);
    sz.fun();
    return 0;
}

3.2.2 protected（受保护的继承）

（1）父类是public---->子类是protected

（2）父类是protected---->子类也是protected

（3）父类是private---->子类也是private，但是类内不可以直接访问，可以间接访问

#include <iostream>

using namespace std;

class Father{
public:
    int num1;
protected:
    int num2;
private:
    int num3;
public:
    Father(int num1,int num2,int num3)
        :num1(num1),num2(num2),num3(num3){}
    void fun()const{}
    int get_num3()const{
        return num3;
    }
};
class Son:protected Father{
public:
    Son(int num1,int num2,int num3)
        :Father(num1,num2,num3){}
    void show(){
        cout<<this->num1<<endl;  //父类public---->子类是protected
        cout<<this->num2<<endl;  //父类protected---->子类也是protected
//        cout<<this->num3<<endl;  //报错，父类private---->子类也是private，但是类内不可以直接访问
        cout<<this->Father::get_num3()<<endl;  //父类private---->子类也是private，可以间接访问
        cout<<"******"<<endl;
    }
};
class Sunzi:protected Son{
public:
    Sunzi(int num1,int num2,int num3)
        :Son(num1,num2,num3){}
    void fun()const{
        cout<<this->num1<<" "<<this->Son::num1<<endl;  //父类public---->子类是protected
        cout<<this->num2<<" "<<this->Son::num2<<endl;  //父类protected---->子类也是protected
        cout<<"******"<<endl;
    }
};

int main(){
    Son s1(1,2,3);
    s1.show();
    Sunzi sz(4,5,6);
    sz.fun();
    return 0;
}

3.2.3 private（私有继承）

（1）父类是public---->子类是private，类内可以直接访问

（2）父类是protected---->子类是private，类内可以直接访问

（3）父类是private---->子类也是private，但是类内不可以直接访问，可以间接访问

4、多重继承

4.1 概念

继承中，允许有多个基类，每一个基类的继承都可以看作是唯一的独一继承，此时派生类就拥有了所有基类的特性

#include <iostream>
using namespace std;

class Sofa{
public:
    int num=1;
public:
    void job(){
        cout<<"沙发可以坐"<<endl;
    }
};
class Bed{
public:
    void work(){
        cout<<"床可以躺"<<endl;
    }
};
class SofsBed:public Sofa,public Bed{
public:
    void work(){
        cout<<"即可以躺又可以坐"<<endl;
    }
};

int main(){
    SofsBed sfb;
    sfb.job();
    sfb.work();
    cout<<sfb.num<<endl;
    sfb.Bed::work();
    return 0;
}

问题：多个基类同时拥有同名成员函数，此时派生类对象直接调用该函数会产生歧义

解决方法：添加基类作用域限定符

4.2 菱形继承

多继承中的若干个基类，又同时拥有同一个基类，此时叫菱形继承（钻石继承）

#include <iostream>
using namespace std;

//爷爷类
class Furniture{
public:
    void show(){
        cout<<"我们是家具"<<endl;
    }
};
//基类
class Sofa:virtual public Furniture{};
class Bed:virtual public Furniture{};
//派生类
class SofsBed:public Sofa,public Bed{};

int main(){
    SofsBed sfb;
//    sfb.show();  //报错，问题：两个基类拥有了同名函数，产生了歧义
    //解决方法1：使用基类作用域限定符
    sfb.Bed::show();
    sfb.Sofa::show();
    //解决方法2：使用虚继承
    /*继承方式有两种：普通继承（默认的）和虚继承（继承方式前添加virtual关键字）*/
    sfb.show();
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2303738.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

vue,vue3 keepalive没有效果，无法缓存页面include无效，keep-alive

vue,vue3 keepalive没有效果，无法缓存页面include无效，keep-alive

keepalive没有效果&#xff0c;无法缓存页面&#xff1f; 问题大概是组件的name值不对应&#xff0c;vue2修改组件文件的name值&#xff0c;vue3保持组件文件名称和路由页面配置的name一致就可以了&#xff0c;如果vue3不想保持一致&#xff0c;必须手动在文件后面添加export..…
阅读更多...
DeepSeek智能测试知识库助手PRO版：多格式支持+性能优化

DeepSeek智能测试知识库助手PRO版：多格式支持+性能优化

前言 测试工程师在管理测试资产时，需要面对多种文档格式、大量文件分类及知识库的构建任务。为了解决这些问题，我们升级了 DeepSeek智能测试知识库助手，不仅支持更多文档格式，还加入了 多线程并发处理 和 可扩展格式支持，大幅提升处理性能和灵活性。 主要功能亮点： 多格…
阅读更多...
纯手工搭建整套CI/CD流水线指南

纯手工搭建整套CI/CD流水线指南

目录 一、前言 二、环境准备 1、服务器开荒&#xff08;192.168.1.200&#xff09; 2、离线资源清单&#xff08;提前用U盘拷好&#xff09; 三、硬核安装&#xff1a;比拧螺丝还细的步骤 Step1&#xff1a;搭建GitLab&#xff08;注意&#xff01;这是只内存饕餮&#xf…
阅读更多...
智能硬件新时代，EasyRTC开启物联音视频新纪元

智能硬件新时代，EasyRTC开启物联音视频新纪元

在万物互联的时代浪潮中&#xff0c;智能硬件正以前所未有的速度融入我们的生活&#xff0c;从智能家居的便捷控制&#xff0c;到智能穿戴设备的健康监测&#xff0c;再到工业物联网的高效管理&#xff0c;智能硬件的应用场景不断拓展。而在这个智能硬件蓬勃发展的背后&#xf…
阅读更多...
Rust编程语言入门教程（八）所有权 Stack vs Heap

Rust编程语言入门教程（八）所有权 Stack vs Heap

Rust 系列 &#x1f380;Rust编程语言入门教程&#xff08;一&#xff09;安装Rust&#x1f6aa; &#x1f380;Rust编程语言入门教程&#xff08;二&#xff09;hello_world&#x1f6aa; &#x1f380;Rust编程语言入门教程&#xff08;三&#xff09; Hello Cargo&#x1f…
阅读更多...
交易所开发:数字市场的核心动力

交易所开发:数字市场的核心动力

数字资产交易所作为连接用户与市场的核心枢纽&#xff0c;已成为推动数字经济发展的关键引擎。其开发不仅需要技术创新&#xff0c;还需兼顾用户体验、合规安全与生态构建&#xff0c;以下是交易所开发的核心要素与实践路径分析&#xff1a; 一、交易所的核心定位与技术架构…
阅读更多...
Jmeter进阶篇（34）如何解决jmeter.save.saveservice.timestamp_format=ms报错？

Jmeter进阶篇（34）如何解决jmeter.save.saveservice.timestamp_format=ms报错？

问题描述 今天使用Jmeter完成压测执行，然后使用命令将jtl文件转换成html报告时，遇到了报错！ 大致就是说jmeter里定义了一个jmeter.save.saveservice.timestamp_format=ms的时间格式，但是jtl文件中的时间格式不是标准的这个ms格式，导致无法正常解析。对于这个问题，有如下…
阅读更多...
Navicat17详细安装教程（附最新版本安装包和补丁）2025最详细图文教程安装手册

Navicat17详细安装教程（附最新版本安装包和补丁）2025最详细图文教程安装手册

目录 前言&#xff1a;为什么选择Navicat 17&#xff1f; 一、下载Navicat17安装包 二、安装Navicat 1.运行安装程序 2.启动安装 3.同意“协议” 4.设置安装位置 5.创建桌面图标 6.开始安装 7.安装完成 三、安装补丁 1.解押补丁包 2.在解压后的补丁包目录下找到“w…
阅读更多...
一文详解U盘启动Legacy/UEFI方式以及GPT/MBR关系

一文详解U盘启动Legacy/UEFI方式以及GPT/MBR关系

对于装系统的老手而说一直想研究一下装系统的原理&#xff0c;以及面对一些问题时的解决思路&#xff0c;故对以前的方法进行原理上的解释&#xff0c;主要想理解其底层原理。 引导模式 MBR分区可以同时支持UEFI和Legacy引导&#xff0c;我们可以看一下微pe制作的启动盘&#…
阅读更多...
LeetCode 热题 100_搜索二维矩阵（64_74_中等_C++）(二分查找)（暴力破解法；Z字形查找；一次二分查找）

LeetCode 热题 100_搜索二维矩阵（64_74_中等_C++）(二分查找)（暴力破解法；Z字形查找；一次二分查找）

LeetCode 热题 100_搜索二维矩阵&#xff08;64_74&#xff09; 题目描述&#xff1a;输入输出样例&#xff1a;题解&#xff1a;解题思路&#xff1a;思路一&#xff08;暴力破解法&#xff09;&#xff1a;思路二&#xff08;Z字形查找&#xff09;&#xff1a;思路三&#x…
阅读更多...
学习量化交易的环境安装记录

学习量化交易的环境安装记录

1、安装anaconda 因为使用python&#xff0c;需要安装anaconda&#xff0c;具体是下面的官方地址&#xff0c;根据自己需要下载相应的版本 https://www.anaconda.com/download 运行上面下载的文件&#xff0c;安装anaconda 可以根据自己需要安装到相应的盘上面 同时环境变量…
阅读更多...
MySQL数据库入门到大蛇尚硅谷宋红康老师笔记 高级篇 part 1

MySQL数据库入门到大蛇尚硅谷宋红康老师笔记 高级篇 part 1

第01章_Linux下MySQL的安装与使用 首先在vmware中下载centos7&#xff0c;实际上8更好一点&#xff0c;不过centos已经是时代的眼泪了&#xff0c;我之前已经教过了&#xff0c;不过是忘了&#xff0c;所以重新说一遍&#xff0c;看文档即可 2.开机前修改mac地址 &#xff0…
阅读更多...
基于AVue的二次封装：快速构建后台管理系统的CRUD方案

基于AVue的二次封装：快速构建后台管理系统的CRUD方案

基于AVue的二次封装&#xff1a;快速构建后台管理系统的CRUD方案 在开发后台管理系统时&#xff0c;表格是常见的组件之一。然而&#xff0c;使用原生的Element Plus实现CRUD&#xff08;增删改查&#xff09;功能往往需要编写大量重复代码&#xff0c;过程繁琐。即使借助类似…
阅读更多...
第6章:基于LangChain如何开发Agents，附带客户支持智能体示例

第6章:基于LangChain如何开发Agents，附带客户支持智能体示例

本文主要介绍了 LangChain4j 中的 Agent&#xff08;代理&#xff09; 概念&#xff0c;以及如何使用 LangChain4j 构建代理系统&#xff0c;重点提供了一个客户支持系统的智能体样例 代理&#xff08;Agents&#xff09;| LangChain4j 注意&#xff1a; 请注意&#xff0c;“A…
阅读更多...
传统的自动化行业的触摸屏和上位机，PLC是否会被取代？

传统的自动化行业的触摸屏和上位机，PLC是否会被取代？

传统的自动化行业的触摸屏和上位机是否会被取代&#xff1f; 在工业自动化领域&#xff0c;触摸屏和上位机长期扮演着核心角色&#xff0c;尤其在污水处理、化工生产等场景中&#xff0c;它们通过实时数据采集、逻辑控制、报警联动等功能&#xff0c;保障了生产设备的稳定运行…
阅读更多...
智能合约的部署

智能合约的部署

https://blog.csdn.net/qq_40261606/article/details/123249473 编译 点击图中的 “Compile 1_Storage.sol” 存和取一个数的合约&#xff0c;remix自带 pragma solidity >0.8.2 <0.9.0; /*** title Storage* dev Store & retrieve value in a variable* custom:d…
阅读更多...
word$deepseep

word$deepseep

1、进入官网地址。 DeepSeek 2、进入DeepSeek的API文档 3、点击DeepSeek开放平台左侧的“API Keys”, 再点击“创建API Key” 4、在弹出的对话框中&#xff0c;输入自己的API Key名称&#xff0c;点击创建。 sk-0385cad5e19346a0a4ac8b7f0d7be428 5、打开Word文档。 6、Word找…
阅读更多...
Mac系统下使用Docker快速部署MaxKB：打造本地知识库问答系统

Mac系统下使用Docker快速部署MaxKB：打造本地知识库问答系统

随着大语言模型的广泛应用&#xff0c;知识库问答系统逐渐成为提升工作效率和个人学习的有力工具。MaxKB是一款基于LLM&#xff08;Large Language Model&#xff09;大语言模型的知识库问答系统&#xff0c;支持多模型对接、文档上传和自动爬取等功能。本文将详细介绍如何在Ma…
阅读更多...
如何为自己的 PDF 文件添加密码？在线加密 PDF 文件其实更简单

如何为自己的 PDF 文件添加密码？在线加密 PDF 文件其实更简单

随着信息泄露和数据安全问题的日益突出&#xff0c;保护敏感信息变得尤为重要。加密 PDF 文件是一种有效的手段&#xff0c;可以确保只有授权用户才能访问或修改文档内容。本文将详细介绍如何使用 CleverPDF 在线工具为你的 PDF 文件添加密码保护&#xff0c;确保其安全性。 为…
阅读更多...
华为昇腾910b服务器部署DeepSeek翻车现场

华为昇腾910b服务器部署DeepSeek翻车现场

最近到祸一台HUAWEI Kunpeng 920 5250&#xff0c;先看看配置。之前是部署的讯飞大模型&#xff0c;发现资源利用率太低了。把5台减少到3台&#xff0c;就出了他 硬件配置信息 基本硬件信息 按照惯例先来看看配置。一共3块盘&#xff0c;500G的系统盘&#xff0c; 2块3T固态…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023