C++继承概述

最新推荐文章于 2024-11-15 21:44:47 发布
最新推荐文章于 2024-11-15 21:44:47 发布
阅读量185 收藏
点赞数
分类专栏： C++基础内容概述 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiu_yue_ya/article/details/134614173
版权
        面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。
        当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 派生类继承了基类的所有成员变量和函数，在这个基础上再去定义派生类的数据。
        继承代表了一种包含关系。例如，动物作为基类，动物的基本行为有进食和行走，哈士奇也属于动物，我们不必要再去声明一个哈士奇类，可以基础动物类去创建一个哈士奇类，再去添加哈士奇的一些特征，例如拆家，鸟也是动物，也可以基础动物类，在可以加入鸟自己的特征，等等等等。
        继承的语法为： 
class 派生类名: 继承方式 基类名
{
    ...
}
        其中继承方式是决定在派生类中，从基类继承过来的那一部分的成员的访问权限，分为公有继承( public )，受保护继承( protected )和私有继承( private )。
        其中对于公有继承，基类中的数据在派生类中的访问权限如下：
通过公有继承后，基类中的公有成员在派生类中也是公有的，派生类可以正常访问，基类
的私有数据在派生类中是私有的，派生类不可访问，受保护数据在派生类中是受保护的，派生
类可以访问，但类外无法访问。
        对于私有继承，基类中数据在派生类中的访问权限如下：
        通过私有继承后，基类的所有成员在派生类中都是私有的，都不可以访问
        对于受保护继承，基类中数据在派生类中的访问权限如下：
        通过受保护继承后，基类中的公有成员在派生类中变成受保护的，派生类可以正常访问，基类的私有数据在派生类中是私有的，派生类不可访问，受保护数据在派生类中还是受保护的，派生类可以访问。
继承示例： 
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            a = b;
        }
};
class B:public A //公有继承
{
    private:
        int c;
    public:
        B(int x,int y,int z):A(x,y),c(z){}
};
class C:private A //私有继承
{
    private:
        int d;
    public:
        C(int x,int y,int z):A(x,y),d(z){}
};
class D:protected A //受保护继承
{
    private:
        int e;
    public:
        D(int x,int y,int z):A(x,y),e(z){}
};

继承中的构造和析构

        虽然派生类中含有从基类继承来的成员，但是可能没有权限访问(如：基类的私有成员)，所以派生类是不能直接初始化从基类继承来成员，所以，在 C++中，规定每个类控制它自己成员的初始化以及销毁过程，也就是说，基类的成员由基类的构造函数和析构函数来进行初始化和销毁，派生类中新添加的成员，就由派生类的构造函数和析构函数来进行初始化和销毁。
        那么，如果基类有默认构造函数，则实例化派生类对象时，会自动调用基类的默认构造函 数，来初始化从基类继承过来的成员变量，如果基类没有默认构造函数(即基类的构造函数有参数)或者想调用有参数的构造函数，就需要传参数给基类的构造函数，则必须在派生类的构造函数初始化列表中调用基类的构造函数，来完成基类成员的初始化，在上面的例子中就是这样一种情况，但我们还是来说一下在派生类中构造函数初始化列表中如何去初始化基类，格式如下： 
派生类的构造函数名(参数列表):基类构造函数名(参数列表),...
{
    //函数体
}
例如： 
B(int x,int y,int z):A(x,y),c(z){}
B 是派生类，A 是基类，A 的非默认构造函数中有两个参数。
派生类中构造函数和析构函数的调用顺序：
        创建时，先调用基类的构造函数，再调用派生类的构造函数
        销毁时，先调用派生类的析构函数，再调用基类的析构函数

派生类和基类的调用关系

        由于在派生类对象中包含了基类的所有成员，所以我们可以把派生类对象当做基类对象来使 用，具体如下：注意：以下都要建立在公有继承的基础上 ，因为公有继承不会改变基类在派生类中的结构，而其他继承方式都会改变基类在派生类中的结构。
1.可以用派生类对象初始化基类对象(公有继承情况下)
例如： 
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B:public A //公有继承
{
    private:
        int c;
    public:
        B(int x,int y,int z):A(x,y),c(z){}
};
int main(int argc, char const *argv[])
{
    B b(1,2,3); //定义一个派生类对象
    A a = b; //用派生类初始化基类
    a.fun();
    return 0;
}

2.可以用派生类对象给基类对象赋值(公有继承情况下)
例如： 
int main(int argc, char const *argv[])
{
    B b(1,2,3); //定义一个派生类对象
    A a(3,4); //定义一个基类对象
    a = b; //用派生类给基类赋值
    a.fun();
    return 0;
}

3. 基类指针可以指向派生类对象(公有继承情况下)
例如： 
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B:public A //公有继承
{
    private:
        int c;
    public:
        B(int x,int y,int z):A(x,y),c(z){}
        void sun()
        {
            cout << "c:" << c << endl;
        }
};
int main(int argc, char const *argv[])
{
    B b(1,2,3); //定义一个派生类对象
    A *p = &b;
    p->fun();
    return 0;
}

        但是，使用基类指针访问派生类，只能访问从基类中继承下来的数据，不能访问派生类中
新增的数据。
4.基类引用可以绑定到派生类对象(公有继承情况下)
例如： 
int main(int argc, char const *argv[])
{
    B b(1,2,3); //定义一个派生类对象
    A &p = b;
    p.fun();
    return 0;
}
        同样，使用基类引用指向派生类，也只能访问从基类中继承下来的数据，不能访问派生类中新增的数据。

多继承

        多继承即一个子类可以有多个父类，它继承了多个父类的特性。
C++ 类可以从多个类继承成员，语法如下： 
class <派生类名>:<继承方式 1><基类名 1>,<继承方式 2><基类名 2>,…
{
    <派生类类体>
};
例如： 
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B
{
    private:
        int c;
        int d;
    public:
        B(int x,int y):c(x),d(y){}
        void fun()
        {
            cout << "c:" << c << "d:" << d << endl;
        }
};
class C:public A,private B
{
    private:
        int e;
    public:
        C(int a1,int a2,int a3,int a4,int a5):A(a1,a2),B(a3,a4),e(a5){}
};
        在查看上面多继承例子的时候，我们会发现一个问题，如果继承的基类中有相同名字的元素该怎么去访问，或者，不讲多继承，就单继承中基类中有个成员函数名和派生类中的一个成员函数名相同，怎么去访问才不会访问错？方法就是在访问函数名前加上作用域就好了，例如：
        基类 A 中有一个成员函数叫 fun(),派生类 B 继承 A，B 类中又定义了一个 fun()函数，那么在用派生类访问 fun()函数时，如果要访问基类中的 fun()就需要加上作用域来指定,如果不加上，默认为是访问派生类中的 fun()。在多继承中也是如此，例如下面例子 
#include <iostream>
#include<string.h>
using namespace std;
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B
{
    private:
        int c;
        int d;
    public:
        B(int x,int y):c(x),d(y){}
        void fun()
        {
            cout << "c:" << c << "d:" << d << endl;
        }
};
class C:public A,public B
{
    private:
        int e;
    public:
        C(int a1,int a2,int a3,int a4,int a5):A(a1,a2),B(a3,a4),e(a5){}
        void fun()
        {
            cout << "e:" << e << endl;
        }
};
int main(int argc, char const *argv[])
{
    C c(1,2,3,4,5); //定义一个派生类 C
    c.fun(); //默认是访问派生类 C 的 fun 函数
    c.A::fun(); //访问基类 A 的 fun 函数
    c.B::fun(); //访问基类 B 的 fun 函数
    B *p = &c;
    p->fun(); //访问 B 的 fun 函数
    return 0;
}

菱形继承

        菱形继承就是有两个派生类继承一个基类，然后又有一个派生类继承这两个派生类，例如：A 为基类，B 和 C 都继承了 A,D 又继承了 B 和 C,这样的继承关系就叫菱形继承。

例如： 
#include <iostream>
#include<string.h>
using namespace std;
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B:public A
{
    private:
        int c;
        int d;
    public:
        B(int x,int y,int z,int k):A(x,y),c(z),d(k){}
        void fun()
        {
            cout << "c:" << c << "d:" << d << endl;
        }
};
class C:public A
{
    private:
        int e;
    public:
        C(int a1,int a2,int a3):A(a1,a2),e(a3){}
        void fun()
        {
            cout << "e:" << e << endl;
        }
};
class D:public B,public C
{
    private:
        int w;
    public:
        D(int a1,int a2,int a3,int a4,int a5,int a6,int a7,int a8):B(a1,a2,a3,a4),C(a5,a6,a7),w(a8){}
};
int main(int argc, char const *argv[])
{
    D d(1,2,3,4,5,6,7,8); 
    d.B::fun(); //访问 B 中的 fun()
    B *p = &d;
    p->A::fun(); //访问 B 中 A 中的 fun()
    return 0;
}
        如上，B 继承了 A,那么 B 中就有一份 A 的拷贝，C 又继承了 A,那么 C 中也有一份 A 的拷贝，这两个还不是同一个，D 多继承了 B 和 C 后，那么在 D 中就有两份 A 的拷贝，一份来自 B,
一份来自 C,那么就会产生一个问题，D 中有两份名字相同但是来源不同的数据，使得 D 在访问
基类元素时，就会产生二义性，那有没有办法可以使得菱形继承后最后继承的派生类只保存一 份基类元素呢？那就用来学习下我们接下来要说的一个虚继承方式了。

虚继承

        为了解决多继承时的命名冲突和冗余数据问题，C++ 提出了虚继承，使得在派生类中只保留一份间接基类的成员。在继承方式前面或后面加上 virtual 关键字就是虚继承。
虚继承的语法： 
class 派生类名称:继承方式 virtual 基类名称
{
    //...
};
或
class 派生类名称: virtual 继承方式 基类名称
{
    //...
};
例如： 
class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B:public virtual A 
{
    private:
        int c;
        int d;
    public:
        B(int x,int y,int z,int k):A(x,y),c(z),d(k){}
        void fun()
        {
            cout << "c:" << c << "d:" << d << endl;
        }
};
        使用虚继承的类，在内部会生成一个指针，这个指针指向一张虚表，虚表中去维护了基类元素。也就是说上面例子中的派生类 B 的结构如下图所示：

        进行虚继承后，在虚继承类 B 的开头就多了一个指向虚表的指针，这个和虚函数的虚表不一样，这个虚表是用来维护基类用于解决菱形继承问题的。
        其中，容易让人产生误解的是，是不是虚继承之后，我内部有一个虚表了，就不需要去继承基类的元素了，答案是还是要继承一份基类的元素的，如果单纯是单继承或多继承，虚继承的意义其实并不大，但是对于菱形继承，因为存在数据的二义性，所以对于菱形继承，较有重要的意义。
        我们来看虚继承后的菱形继承示例： 
class A
{
    public:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){}
        void fun()
        {
            cout << "a:" << a << "b:" << b << endl;
        }
};
class B:public virtual A
{
    private:
        int c;
        int d;
    public:
        B(int x,int y,int z,int k):A(x,y),c(z),d(k){}
        void funb()
        {
            cout << "c:" << c << "d:" << d << endl;
        }
};
class C:public virtual A
{
    private:
        int e;
        int r;
    public:
        C(int a1,int a2,int a3):A(a1,a2),e(a3){}
        void func()
        {
            cout << "e:" << e << endl;
        }
};
class D:public B,public C
{
    private:
        int w;
    public:
        D(int a1,int a2,int a3,int a4,int a5,int a6,int a7,int a8):A(a1,a2),B(a1,a2,a3,a4),C(a5,a6,a7),w(a8){}
};
        可以看到，没有虚继承时，在派生类 D 中我们是没法对 A 进行构造的，但是，当 B,C 都是 虚继承之后，B 和 C 的内部都会有一个指向虚表的指针，在 D 继承 B,C 之后，D 也会生成一份指向虚表的指针，这个虚表管理着基类 A,所以在构造函数初始化列表中，就可以对 A 进行初始化构造，也必须对 A 进行初始化构造。这个时候 D 中的数据情况如下：

        那么这个时候去访问基类 A 的元素时就不会产生这种不知道是来自 B 中继承的 A 的元素还是来自 C 中继承 A 的元素的问题了，因为基类 A 现在只提供虚表指针进行管理，而 D 中只要有这个虚表指针就可以直接访问基类的元素，和访问 B 中的和 C 中的都一样，因为它们的虚表指针所管理的基类是一样的。
九月丫
关注
专栏目录
C++继承多态
02-08
### C++继承与多态详解 #### 一、概述 在面向对象编程(OOP)中，**继承**和**多态**是两个非常核心的概念。它们不仅能够提高代码的复用性和灵活性，还能帮助开发者更好地组织和管理代码。本文将详细介绍这两个概念...
c++抽象类继承
01-05
根据给定的信息，我们可以深入探讨C++中的抽象类与继承机制。下面将详细介绍如何通过抽象类和继承在C++中实现特定的功能。 ### 概述 在这个示例中，我们有三个具体的类：`Student`、`Lecture` 和 `Module`，它们都...
C++编程基础知识概述
11-01
C++编程基础知识概述 C++是一种强类型、静态编译的通用编程语言，它由Bjarne Stroustrup于1979年在贝尔实验室创建，最初是作为C语言的扩展，后来发展成为一种独立的编程语言。C++以其高效、灵活性和面向对象特性而...
c++基础介绍基础概述
09-19
9. **继承和多态**：继承允许一个类（子类）从另一个类（基类）继承属性和方法，从而实现代码复用。多态性允许不同的对象对同一消息做出不同的响应，是面向对象设计的重要特性。 10. **模板**：模板是C++中的泛型...
C++ 编程语言概述及应用领域
07-16
### C++编程语言概述 C++作为一种通用的、面向对象的编程语言，在多个领域内具有广泛应用，例如系统软件、游戏开发、嵌入式系统、实时系统、操作系统以及高性能计算等。该语言由Bjarne Stroustrup在20世纪70年代...
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
shanshan的博客
11-11 505
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 464
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
C++ 中的string类
2201_75357870的博客
11-15 709
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
STL之vecor的使用(超详解)
2302_80220709的博客
11-11 787
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
C语言之数组
m0_75253775的博客
11-11 1031
前面我们整理了C语言函数相关知识点,C语言中函数有两种特殊情况。
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 1011
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
量化交易backtrader实践(三)_指标与策略篇(8)_股票软件指标参考C
最新发布
AouSdu
11-15 598
主要是学习和实践股票软件中的内置的技术指标公式并且在backtrader中没有的，本节为趋势型指标公式。
lambda 表达式与mutable
王尚权 qq:2515162716
11-15 672
通常情况下，lambda表达式捕获的变量是不可变的，使用mutable关键字可以破坏这种不可变性，允许对捕获变量进行修改。在C++中，mutable关键字和引用捕获方式（&）有不同的用途和效果，它们可以在某些情况下结合使用，但它们的基本功能和影响是不同的。在这个例子中，x既是通过引用捕获的，也是mutable关键字作用的对象。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。
【代码随想录day29】【C++复健】134. 加油站；135. 分发糖果；860.柠檬水找零；406. 根据身高重建队列
yumenohimiko的博客
11-14 627
感觉贪心的题真的很考验一个人的智商，而我，碰巧没有。134. 加油站偷看了解析思路，但依然因为一个低级失误导致被卡了很久... 并且写出来的代码也非常的麻烦，主要体现在我每到一个新节点，就必须求证似的让iter走完一整圈才算结束，但卡哥的方法一个for循环就结束了。卡哥的思路也相当的清晰：简单来说就是当你一圈下来：1 如果和小于0，那么说明无论如何无解，也不用往后再看了。
扫雷游戏代码分享(c基础)
lb3636363636的博客
11-11 2206
创建两个.c 一个.h。
C++ 编程基础（7）内存模型 | 7.1、内存类型
个人技术博客
11-15 168
在C++编程中，内存管理是一个核心概念。了解不同类型的内存区域有助于我们编写更高效、更安全的代码。本文将详细介绍C++程序的五种主要内存类型：堆、栈、全局区、常量区和二进制代码区。
C++ STL -- 模版
无限大的博客
11-14 1049
在C++编程中，对于不同数据类型的操作，常常需要编写多个相似的函数。例如，在一个项目中，我们可能需要实现一个加法功能。
【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序ABCDE
SunMy的博客
11-12 470
【代码】【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序ABCDE。
什么是 C++ 中的常量表达式？ 有什么用途？如何判断一个表达式是否是常量表达式？
SUN_Gyq的博客
11-15 418
由常量和算术运算符（`+`、`-`、`*`、`/`、`%`等）、逻辑运算符（`&&`、`||`、`!`等）、位运算符（`&`、`|`、`^`、`~`、`<<`、`>>`等）组成的表达式，只要其中参与运算的操作数都是常量表达式，那么整个表达式也是常量表达式。模板参数：模板参数必须是常量表达式，这使得模板在编译时就能根据常量表达式的值进行实例化，生成针对特定参数的具体代码，提高了代码的复用性和执行效率。：被声明为`constexpr`的函数，若其参数均为常量表达式，则该函数的返回值也是常量表达式。
C++语言概述：面向对象编程与优势
本节重点深入探讨C++语言概述，主要涵盖了以下几个关键知识点： 1. 面向对象编程：C++是一种支持面向对象（Object-Oriented Programming, OOP）的编程语言。OOP的核心思想是将程序分解为独立的对象，每个对象都有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

九月丫

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值