C++类继承

已于 2024-04-02 21:54:14 修改
阅读量468 收藏 9
点赞数 10
分类专栏： C++基础 文章标签： c++
于 2024-04-02 15:59:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45842249/article/details/137264580
版权
本文详细介绍了C++中的类继承机制，包括基本概念、不同继承方式下的访问权限控制、构造函数和析构函数的行为，以及多继承和菱形继承的问题及虚继承的解决方案。
摘要由CSDN通过智能技术生成

类继承

  • 继承一笔财产比白手起家要轻松。
  • 重用经过测试的、可靠的代码，比从头开始写代码要好得多。
  • 类继承的目的是代码重用。

类继承-基本概念

继承可以理解为一个类从另一个类获取成员变量和成员函数的过程。
语法：

class 派生类名：[继承方式] 基类名
{
	派生类新增的成员
}

被继承的类称为基类或父类，继承的类称为派生类或子类。
继承和派生是一个概念，只是站的角度不同。
派生类除了拥有基类的成员，还可以定义新的成员，以增强其功能。
使用继承的场景:

  1. 如果新创建的类与现有的类相似，只是多出若干成员变量或成员函数时，可以使用继承。
  2. 当需要创建多个类时，如果它们拥有很多相似的成员变量或成员函数，可以将这些类共同的成员提取出来，定义为基类，然后从基类继承。

对于1：
我们设计一个海选报名者类，这个类里面的成员函数只有姓名和联系方式。报名时需要唱一首歌，长的好听就可以留下，正式成为一名超女，所以我们还有一个超女类，继承海选报名表类。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class CAIIComers       //海选报名表类。
{
public:
    string m_name;//姓名
    string m_tel;//联系方式
    //构造函数
    CAIIComers() { m_name = "某女";m_tel = "不详"; }
    //报名时需要唱一首歌
    void sing() { cout << "我是一只小小鸟。\n"; }
    //设置姓名
    void setname(const string& name) { m_name = name; }
    //设置电话号码
    void settel(const string& tel) { m_tel = tel; }
};
class CGirl :public CAIIComers {//超女类
public:
    int m_bh;//编号
    CGirl() { m_bh = 8; }
    void show(){ cout << "编号:" << m_bh << ",姓名:" << m_name << ",联系电话：" << m_tel << endl; }


};
                  
int main()
{
    CGirl g;
    g.setname("西施");
    g.show();
}

对于2：例如
在这里插入图片描述

类继承-继承方式

类成员的访问权限由高到低依次为: public -> protected -> private，public成员在类外可以访问，private成员只能在类的成员函数中访问。
如果不考虑继承关系，protected成员和private成员一样，类外不能访问。但是，当存在继承关系时,protected和private就不一样了。基类中的protected成员可以在派生类中访问，而基类中的private成员不能在派生类中访问。
继承方式有三种: public(公有的)、 protected(受保护的）和private(私有的)。它是可选的，如果不写，那么默认为private。不同的继承方式决定了在派生类中成员函数中访问基类成员的权限。
在这里插入图片描述
这张图描述了三种继承方式下，派生类成员访问权限的变化。

  1. 基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为protected时，那么基类成员在派生类中的访问权限最高也为protected，高于protected 的会降级为protected，但低于protected不会升级。再如，当继承方式为public时，那么基类成员在派生类中的访问权限将保持不变。
    也就是说，继承方式中的public、protected、private是用来指明基类成员在派生类中的最高访问权限的。

  2. 不管继承方式如何，基类中的private成员在派生类中始终不能使用(不能在派生类的成员函数中访问或调用)。

  3. 如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为public或protected;只有那些不希望在派生类中使用的成员才声明为private。

  4. 如果希望基类的成员既不向外暴露（不能通过对象访问)，还能在派生类中使用，那么只能声明为protected。
    由于private和protected继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中，一般使用public

    在派生类中，可以通过基类的公有成员函数间接访问基类的私有成员。
    例如：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A       //基类。
{
private:
    int m_a = 10;
public:
    int m_b = 20;
    void func() {
        m_a = 11;
        cout << "m_a" << m_a << endl;
    }
};
class B :public A {//派生类
   

};
                  
int main()
{
    B b;
   // b.ma = 11;
    b.func();
}


**使用`using`关键字可以改变基类成员在派生类中的访问权限。**
注意: `using`只能改变基类中`public`和`protected`成员的访问权限，不能改变`private`成员的访问权限，因为基类中`private`成员在派生类中是不可见的，根本不能使用。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A       //基类。
{
public:
    int m_a = 10;
protected:
    int m_b = 20;
private:
    int m_c = 30;
};
class B :public A {//派生类
public:
    using A::m_b;//把m_b的权限修改为共有的
private:
    using A::m_a;//把m_a的权限修改为私有的
};
                  
int main()
{
    B b;
    //b.m_a = 11;
    b.m_b = 21;
    //b.m_c = 21;
}

类继承-继承的对象模型

  1. 创建派生类对象时，先调用基类的构造函数，再调用派生类的构造函数。
  2. 销毁派生类对象时，先调用派生类的析构函数，再调用基类的析构函数。
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    A() { cout << "调用了A的构造函数"; }
    ~A() { cout << "调用了A的析构函数"; }
};

class B :public A {//子类
public:
    B() { cout << "调用了B的构造函数.\n"; }
    ~B() { cout << "调用了B的析构函数.\n"; }
};
class C :public B {//孙类
public:
    C() { cout << "调用了C的构造函数.\n"; }
    ~C() { cout << "调用了C的析构函数.\n"; }
};
int main() {
    C c;
}
  1. 创建派生类对象时只会申请一次内存，派生类对象包含了基类对象的内存空间this指针相同的。
  2. 创建派生类对象时，先初始化基类对象，再初始化派生类对象。
  3. 在VS中，用cl.exe可以查看类的内存模型。
  4. 对派生类对象用sizeof得到的是基类所有成员（包括私有成员)+派生类对象所有成员的大小。
  5. 在C++中，不同继承方式的访问权限只是语法上的处理。
  6. 对派生类对象用memset()会清空基类私有成员。
  7. 用指针可以访问到基类中的私有成员（内存对齐)。

类继承-如何构造基类

派生类构造函数的要点如下:

  1. 创建派生类对象时，程序首先调用基类构造函数，然后再调用派生类构造函数。
  2. 如果没以指定基类构造函数，将使用基类的默认构造函数。
  3. 可以用初始化列表指明要使用的基类构造函数。
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    int m_a;
private:
    int m_b;
public:
    A() :m_a(0), m_b(0) {//基类的默认构造函数
        cout << "调用了基类的默认构造函数A().\n";
    }
    A(int a, int b):m_a(a),m_b(b) {//基类的两个参的默认构造函数
        cout << "调用了基类的默认构造函数A(int a, int b).\n";
    }
    A(const A& a) :m_a(a.m_a + 1), m_b(a.m_b + 1) {//基类的拷贝构造函数
        cout << "调用了基类的拷贝构造函数A(const A& a).\n";
    }
    //显示基类A全部的成员
    void showA() {
        cout << "m_a=" << m_a << ",m_b=" << m_b << endl;
    }
};
class B :public A {//派生类
public:
    int m_c;
    B() :m_c(0),A() {//派生类的默认构造函数
        cout << "调用了派生类的构造函数B()\n";
    }
    B(int a, int b, int c) :A(a, b), m_c(0) {//基类的三个构造函数
        cout << "调用了派生类的构造函数B(int a,int b,int c)。\n";
    }
    B(const A& a, int c) :A(a), m_c(c) {//指明基类的拷贝构造函数
        cout << "调用了派生类的拷贝构造函数B(constA &a,int c)。\n";
    }

    //显示派生类B全部的成员
    void showB() {
        cout << "m_c=" << m_c << endl << endl;
    }
};
int main() {
    B b1;//调用基类的默认构造函数
    b1.showA();
    b1.showB();
    B b2(1, 2, 3);//调用两个参数的构造函数
    b2.showA(); b2.showB();

    A a(10, 20);//创建基类对象
    B b3(a, 30);//将调用基类的拷贝构造函数
    b3.showA();b3.showB();

}
  1. 基类构造函数负责初始化被继承的数据成员;派生类构造函数主要用于初始化新增的数据成员。
  2. 派生类的构造函数总是调用一个基类构造函数，包括拷贝构造函数。

类继承-名字遮挡和类作用域

如果派生类中的成员（包括成员变量和成员函数）和基类中的成员重名，通过派生类对象或者在派生类的成员函数中使用该成员时，将使用派生类新增的成员，而不是基类的。
例如：这个执行结果是80；

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    int m_a = 30;
    void func() { cout << "调用了A的func()函数.\n"; }
};
class B :public A {//派生类
public:
    int m_a = 80;
    void func() { cout << "调用了B的func()函数.\n"; }
};
int main() {
    B b;
    cout << "m_a的值是:" << b.m_a << endl;
    b.func();
}

注意：基类的成员函数和派生类的成员函数不会构成重载，如果派生类有同名函数，那么就会遮蔽基类中的所有同名函数。

   类是一种作用域，每个类都有它自己的作用域，在这个作用域之内定义成员。
   在类的作用域之外，普通的成员只能通过对象（可以是对象本身，也可以是对象指针或对象引用)来访问，静态成员可以通过对象访问，也可以通过类访问。
   在成员前面加类名和域解析符可以访问对象的成员。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    int m_a = 30;
    int m_b = 50;
    void func() { cout << "调用了A的func()函数.\n"; }
    void func(int m_a) { cout << "调用了A的func(int a)函数";A::m_a = m_a; }
};
int main() {
    A a;
    cout << "m_a的值是:" << a.A::m_a << endl;
    a.A::func();
}

   如果不存在继承关系，类名和域解析符可以省略不写。
   当存在继承关系时，基类的作用域嵌套派生类的作用域中。
如果成员在派生类的作用域已经找到，就不会在基类作用域中继续查找;如果没有找到，则继续在基类作用域中查找。
   如果在成员的前面加上类名和域解析符，就可以直接使用该作用域的成员。
在这里插入图片描述
例如这个：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    int m_a = 10;
    void func() { cout << "调用了A的func()函数.\n"; }
};
class B :public A {//子类
public:
    int m_a = 20;
    void func() { cout << "调用了B的func()函数.\n"; }
};
class C :public B {//孙类
public:
    int m_a = 30;
    void func() { cout << "调用了C的func()函数.\n"; }
};
int main() {
    C c;
    cout << "C::m_a的值是:" << c.C::m_a << endl;
    cout << "B::m_a的值是:" << c.B::m_a << endl;
    cout << "A::m_a的值是:" << c.A::m_a << endl;
    c.C::func();
    c.B::func();
    c.A::func();
}

类继承-继承的特殊关系

派生类和基类之间有一些特殊关系。

  1. 如果继承方式是公有的，派生类对象可以使用基类成员。
  2. 可以把派生类对象赋值给基类对象（包括私有成员)，但是，会舍弃非基类的成员。
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    int m_a = 0;
private:
    int m_b = 0;
public:
    void show() { cout << "A::show() m_a="<<m_a<<",m_b="<<m_b<<endl; }
    void setb(int b) { m_b = b; }
};
class B :public A {//子类
public:
    int m_c = 0;
    void show() { cout << "B::show() m_a=" << m_a << ",m_c=" << m_c << endl; }
};
int main() {
    A a;
    B b;
    b.m_a = 10;
    b.setb(20);
    b.m_c = 30;

    a.show();

    a = b;
    a.show();
}

在这里插入图片描述

  1. 基类指针可以在不进行显式转换的情况下指向派生类对象。
    如果是指针的话要用->
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {//基类
public:
    int m_a = 0;
private:
    int m_b = 0;
public:
    void show() { cout << "A::show() m_a="<<m_a<<",m_b="<<m_b<<endl; }
    void setb(int b) { m_b = b; }
};
class B :public A {//子类
public:
    int m_c = 0;
    void show() { cout << "B::show() m_a=" << m_a << ",m_c=" << m_c << endl; }
};
int main() {
    B b;
    A* a = &b;
    b.m_a = 10;
    b.setb(20);
    b.m_c = 30;

    a->m_a = 11;
    a->setb(22);
    //a->m_c = 30;

    a->show();
}
  1. 基类引用可以在不进行显式转换的情况下引用派生类对象。
    注意:
  2. 基类指针或引用只能调用基类的方法，不能调用派生类的方法。（主要是多态哪里）
  3. 可以用派生类构造基类。
  4. 如果函数的形参是基类，实参可以用派生类。
  5. C++要求指针和引用类型与赋给的类型匹配，这一规则对继承来说是例外。但是，这种例外只是单向的，不可以将基类对象和地址赋给派生类引用和指针（没有价值，没有讨论的必要)。

类继承-多继承和虚继承

多继承的语法：
class派生类名:[继承方式1] 基类名1,[继承方式2] 基类名2,…
{
派生类新增加的成员
}

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A1 {//基类一
public:
    int m_a = 10;
};
class A2  {//基类二
public:
    int m_b = 20;
};
class B :public A1, public A2 {//派生类
public:
    int m_c = 30;
};
int main() {
    B b;
    cout << "m_a的值是:" << b.m_a << ",m_b的值是:" << b.m_b << ",m_c的值是:" << b.m_c << endl;
}



#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A1 {//基类一
public:
    int m_a = 10;
};
class A2  {//基类二
public:
    int m_a = 20;
};
class B :public A1, public A2 {//派生类
public:
    int m_a = 30;
};
int main() {
    B b;
    cout << "B::m_a的值是:" << b.m_a << endl;
    cout << "A1::m_a的值是:" << b.A1::m_a << endl;
    cout << "A2::m_a的值是:" << b.A2::m_a << endl;
}

菱形继承：
在这里插入图片描述

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {
public:
    int m_a = 10;
};
class B:public A  {
};
class C :public A {
};
class D :public B, public C {};
int main() {
    D d;
    //d.m_a会报错
    d.B::m_a = 30;
    d.C::m_a = 20;
    cout << "B::m_a的地址是:" << &d.B::m_a << ",值是：" << d.B::m_a << endl;
    cout << "C::m_a的地址是:" << &d.C::m_a << ",值是：" << d.C::m_a << endl;

}

对于这个代码：如果直接赋值d.m_a会报错。B,C这是两个地址两个值。
在这里插入图片描述
也就是说，菱形继承存在两个问题:数据冗余和名称的二义性。解决这个问题，C++引入了虚继承技术。语法很简单，在派生类B和C继承A的定义中，加上virtual关键字

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                  
class A {
public:
    int m_a = 10;
};
class B:virtual public A  {
};
class C:virtual public A {
};
class D:public B, public C {};
int main() {
    D d;
    //d.m_a会报错
    d.B::m_a = 30;
    d.C::m_a = 20;
    cout << "B::m_a的地址是:" << &d.B::m_a << ",值是：" << d.B::m_a << endl;
    cout << "C::m_a的地址是:" << &d.C::m_a << ",值是：" << d.C::m_a << endl;

}

在这里插入图片描述

::呵呵哒::
关注
专栏目录
C++类继承示例
01-20
C++的子类与孙子类都实现了虚函数时，孙子类的实现会覆盖掉子类的实现。 　继承的主要的应用是把不同的类放到一个数组中，然后遍历调用同名函数。 　实例如下： #include #include #include using ...
c++类继承关系
10-23
c++类继承关系 Hierarchy Chart 继承关系 基类CObject派生出的各类,MSDN中用
C++类继承 继承后函数的值实现详解
08-25
主要介绍了C++类继承 继承后函数的值实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C 学习（4）
search7的博客
11-05 523
C语言学习，每个模块来自工作中的？？？
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 571
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
杨辉三角——c语言
aqua3535742358的博客
11-05 62
define N 10 //自己定义输出行数。
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 259
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 343
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 378
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
new 和 delete 运算符在 C++ 中的作用以及什么是内存泄漏？如何避免内存泄漏？
SUN_Gyq的博客
10-31 537
内存泄漏是指在计算机程序中，由于疏忽或错误等原因，导致动态分配的内存没有被正确释放，从而在程序运行过程中占用的内存空间不断增加的现象。在可能抛出异常的代码中，要确保即使发生异常，也能正确地释放动态分配的内存。智能指针在构造时获取资源，在析构时自动释放资源，确保资源的正确释放，即使在发生异常的情况下也能有效避免内存泄漏。例如，在 C++ 中，如果使用new运算符分配了一块内存，但在后续的程序执行过程中没有使用delete运算符释放它，就会发生内存泄漏。在使用动态分配的内存后，确保在不再需要时及时释放它。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 642
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
【C++、数据结构】哈希表——散列表(一)（概念/总结）
金哥的博客
11-01 1282
哈希表：概念/散列函数/处理冲突常见方法/查找/删除操作/四种方法探测覆盖率
C语言 流程控制语句
2201_75297369的博客
11-05 275
时间：2024.11.5。
C++泛型编程
ymhdt的博客
11-02 616
泛型编程主要使用模板来实现。模板就是允许你编写与类型无关的代码，即对所有传入的数据类型编写通用的实现代码。比如，我想返回传入数据的占内存大小。对这个问题的解决，可以不依赖数据类型，我们都可以通过相同的操作返回结果。函数模板的定义如下代码：注意：每个函数模板都要在其之前使用template<>声明，不可复用。// 指定一个参数类型的函数模板// 指定多个参数类型的函数模板//指定可变参数函数模板模板定义的语法不用多说，但是模板参数有很多知识点需要掌握。类模板的定义形式和函数模板没有太大区别。
第九天: 深入探索C语言中的动态内存管理
qq_57484399的博客
10-31 359
简单来说，就是C语言没有直接提供给我们的数据类型，但是C语言给我们留了一个后门，允许我们用一些特殊的关键字来定义自己的数据类型。枚举类型允许我们定义一组相关的常量，这些常量就是枚举类型的取值。听起来有点绕？我给你举个例子。比如说，我们要表示一周的七天，我们可以用字符串来表示，但处理起来比较麻烦。用整数表示就简单多了，星期一是1，星期二是2，以此类推。这样的变量就可以定义为枚举类型，它的取值范围就是1到7。首先，我们用struct关键字来定义一个结构体。
介绍一下如何生成随机数（c基础）
最新发布
lb3636363636的博客
11-05 298
rand srand time
【Pikachu】Cross-Site Scripting跨站脚本攻击实战
若把此心以学道，即身成佛有何难
11-05 564
只管把目标定在高峰，人家要笑就让他去笑！
C++类继承：派生类的定义与继承方式
"派生类的定义格式-c++类继承 ppt文档第9章" 在C++编程语言中，类的继承是一种强大的特性，它允许我们创建新的类（派生类）基于现有的类（基类），从而实现代码重用和类之间的层次结构。这种关系可以被形象地比喻为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值