《C++进阶--9.继承》

最新推荐文章于 2024-06-11 22:59:16 发布
最新推荐文章于 2024-06-11 22:59:16 发布
阅读量1.4k 收藏 16
点赞数 45
分类专栏： 从0-1学习c++ 文章标签： 开发语言 c++ 算法 c语言 visualstudio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AGood_Coder/article/details/136334327
版权

目录

9. 继承

9.1 继承的基本语法

9.2 继承方式

9.3 继承中的对象模型

9.4 继承中构造和析构顺序

9.5 继承同名成员处理方式

9.6 继承同名静态成员处理方式

9.7 多继承语法

9.8 菱形继承

9. 继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

9.1 继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同

接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

普通实现：

//Java页面
class Java 
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java,Python,C++...(公共分类列表)" << endl;
    }
    void content()
    {
        cout << "JAVA学科视频" << endl;
    }
};
//Python页面
class Python
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java,Python,C++...(公共分类列表)" << endl;
    }
    void content()
    {
        cout << "Python学科视频" << endl;
    }
};
//C++页面
class CPP 
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java,Python,C++...(公共分类列表)" << endl;
    }
    void content()
    {
        cout << "C++学科视频" << endl;
    }
};
​
void test01()
{
    //Java页面
    cout << "Java下载视频页面如下： " << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
    cout << "--------------------" << endl;
​
    //Python页面
    cout << "Python下载视频页面如下： " << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    cout << "--------------------" << endl;
​
    //C++页面
    cout << "C++下载视频页面如下： " << endl;
    CPP cp;
    cp.header();
    cp.footer();
    cp.left();
    cp.content();
​
}
​
int main() {
​
    test01();
​
    system("pause");
​
    return 0;
}

继承实现：

//公共页面
class BasePage
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
​
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java,Python,C++...(公共分类列表)" << endl;
    }
​
};
​
//Java页面
class Java : public BasePage
{
public:
    void content()
    {
        cout << "JAVA学科视频" << endl;
    }
};
//Python页面
class Python : public BasePage
{
public:
    void content()
    {
        cout << "Python学科视频" << endl;
    }
};
//C++页面
class CPP : public BasePage
{
public:
    void content()
    {
        cout << "C++学科视频" << endl;
    }
};
​
void test01()
{
    //Java页面
    cout << "Java下载视频页面如下： " << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
    cout << "--------------------" << endl;
​
    //Python页面
    cout << "Python下载视频页面如下： " << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    cout << "--------------------" << endl;
​
    //C++页面
    cout << "C++下载视频页面如下： " << endl;
    CPP cp;
    cp.header();
    cp.footer();
    cp.left();
    cp.content();
​
​
}
​
int main() {
​
    test01();
​
    system("pause");
​
    return 0;
}

总结：

继承的好处：可以减少重复的代码

语法：class A : public B; // class 子类 : 继承方式 父类

A 类称为子类 或 派生类

B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

9.2 继承方式

继承的语法：class 子类 : 继承方式 父类

继承方式一共有三种：

  • 公共继承

  • 保护继承

  • 私有继承

示例：

class Base1
{
public: 
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
​
//公共继承
class Son1 :public Base1
{
public:
    void func()
    {
        m_A; //可访问 public权限
        m_B; //可访问 protected权限
        //m_C; //不可访问
    }
};
​
void myClass()
{
    Son1 s1;
    s1.m_A; //其他类只能访问到公共权限
}
​
//保护继承
class Base2
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
class Son2:protected Base2
{
public:
    void func()
    {
        m_A; //可访问 protected权限
        m_B; //可访问 protected权限
        //m_C; //不可访问
    }
};
void myClass2()
{
    Son2 s;
    //s.m_A; //不可访问
}
​
//私有继承
class Base3
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
class Son3:private Base3
{
public:
    void func()
    {
        m_A; //可访问 private权限
        m_B; //可访问 private权限
        //m_C; //不可访问
    }
};
class GrandSon3 :public Son3
{
public:
    void func()
    {
        //Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
        //m_A;
        //m_B;
        //m_C;
    }
};

9.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

示例：

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C; //私有成员只是被编译器隐藏了，但是还是会继承下去
};
​
//公共继承
class Son :public Base
{
public:
    int m_D;
};
​
void test01()
{
    cout << "sizeof Son = " << sizeof(Son) << endl;//16，父类所有非静态成员都会被子类继承下去
}
​
int main() {
​
    test01();
​
    system("pause");
​
    return 0;
}

利用工具查看：

打开工具窗口后，定位到当前CPP文件的盘符

然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名

效果如下图：

结论： 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

9.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

示例：

class Base 
{
public:
    Base()
    {
        cout << "Base构造函数!" << endl;
    }
    ~Base()
    {
        cout << "Base析构函数!" << endl;
    }
};
​
class Son : public Base
{
public:
    Son()
    {
        cout << "Son构造函数!" << endl;
    }
    ~Son()
    {
        cout << "Son析构函数!" << endl;
    }
​
};
​
​
void test01()
{
    //继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
    Son s;
}
​
int main() {
​
    test01();
​
    system("pause");
​
    return 0;
}

总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

9.5 继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

  • 访问子类同名成员 直接访问即可

  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
    Base()
    {
        m_A = 100;
    }
​
    void func()
    {
        cout << "Base - func()调用" << endl;
    }
​
    void func(int a)
    {
        cout << "Base - func(int a)调用" << endl;
    }
​
public:
    int m_A;
};
​
​
class Son : public Base {
public:
    Son()
    {
        m_A = 200;
    }
​
    //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
    //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
    void func()
    {
        cout << "Son - func()调用" << endl;
    }
public:
    int m_A;
};
​
void test01()
{
    Son s;
​
    cout << "Son下的m_A = " << s.m_A << endl;
    cout << "Base下的m_A = " << s.Base::m_A << endl;
​
    s.func();//直接调用 调用的是子类中的同名成员
    s.Base::func();//调用父类中的同名成员
    //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中的所有同名成员函数
    s.Base::func(10);//调用父类中的成员 重载
​
}
int main() {
​
    test01();
​
    system("pause");
    return EXIT_SUCCESS;
}

总结：

  1. 子类对象可以直接访问到子类中同名成员

  2. 子类对象加作用域可以访问到父类同名成员

  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

9.6 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可

  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
    static void func()
    {
        cout << "Base - static void func()" << endl;
    }
    static void func(int a)
    {
        cout << "Base - static void func(int a)" << endl;
    }
​
    static int m_A;
};
​
int Base::m_A = 100;
​
class Son : public Base {
public:
    static void func()
    {
        cout << "Son - static void func()" << endl;
    }
    static int m_A;
};
​
int Son::m_A = 200;
​
//同名成员属性
void test01()
{
    //通过对象访问
    cout << "通过对象访问： " << endl;
    Son s;
    cout << "Son  下 m_A = " << s.m_A << endl;
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
​
    //通过类名访问
    cout << "通过类名访问： " << endl;
    cout << "Son  下 m_A = " << Son::m_A << endl;
    //第一个“：：”代表通过类名的方式访问，第二个“：：”代表访问父类作用域下的数据
    cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}
​
//同名成员函数
void test02()
{
    //1、通过对象访问
    cout << "通过对象访问： " << endl;
    Son s;
    s.func();//自己的fun()
    s.Base::func();//父类的func()
    //2、通过类名的方式访问
    cout << "通过类名访问： " << endl;
    Son::func();
    Son::Base::func();
    //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作用域访问
    Son::Base::func(100);
}
int main() {
​
    //test01();
    test02();
​
    system("pause");
​
    return 0;
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

9.7 多继承语法

三种权限的区别：

  • public:可以被任意实体访问

  • protected:只允许本类及子类的成员函数访问

  • private:只允许本类的成员函数访问

C++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

示例：

class Base1 {
public:
    Base1()
    {
        m_A = 100;
    }
public:
    int m_A;
};
​
class Base2 {
public:
    Base2()
    {
        m_A = 200;  //开始是m_B 不会出问题，但是改为m_A就会出现不明确
    }
public:
    int m_A;
};
​
//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
    Son()
    {
        m_C = 300;
        m_D = 400;
    }
public:
    int m_C;
    int m_D;
};
​
​
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
    Son s;
    cout << "sizeof Son = " << sizeof(s) << endl;
    //当父类中出现同名成员，为了避免二义性，需要加作用域区分
    cout << s.Base1::m_A << endl;
    cout << s.Base2::m_A << endl;
}
​
int main() {
​
    test01();
​
    system("pause");
​
    return 0;
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

9.8 菱形继承

菱形继承概念：

两个派生类继承同一个基类（两个类有一个共同的父类）

又有某个类同时继承者两个派生类（这两个类又有一个共同的子类）

这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

示例：

class Animal
{
public:
    int m_Age;
};
​
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};
​
void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 100;
    st.Tuo::m_Age = 200;
    //菱形继承中，两个父类拥有相同的数据，需要加作用域区分
    cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
    //这份数据只要有一份就可以了，菱形继承导致数据有两份，浪费资源
    //利用虚继承 解决菱形继承的问题
    cout << "st.m_Age = " << st.m_Age << endl;
}
​
​
int main() {
​
    test01();
​
    system("pause");
​
    return 0;
}

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

  • 利用虚继承可以解决菱形继承问题

程序猿！=程序员
关注
  • 45
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++进阶-----继承
weixin_63219391的博客
05-03 686
本文介绍继承相关问题和相关知识
C++进阶----继承
qq_41420788的博客
01-28 840
C++进阶----继承
C++进阶---菱形继承
LoveHoneyYou的博客
07-31 223
菱形继承
C++进阶-继承
~
01-25 1118
【C++进阶学习】C++中的继承零、前言一、继承的概念和定义二、基类和派生类对象赋值转换三、继承中的作用域四、派生类的默认成员函数五、继承和友元六、继承和静态成员七、菱形继承和虚拟继承八、继承和组合九、继承相关面试题 零、前言 从本章开始，我们已经达到了C++的入门水平，开始向进阶进发，而本章则是介绍学习C++的继承 一、继承的概念和定义 概念： 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生.
C++进阶课程讲义_v1.0.4.pdf
04-22
9 C++输入和输出流 51 9.1 I/O流的概念和流类库的结构 51 9.2标准I/O流 53 9.2.1标准输入流 55 9.2.2标准输出流 59 9.3文件I/O 66 9.3.1文件流类和文件流对象 66 9.3.2C++文件的打开与关闭 67 9.3.3C++对ASCII文件的...
清华大学C++进阶讲义：第7章类的继承.pdf
01-22
第7章类的继承
C++进阶，迈向C++高级世界
10-12
C++进阶，迈向C++高级世界 C++是一种功能强大且灵活的编程语言，它提供了大量的语法糖，对开发者来说，这些语法糖可以提高编码效率、减少错误和提高代码可读性。但是，对于初学者来说，C++可能是一个很陌生的领域，...
C++基础和进阶笔记 .docx
08-02
一、C++对C的扩展 5 ...三、继承和派生 45 四、多态 53 五、纯虚函数和抽象类 67 六、函数模板和类模板 80 七、C++的类型转换 102 八、异常处理机制专题 106 九、C++输入和输出流 121 十、STL实用技术专题 144
《由浅入深学C++-基础、进阶与必做300题》pdf格式 （完整版 带目录
07-26
本书循序渐进地讲述了C++的基础知识、C++程序的组成及其开发过程、C++程序中的数据、表达式和语句、控制程序流程、数组与字符串、指针与引用、使用函数、函数模板、错误和异常处理、宏和预编译、面向对象的开发、...
为什么选择Python作为AI开发语言
AI心易行者
06-09 1796
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1016
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 150
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 689
LeetCode 算法：轮转数组c++
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 760
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 328
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 295
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
最新发布
专注于人工智能的算法与应用
06-11 833
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
深度搜索算法3（c++）
mmz1207的博客
06-08 394
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
gcc-c++-4.8.5-4.el7.x86_64
05-09
gcc-c-4.8.5-4.el7.x86_64中包含了一个GNU编译器集合，并且它支持许多流行的编程语言，如C++, Fortran和Java。 在编程过程中，gcc-c-4.8.5-4.el7.x86_64为用户提供了许多功能和选项，以便用户能够使用不同的编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿！=程序员

感谢来过，感谢有你！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值