C++编程（七）继承

已于 2024-07-02 09:23:07 修改
阅读量832 收藏 18
点赞数 26
文章标签： c++ 开发语言
于 2024-07-01 19:17:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44254079/article/details/140038532
版权

文章目录

一、继承

（一）概念

继承是C++的一种机制,用已知的类封装出的新的类，继承描述类与类之间的关系

作用：
为了代码的复用
为了实现多态的必备条件之一

继承中的访问控制权限：public private protected

A类继承B类：
A类叫做子类（派生类）
B类叫做父类（基类）

（二）语法格式

继承的语法格式

class 基类{};
class 子类:继承的权限 基类{};
  • 注：
  • 私有成员也可以被继承过来，但是私有成员被继承过来之后不能访问
  • 公有继承：访问权限不变，只有私有的成员访问不到
    私有继承：会将公有权限和受保护权限变为私有的，私有成员仍是私有成员，但是私有成员访问不到
    受保护继承：会将公有权限和受保护权限变为受保护的，私有成员继承过来还是不可访问
  • 一般继承方式都是public继承
    私有成员和受保护成员是访问不到的，如果想要访问私有成员和受保护成员可以借助基类的公有成员的接口
  • 如果不加继承控制权限，默认是private私有继承权限
  • 通过子类访问父类中的成员：
    在子类中访问父类中的成员：
    父类名::成员变量名;
    父类名::成员函数名;
    在类外通过子类访问父类中的成员：
    子类对象名.父类名::成员变量名;
    子类对象名.父类名::成员函数名;
  • 如果子类和父类中出现同名的成员变量名，不会起冲突；
    如果在子类中访问同名成员变量，什么都不加，默认是通过this指针

（三）通过子类访问父类中的成员

1. 类内

Father :: Father_show();

2. 类外

son.Father::Father_show();

#include <iostream>
using namespace std;
class Father{
public:
    int a=10;
};
class son:public Father{
public:
    void show(void){
        cout<<"a="<<Father::a<<endl;
    }
};

int main()
{
    son son1;
    son1.show();
    return 0;
}

（四）继承中的特殊成员函数

构造函数、析构函数、拷贝构造函数、拷贝赋值函数

1. 构造函数

构造函数在继承关系中不会被继承
如果在子类的构造函数中没有显式的调用父类的构造函数，编译器会默认先调用父类的无参的构造函数
如果在子类的构造函数中显式地调用父类的构造函数，会先调用父类的构造函数，再调用子类的构造函数

#include <iostream>
using namespace std;
//基类
class Base
{
public:
    Base(int a): value(a) {
        cout<<"base"<<endl;
    }
    int value = 100;
    ~Base(){
        cout<<"~base"<<endl;
    }
};
//子类
class Son1: Base  //说明不写访问控制权限,默认是private
{
public:
    Son1(int a): Base(a) {
        cout<<"son1"<<endl;
    }
    ~Son1(){
        cout<<"~son1"<<endl;
    }
};
int main()
{
    Son1 son(10);   //实例化对象son2
    return 0;
}

在这里插入图片描述

2. 析构函数

1.析构函数在继承关系中不会被继承
2.如果子类中没有显式的调用析构函数,编译器会使用子类的析构函数;
编译器也会默认调用父类的析构函数;
3.如果在子类中重写了子类的析构函数,父类中重写父类的析构函数
先调用子类的析构函数----再调用父类的析构函数

3. 拷贝构造函数

1.如果在子类中不显式的调用父类的拷贝构造函数,
会调用编译器提供的缺省的拷贝构造函数来完成对成员的拷贝操作;
提供的缺省的拷贝构造函数是一个浅拷贝;

2.如果在子类中显式的调用父类的拷贝构造函数,会调用自己写的拷贝构造函数;
想要调用父类的拷贝构造函数需要在子类的拷贝构造函数的初始化列表中显式的调用父类的拷贝构造函数;
eg：
//父类的指针或者是引用指向子类的对象—多态中讲
子类类名(const 子类类名 &obj): 父类类名(传参){}

3.如果在类中没有指针类型的成员,可以使用编译器提供的缺省的拷贝构造函数; //浅拷贝
如果在类中有指针类型的成员,需要自己实现深拷贝构造函数

#include <iostream>

using namespace std;
class Base
{
public:
    Base(int a): data(a)
    {
        cout << "Base(int a):data(a)" << endl;
    }
    ~Base(void)
    {
        cout << " ~Base(void)" << endl;
    }
    //拷贝构造函数
    Base(const Base &obj)
    {
        cout << "Base(const Base &obj)"  << endl;
        data = obj.data;
    }
private:
    int data;
};
class Son: public Base
{
public:
    Son(int a): Base(a)
    {
        cout << "Son(int a):Base(a)" << endl;
    }
    ~Son(void)
    {
        cout << " ~Son(void)" << endl;
    }
    //子类的拷贝构造函数
    //父类的指针或者是引用指向子类的对象(多态中讲)
    Son(const Son &obj): Base(obj)
    {
        cout << " Son(const Son &obj):Base(obj)" << endl;
    }
private:
};

int main()
{
    //实例化对象
    //Son son1;  //调用无参构造函数
    Son son1(10);   //调用有参构造函数
    Son son2 = son1;  // 调用拷贝构造函数
    return 0;
}

4. 拷贝赋值函数

1.如果在子类中不显式的调用父类的拷贝赋值函数,会调用编译器提供的缺省的拷贝赋值函数 来完成对成员的拷贝赋值操作;
默认提供的拷贝赋值函数是一个浅拷贝;

2.如果在子类中想要显式的调用父类的拷贝赋值函数,需要在子类的拷贝赋值函数中使用调用父类的拷贝赋值函数
格式：
父类::成员函数(传递参数); //需要在子类的拷贝赋值函数中写

3.如果在类中没有指针类型的成员,可以使用编译器提供的默认缺省的拷贝赋值函数
如果在类中有指针类型的成员,需要自己实现深拷贝赋值函数

#include <iostream>

using namespace std;
class Base
{
public:
    Base(int a): data(a)
    {
        cout << "Base(int a):data(a)" << endl;
    }
    ~Base(void)
    {
        cout << " ~Base(void)" << endl;
    }
    //拷贝赋值函数
    Base &operator =(const Base &obj)
    {
        cout << "Base &operator =(const Base &obj)" << endl;
        if(this != &obj) {
            //拷贝赋值操作
            data = obj.data;
        }
        return *this;
    }
private:
    int data;
};
class Son: public Base
{
public:
    Son(int a): Base(a)
    {
        cout << "Son(int a):Base(a)" << endl;
    }
    ~Son(void)
    {
        cout << " ~Son(void)" << endl;
    }
    //拷贝赋值函数
    Son &operator =(const Son &obj)
    {
        cout << "Son &operator =(const Son &obj)" << endl;
        if(this != &obj) {
            //拷贝赋值函数
            //想要显式的使用父类的拷贝赋值函数
            //调用父类的拷贝赋值函数
            //父类的指针或者是引用指向子类对象(多态中讲)
            Base::operator =(obj);
        }
        return *this;
    }
private:
};

int main()
{
    //实例化对象
    //Son son1;  //调用无参构造函数
    Son son1(10);   //调用有参构造函数
    Son son3(11);
    son1 = son3;  //调用拷贝赋值函数
    return 0;
}

二、多重继承

（一）概念

1. 多重继承

一个子类继承于多个父类叫做多重继承

2. 语法格式

class 基类1{};
class 基类2{};
class 子类:public 基类1,public 基类2{};

实际开发中不建议使用多重继承，因为在不同的基类中包含相同名字的成员，容易出现歧义，如果不想出现歧义，需要通过子类访问父类中的成员;
格式：子类对象名.父类名::成员；

（二）使用示例

#include <iostream>
using namespace std;
class Base1{
public:
    int a=10;
};
class Base2{
public:
    int a=200;
};

class son:public Base1,public Base2{
};

int main()
{
    son son1;
    cout<<"Base1::a="<<son1.Base1::a<<" Base2::a="<<son1.Base2::a<<endl;
    return 0;
}

输出结果：
在这里插入图片描述

注意
如果此时直接调用son1中的a会报错，因为son1从base1和base2中都继承了a，所以当直接调用时，会产生歧义，导致编译器无法确定是打印从哪个基类继承的值
在这里插入图片描述

三、链式继承

链式继承中构造函数的初始化列表只需要关注自己继承的基类即可

#include <iostream>
using namespace std;
class Grandfather{
public:
    Grandfather(int aa):a(aa){
        cout<<"Grandfather 构造函数"<<endl;
    }
    ~Grandfather(void){
        cout<<"Grandfather 析构函数"<<endl;
    }
    int a=10;
};

class Father:public Grandfather{
public:
    Father(int aa,int bb):b(bb),Grandfather(aa){
        cout<<"Father 构造函数"<<endl;
    }
    ~Father(void){
        cout<<"Father 析构函数"<<endl;
    }
    int b=20;
};

class son:public Father{
public:
    son(int aa,int bb,int cc):c(cc),Father(aa,bb){
        cout<<"son 构造函数"<<endl;
    }
    ~son(void){
        cout<<"son 析构函数"<<endl;
    }
    int c=30;
};

int main()
{
    son son1(100,200,300);
    return 0;
}

输出结果：
在这里插入图片描述

四、扇形继承

扇形继承中子类的初始化列表需要把所有基类都考虑进去

#include <iostream>
using namespace std;
class Mother{
public:
    Mother(int aa):a(aa){
        cout<<"Mother 构造函数"<<endl;
    }
    ~Mother(void){
        cout<<"Mother 析构函数"<<endl;
    }
    int a=10;
};

class Father{
public:
    Father(int bb):b(bb){
        cout<<"Father 构造函数"<<endl;
    }
    ~Father(void){
        cout<<"Father 析构函数"<<endl;
    }
    int b=20;
};

class son:public Mother,public Father{
public:
    son(int aa,int bb,int cc):c(cc),Mother(aa),Father(bb){
        cout<<"son 构造函数"<<endl;
    }
    ~son(void){
        cout<<"son 析构函数"<<endl;
    }
    int c=30;
};

int main()
{
    son son1(100,200,300);
    return 0;
}

输出结果：
在这里插入图片描述

五、菱形继承(钻石继承)和虚继承

（一）概念

虚继承是一种机制，作用是就是为了解决钻石继承中继承多份父类数据的问题
虚继承共享同一份数据，虚继承会间接或是直接影响基类或者子类的数据

（二）语法格式

class 子类类名: virtual 继承方式 基类类名{}

（三）使用示例

#include <iostream>
using namespace std;
class Base{
public:
    Base(int b):base(b){
        cout<<"Base 构造函数"<<endl;
    }
    ~Base(void){
        cout<<"Base 析构函数"<<endl;
    }
    int base=10000;
};

class Mother:public Base{
public:
    Mother(int aa,int base):Base(base),a(aa){
        cout<<"Mother 构造函数"<<endl;
    }
    ~Mother(void){
        cout<<"Mother 析构函数"<<endl;
    }
    int a=10;
};

class Father:public Base{
public:
    Father(int bb,int base):Base(base),b(bb){
        cout<<"Father 构造函数"<<endl;
    }
    ~Father(void){
        cout<<"Father 析构函数"<<endl;
    }
    int b=20;
};

class son:public Mother,public Father{
public:
    son(int aa,int bb,int cc,int base):Mother(aa,base),Father(bb,base),c(cc){
        cout<<"son 构造函数"<<endl;
    }
    ~son(void){
        cout<<"son 析构函数"<<endl;
    }
    int c=30;
};

int main()
{
    son son1(100,200,300,1);

    return 0;
}

输出结果：
在这里插入图片描述
但是如果此时想要调用son1.base就会产生歧义，因为son1从两个父类中都分别继承了一个base，继承类继承了基类多次，从而产生了歧义
在这里插入图片描述

（四）虚继承


#include <iostream>
using namespace std;
//虚基类
class Base{
public:
    Base(int b):base(b){
        cout<<"Base 构造函数"<<endl;
    }
    ~Base(void){
        cout<<"Base 析构函数"<<endl;
    }
    int base=10000;
};
//加上关键字virtual声明成虚基类
class Mother:virtual public Base{
public:
    Mother(int aa,int base):Base(base),a(aa){
        cout<<"Mother 构造函数"<<endl;
    }
    ~Mother(void){
        cout<<"Mother 析构函数"<<endl;
    }
    int a=10;
};
//加上关键字virtual声明成虚基类
class Father:virtual public Base{
public:
    Father(int bb,int base):Base(base),b(bb){
        cout<<"Father 构造函数"<<endl;
    }
    ~Father(void){
        cout<<"Father 析构函数"<<endl;
    }
    int b=20;
};

//汇聚子类
class son:public Mother,public Father{
public:
    son(int aa,int bb,int cc,int base):Base(base),Mother(aa,base),Father(bb,base),c(cc){
	//虚基类的构造函数是由最底层的派生类直接调用的，而不是由每个直接派生类调用。        
        cout<<"son 构造函数"<<endl;
    }
    ~son(void){
        cout<<"son 析构函数"<<endl;
    }
    int c=30;
};

int main()
{
    son son1(100,200,300,1);
    cout<<son1.a<<endl;
    cout<<son1.b<<endl;
    cout<<son1.c<<endl;
    cout<<son1.base<<endl;
    return 0;
}
  • 注：
  • 此时基类Base被称作虚基类，子类son1称为汇聚子类
  • 虚基类的构造函数是由最底层的派生类直接调用的，而不是由每个直接派生类调用。因此汇聚子类的初始化列表中必须显式的写虚基类的有参构造函数。
臻一
关注
  • 26
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++泛型编程
蹦跶跶
06-04 5742
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++编程实例100篇
08-28
《C++编程实例100篇》是一本深入浅出的C++编程教程，它以实践为主导，通过丰富的实例帮助学习者掌握C++语言的基础和核心概念。这本书的每个实例都精心设计，旨在帮助初学者和有经验的开发者巩固和提升C++编程技能。 ...
C++编程——继承
professor_tao的博客
04-25 3777
文章目录1. 继承的基本语法2. 继承方式 继承的知识点结构： 继承是面向对象三大特性之一，例如动物类下可以有猫类、狗类。显然猫类、狗类都具有动物类的属性，于此同时，也就有自己独特的属性。这个时候，猫类、狗类就是继承于动物类，采用继承的技术，可以减少重复的代码。 1. 继承的基本语法 语法：class 子类：继承方式 基类 继承示例： 一般网页都有很多部分相似的，我们可以将这些相似的部分抽象出来，作为一个基类。然后子类只需要继承基类，在基类的基础上添加自身其他的属性或者方法就可以实现基本的功能，同时减少
《黑马》——C++核心编程
热门推荐
漏网小鱼的博客
09-05 21万+
前言： ** 配套视频： https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=16795623907667609637 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局
C++ 编程规范-private继承
劲草浅躬行
03-25 3441
Private继承基础知识 延伸： 简单地说下C++类的3种继承方式，分别是public继承，protected继承，private继承。 最常用的还是public继承。class默认的是private继承，它的member如果没写权限也是默认 private。struct则相反，默认的是public继承。结合下面的图示和代码，对C++的继承就有了比较清晰的认识了。 1. 父类引用子类 & 父类指针绑定子类 public继承的时候，以下可行。也就是只有is-a关系的时候，才能采用父类引用绑定子类以
C++类的继承（终极版）简单易懂
weixin_64067830的博客
04-24 6万+
大家好，这里是小张，今天给大家带来的是C++类的继承终极篇，今天小张会把剩下的类的继承内容全部说完，希望能够帮助到大家，话不多说，我们现在就开始。首先先来说说在继承中同名成员的处理方式：如果是访问子类同名成员，直接访问就好，如果要是访问父类的同名成员，需要加作用域（::），详情见以下代码： //继承同名成员的处理方式 //访问子类同名成员，直接访问就好 //访问父类的同名成员，需要加作用域 #include<iostream> using namespace ...
Google 的 C++编程规范
weixin_44835655的博客
03-22 1222
Google 的C++编程规范及C++类型推导；
C++ 多重继承
xiaogangjava的博客
11-29 4736
C++ 编程语言技术知识积累
C++：继承与派生
qq_53826699的博客
06-07 4814
继承与派生的概念 基类与派生类 访问权限控制 派生类的构造函数、析构函数 构造函数与析构函数 duo'ji'c
C++语言编程
dqcmiss的博客
09-01 5551
C++语言是一门面向对象的编程，，它的优点是容易维护，出现问题可以精确定位到。“C”with Class”阶段，C语言基础上的特征主要有：类及派生类、共有和私有成员、构造函数和析构函数、友元、内联函数、赋值运算符的重载，等等。...
C++——继承
新手的博客
04-20 1483
一、继承和派生 1.继承的概念 继承是一种创建新类的方式，新建的类可以继承一个或多个类。可以理解子承父业 所以继承描述的是类和类之间的关系 新建的类被称之为派生类(子)类，之前就存在的类被称之为基(父)类 2.继承和派生 继承和派生是同一个过程，从不同的角度来看的 一个新类从已经存在的类哪里获取其已有的特性，这个叫继承(儿子继承父亲的财产) 从已存在的类产生一个子类，这个叫派生(父亲把财产给儿子) 3.继承分类 新建的类继承一个类，这个是单继承 新建的类继承多个类，这个叫多继承 二、继承方式 1
C++编程思想
09-30
《C++编程思想》是一本深受程序员喜爱的经典书籍，它深入浅出地介绍了C++这一强大的编程语言。这本书不仅涵盖了C++的基础语法，还详细探讨了面向对象编程、泛型编程以及设计模式等高级主题。以下是对这本书中关键...
解析C++编程中的继承方面的运用
01-01
C++继承与组合详解 我们知道，在一个类中可以用类对象作为数据成员，即子对象（详情请查看：C++有子对象的派生类的构造函数）。实际上，对象成员的类型可以是本派生类的基类，也可以是另外一个已定义的类。在一个类...
c++编程实例
10-18
本资源集合了一系列C++编程实例，旨在帮助初学者快速掌握C++语言的核心概念和实际应用技巧。 1. **基础语法**：C++的基础包括变量声明、数据类型（如int、char、float等）、运算符（如算术、比较、逻辑运算符）以及...
C++ 编程入门讲义大全
08-07
目录 介绍 基本语法 变量与数据类型 输入和输出 运算符 控制流程 条件语句 循环语句 函数与模块化 定义函数 函数参数与返回值 ...继承与多态 异常处理 标准库简介 输入输出流 字符串处理 容器与算法
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1098
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 217
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 153
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
最新发布
m0_59680769的博客
07-16 977
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
C++编程：继承与派生基础教程
"C++继承和派生是C++面向对象编程中的重要概念，用于实现类之间的层次结构和代码复用。继承允许创建一个新类（派生类）时，基于已有类（基类）的特点，并可以扩展新的特性。在C++中，派生类可以通过`public`、`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值