c++继承类

已于 2023-12-13 16:16:24 修改
阅读量311 收藏
点赞数 10
文章标签： c++
于 2023-12-13 10:47:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jj56911/article/details/134963681
版权

1.为什么需要继承

一个类继承另一个类,这样类中可以少定义一些成员,直接定义类，代码重复比较严重。

c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。
一个B类继承于A类，或称从类A派生类B。这样的话，类A成为基类(父类)，类B成为派生类(子类）。派生类中的成员，包含两大部分:
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。

2.派生类定义格式

class 派生类名:继承方式基类名
派生类新增的数据成员和成员函数

class DerivedClass : [访问修饰符] BaseClass {
    // 派生类的成员声明
public:
    // 派生类的公有成员
protected:
    // 派生类的保护成员
private:
    // 派生类的私有成员
};

  • DerivedClass 是派生类的名称。
  • [访问修饰符] 可以是 public、protected 或 private，用于指定派生类继承基类的成员的访问级别。这个部分可以省略，默认为 private 继承。
  • BaseClass 是基类的名称，表示派生类从该基类继承成员。

下面是一个例子，演示了派生类的定义：

class BaseClass {
public:
    int basePublic;
protected:
    int baseProtected;
private:
    int basePrivate;
};

class DerivedClass : public BaseClass {
public:
    int derivedPublic;
};

int main() {
    DerivedClass obj;
    obj.basePublic;     // 可以访问公有成员
    obj.baseProtected;  // 可以访问保护成员，因为是公有继承
    // obj.basePrivate; // 无法访问私有成员

    obj.derivedPublic;  // 可以访问派生类的公有成员
    return 0;
}

DerivedClass 公有继承了 BaseClass，因此在 DerivedClass 中可以访问 BaseClass 的公有和保护成员。 

3.三种继承方式:

  • public :公有继承
  • private :私有继承
  • protected :保护继承

从继承源上分:

  • 单继承:指每个派生类只直接继承了一个基类的特征
  • 多继承:指多个基类派生出一个派生类的继承关系,多继承的派生类直接继承了不止一个基类的特征。

派生类继承基类，派生类拥有基类中全部成员变量和成员方法（除了构造和析构之外的成员方法），但是在派生类中，继承的成员并不一定能直接访问，不同的继承方式会导致不同的访问权限。
派生类的访问权限规则如下:


 

4.继承中的对象模型：

在C++编译器的内部可以理解为结构休，子类是由父类成员叠加子类新成员而成:

#include <iostream>

class AcClass {
public:
    int mA;
    int mB;
};

class BcClass : public AcClass {
public:
    int mC;
};

class CClass : public BcClass {
public:
    int mD;
};

void test() {
    std::cout << "A size: " << sizeof(AcClass) << std::endl;
    std::cout << "B size: " << sizeof(BcClass) << std::endl;
    std::cout << "C size: " << sizeof(CClass) << std::endl;
}

int main() {
    test();
    return 0;
}

这段代码涉及了三个类：`AcClass`、`BcClass` 和 `CClass`，它们之间通过继承建立了一种层次关系。

  • AcClass` 类：具有两个公有成员变量 `mA` 和 `mB`。
  • `BcClass` 类：公有继承了 `AcClass` 类，因此继承了 `AcClass` 的成员变量 `mA` 和 `mB`。增加了自己的成员变量 `mC`。
  • `CClass` 类：公有继承了 `BcClass` 类，因此继承了 `AcClass` 的成员变量 `mA` 和 `mB`，以及 `BcClass` 的成员变量 `mC`。增加了自己的成员变量 `mD`。

这种继承关系形成了一个类的层次结构，其中子类（派生类）`BcClass` 和 `CClass` 继承了父类（基类）`AcClass` 的成员，同时可以添加自己的成员。这有助于代码的组织和重用，使得相关的功能和数据可以被逻辑地组织在一起。

5.对象构造和析构的调用原则


继承中的构造和析构

  • 子类对象在创建时会首先调用父类的构造函数
  • 父类构造函数执行完毕后，才会调用子类的构造函数
  • 当父类构造函数有参数时，需要在了类初始化列表(参数列表)中显示调用父类构造函数析构函数调用顺序和构造函数相反。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

class Base {
public:
    Base(int age, string name) {
        this->age = age;
        this->name = name;
        cout << "Base的构造函数" << endl;
    }

    ~Base() {
        cout << "Base的析构函数" << endl;
    }

    string name;
    int age;
};

class Son : public Base {
public:
    Son(int id, int age, string name) : Base(age, name) {
        this->id = id;
        cout << "Son的构造函数" << endl;
    }

    ~Son() {
        cout << "Son的析构函数" << endl;
    }

    int id;
};

void test01() {
    Son p(19, 18, "Lucy");
}

int main() {
    test01();
    return 0;
}


 

6.继承中同名成员的处理方法

  • 当子类成员和父类成员同名时，子类依然从父类继承同名成员
  • 如果子类有成员和父类同名，子类访问其成员默认访问子类的成员(本作用域就近原则)
  • 在子类通过作用域::进行同名成员区分(在派生类中使用基类的同名成员，显示使用类名限定符)

如果子类和父类有同名的成员变量,父类的成员变量会被隐藏,访问的是子类的成员变量如果子类和父类有同名的成员函数,父类的成员函数会被隐藏,访问的是子类的成员函数

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <string>
using namespace std;

class Base {
public:
    Base(int a) {
        this->a = a;
    }

    void foo() {
        cout << "父类的foo函数" << endl;
    }

    int a;
};

class Son : public Base {
public:
    Son(int a1, int a2) : Base(a1) {
        this->a = a2;
    }

    void foo() {
        cout << "子类的foo函数" << endl;
    }

    int a;
};

void test01() {
    Son p(10, 20);
    // 如果子类和父类有同名的成员变量,父类的成员变量会被隐藏,访问的是子类的成员变量
    // 如果子类和父类有同名的成员函数,父类的成员函数会被隐藏,访问的是子类的成员函数
    cout << p.a << endl;
    p.foo();
}

int main() {
    test01();
    return 0;
}

 7.非自动继承的函数

  • 不是所有的函数都能自动从基类继承到派生类中。构造函数和析构函数用来处理对象的创建和析构操作，构造和析构函数只知道对它们的特定层次的对象做什么，也就是说构造函数和析构函数不能被继承，必须为每一个特定的派生类分别创建。
  • 另外operator=也不能被继承，因为它完成类似构造函数的行为。也就是说尽管我们知道如何由=右边的对象如何初始化=左边的对象的所有成员，但是这个并不意味着对其派生类依然有效。

在继承的过程中，如果没有创建这些函数，编译器会自动生成它们。

8.继承中的静态成员特性


静态成员函数和非静态成员函数的共同点:

  1. 他们都可以被继承到派生类中。
  2. 如果重新定义一个静态成员函数，所有在基类中的其他重载函数会被隐藏。
  3. 如果我们改变基类中一个函数的特征，所有使用该函数名的基类版本都会被隐藏。
#include <iostream>
using namespace std;

class Base {
public:
    static int getNum() {
        return sNum;
    }

    static int getNum(int param) {
        return sNum + param;
    }

    static int sNum;
};

int Base::sNum = 10;

class Derived : public Base {
public:
    static int sNum;

    // 基类静态成员属性将被隐藏
    // 如果定义了相同的函数名，则基类中的所有同名函数都会被隐藏
    // static int getNum(int param1, int param2) {
    //     return sNum + param1 + param2;
    // }

    // 如果改变基类函数的某个特征，返回值或者参数个数，将会隐藏基类的同名函数
    static void getNum(int param1, int param2) {
        cout << sNum + param1 + param2 << endl;
    }
};

int Derived::sNum = 20;

void test01() {
    Derived p1;
    // 如果子类和父类有同名的静态成员变量, 父类中的静态成员变量会被隐藏
    cout << p1.sNum << endl;
}

int main() {
    test01();
    return 0;
}


9. 多继承概念


我们可以从一个类继承，我们也可以能同时从多个类继承，这就是多继承。但是由于多继承是非常受争议的，从多个类继承可能会导致函数、变量等同名导致较多的歧义。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <string>

using namespace std;

class A {
public:
    int a;
};

class B {
public:
    int a;
};

class C : public A, public B {
public:
    int c;
};

int main() {
    C obj;
    obj.A::a = 1;  // Accessing 'a' from class A
    obj.B::a = 2;  // Accessing 'a' from class B
    obj.c = 3;

    cout << "A::a: " << obj.A::a << endl;
    cout << "B::a: " << obj.B::a << endl;
    cout << "C::c: " << obj.c << endl;

    return 0;
}

10.菱形继承和虚继承


两个派生类继承同一个基类而又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石型继承。


 

基本结构：

GrandParent
   /     \
  Father   Mother
   \     /
GrandSon

11.二义性问题：

当GrandSon继承了Father和Mother，而Father和Mother都继承了GrandParent时，GrandSon中可能存在两份GrandParent的数据成员，引发二义性问题。

  • 资源浪费： 如果不采用虚继承，GrandSon内可能包含两份相同的GrandParent部分，导致资源浪费。

虚继承的应用：

  • 解决二义性问题： 通过使用virtual关键字进行虚继承，可以确保在最终的派生类中只包含一份共同基类的实例，解决了二义性问题。

class GrandParent { /* ... */ };
class Father : virtual public GrandParent { /* ... */ };
class Mother : virtual public GrandParent { /* ... */ };
class GrandSon : public Father, public Mother { /* ... */ };

  • 资源节省： 虚继承避免了派生类中包含多份相同基类的实例，节省了内存空间，避免了资源浪费。
  • 多重继承的合理应用： 在某些情况下，多重继承是必要的，虚继承使得多重继承更加灵活和可控。

虚继承是通过在基类前加上virtual关键字实现的，这告诉编译器在继承链中只保留一份虚基类的实例。通过合理使用虚继承，可以解决菱形继承带来的问题，确保继承体系的正确性和高效性。

#include <iostream>
#include <string>

using namespace std;

class animal
{
public:
    int age;
};

class sheep : virtual public animal
{
public:
    int id;
};

class camel : virtual public animal
{
public:
    int camel_num;
};

class shenshou : public sheep, public camel
{
public:
    int a;
};

void teste1()
{
    shenshou p;
    // p.age = 100;  // Sheep's age is ambiguous due to multiple inheritance
    p.sheep::age = 100;  // Set sheep's age
    p.age = 108;  // Set camel's age
}

int main()
{
    teste1();
    return 0;
}

12.虚继承的实现原理

虚继承的实现原理涉及到虚基类表（Virtual Base Class Table）和虚基类指针（Virtual Base Class Pointer）的概念。：

  • 虚基类表（Virtual Base Class Table）：

    • 对于每个包含虚基类的类，编译器会在对象的内存布局中插入一个指向虚基类表的指针，该表记录了该类所继承的虚基类的偏移量。
    • 虚基类表的内容包括虚基类的偏移量和其他信息，用于在运行时进行动态调整。

  • 虚基类指针（Virtual Base Class Pointer）：

    • 对于每个包含虚基类的对象，编译器会在对象的内存布局中插入一个虚基类指针，指向虚基类表。
    • 这个指针用于在运行时查找虚基类的实际位置。

  • 虚继承的对象内存布局：

    • 在虚继承中，对于共同的虚基类，只会在派生类的对象中存在一份实例，而不是每个派生类都包含一份。这避免了菱形继承带来的二义性和资源浪费问题。
    • 派生类中的虚基类的成员在内存中的位置通过虚基类表和虚基类指针进行调整，确保访问到正确的虚基类成员。

  • 构造函数和析构函数的调用：

    • 在虚继承中，派生类的构造函数和析构函数中会负责调用虚基类的构造函数和析构函数，并根据虚基类指针和虚基类表的信息进行调整。
class Base {
public:
    int commonData;
};

class Derived1 : public virtual Base {
public:
    int derivedData1;
};

class Derived2 : public virtual Base {
public:
    int derivedData2;
};

class FinalDerived : public Derived1, public Derived2 {
public:
    int finalData;
};

int main() {
    FinalDerived obj;
    obj.commonData = 10;  // Accessing common data through the final derived class
    return 0;
}

 在这个例子中，FinalDerived通过虚继承继承了Base类，确保在内存中只有一份Base类的实例。虚继承通过虚基类表和虚基类指针的机制，解决了菱形继承可能引起的问题。

小姜911
关注
  • 10
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
c++继承坐标类
05-21
运用继承的思想定义二位坐标和三维坐标类
c++抽象类继承
01-05
根据给定的信息，我们可以深入探讨C++中的抽象类与继承机制。下面将详细介绍如何通过抽象类和继承在C++中实现特定的功能。 ### 概述 在这个示例中，我们有三个具体的类：`Student`、`Lecture` 和 `Module`，它们都...
C++类继承示例
01-20
C++的子类与孙子类都实现了虚函数时，孙子类的实现会覆盖掉子类的实现。 　继承的主要的应用是把不同的类放到一个数组中，然后遍历调用同名函数。 　实例如下： #include #include #include using ...
C++类的继承方式
12-31
详细介绍c++类的继承方式，public、private、protect。
C语言如何快速求值
2301_81985098的博客
08-26 915
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？2、计算等式：m2 - n2 = (m + n)(m - n) = 168。1、则：x + 100 = n2, x + 100 + 168 = m2。6、由于 i * j = 168， j>=2，则。
c++命令模式
qq_71286244的博客
08-30 485
c++命令模式详细介绍
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 2921
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 6904
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
【C++ 面试 - 内存管理】每日 3 题（三）
Newin2020的博客
08-26 1201
栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 1276
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 590
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++拷贝构造函数
m0_75109289的博客
08-30 108
设计一个Per类，类中包含私有成员:姓名、年龄、指针成员身高、体重，再设计一个Stu类，类中包含私有成员:成绩、Per类对象p1，设计这两个类的构造函数、析构函数和拷贝构造函数。
C++(Qt)-GIS开发-QGraphicsView显示瓦片地图简单示例2
最新发布
mahuifa的博客
08-30 557
支持多线程加载显示本地离线瓦片地图(墨卡托投影)； 瓦片切片规则以左上角为原点（谷歌、高德、ArcGis等），不支持百度瓦片规则； 支持显示瓦片网格、编号信息。 支持鼠标滚轮缩放切换地图层级。 支持鼠标拖拽。 采用z/x/y层级瓦片存储格式。 在单文件中实现所有主要功能，简单便于理解。 以北纬85.05，西经-180为坐标原点【绝对像素坐标】。
《C++内存对齐探秘：优化性能的关键步骤》
xy520521的博客
08-26 887
内存对齐是 C++编程中一个重要的性能优化技术。通过合理地进行内存对齐，我们可以提高程序的性能，满足硬件的要求，便于数据结构的处理。在现代计算机体系结构中，内存访问通常是以特定的字节数为单位进行的，例如 4 字节、8 字节等。让我们一同深入探索如何在 C++中进行内存对齐，揭开这一神秘面纱，为我们的编程之旅增添强大的性能优化武器。例如，假设一个处理器每次只能读取 4 字节的数据，如果一个变量的起始地址不是 4 的倍数，那么在读取这个变量时，处理器可能需要进行多次读取和组合操作，这将大大降低访问效率。
坐牢第三十天（c++）
m0_62828714的博客
08-27 2612
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++中的异常处理与资源管理
wgr050505的博客
08-30 522
异常处理和资源管理是确保程序健壮性和可靠性的重要组成部分。通过使用智能指针和 RAII 技术，可以有效地避免资源泄漏等问题。希望本文能帮助你更好地理解和运用这些技术，提升你的编程技能。
C++_CH15_static在类和结构体中使用
2401_83411974的博客
08-30 119
在类或者结构体中使用static关键字，那么之后所有的instance，全部指向的同一块内存空间。在这个时候创建实例就没有意义。比如我创建了两个instance，e1和e2.由于他们指向同一块内存空间，所以修改e2的值也会带动e1的值修改。
C++/Qt 多媒体（续五）
qq_67853786的博客
08-30 659
基于Qt框架的C++编程，本章主要内容包括摄像头的使用相关内容的概述
C++继承分类详解：单多继承与面向对象基础
- 为了学习和理解C++继承，推荐参考书籍如《Thinking in C++》、《The C++ Programming Language》和《Introduction to Object-Oriented Programming Using C++》等，这些书籍提供了深入的理论和实践指导。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值