C++中的继承

最新推荐文章于 2025-05-10 09:00:00 发布
原创 最新推荐文章于 2025-05-10 09:00:00 发布 · 243 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++

继承的概念大家应该都很熟悉，最近看《effective C++》的时候发现有一些有意思的特性以前没有了解过，以此为记。

公有继承
首先，最常用的就是公有继承：

class ExampleA {
public:
    virtual ~ExampleA() { std::cout << "A~" << std::endl; }
    virtual void func() { std::cout << "A" << std::endl; }
    int a = 0;
protected:
    int b = 1;
private:
    int c = 2;
};
class ExampleB : public ExampleA {
public:
    ~ExampleB() { std::cout << "B~" << std::endl; }
    void func() { std::cout << "B" << std::endl; }
    void test() { a; b; c; }                        // 无法使用基类的私有成员c
};
class ExampleC : public ExampleB {
public:
    ~ExampleC() { std::cout << "C~" << std::endl; }
    void func() { std::cout << "C" << std::endl; }
    void test() { a; b; c; }                        // 无法使用基类的私有成员c
};

int main()
{
    ExampleB* ex1 = new ExampleC;
    ExampleA* ex2 = new ExampleC;
    ExampleA* ex3 = new ExampleB;
    ExampleA* ex4 = new ExampleA;
    ex1->func();       // C
    ex2->func();       // C
    ex3->func();       // B
    ex4->func();       // A

    delete ex1;        // C~ B~ A~
    delete ex1;        // C~ B~ A~
    delete ex1;        // B~ A~
    delete ex1;        // A~

    return 0;
}

上面的代码有几个关键点：
- 在公有继承中，继承基类之后能够在类中使用基类的public和protected成员。
- 使用了虚函数，虚函数也是实现动态多态的关键。当继承了基类并重写了基类的虚函数，那么对象指针将会有动态多态的特性，就如同上面的代码，无论指针本身指向的是什么类型，都会调用到new的时候的类型成员函数，当然前提是类本身重写了该虚函数，如果没有重写，会自动向下调用到最先实现的那个类的成员函数。
- 虚析构函数，可以看到使用了虚析构后，在析构时会调用真实类型所继承的所有父类的析构函数，这样可以保证资源完整释放。而如果不定义虚析构，只会调用指针本身类型的析构函数和其父类的析构函数。
- 多重继承，“孙子类”同样继承了“爷爷类”的内容。

另外，还有纯虚函数virtual void func() = 0;，纯虚函数不允许实现，只能在派生类中进行重写，另外含有纯虚函数的类不能实例化。

那么，虚函数是怎么实现这种调用规则的呢？
我们先了解一下函数指针的概念：指针指向对象称为对象指针，指针除了指向对象还可以指向函数，函数的本质就是一段二进制代码，我们可以通过指针指向这段代码的开头，计算机就会从这个开头一直往下执行，直到函数结束，并且通过指令返回回来。函数的指针与普通的指针本质上是一样的，存储着内存的地址，这个地址就是函数的首地址。

而当类有虚函数时，就会有对应的虚函数表。虚函数表指针：类中除了定义的函数成员，还有一个成员是虚函数表指针，这个指针指向一个虚函数表的起始位置，这个表会与类的定义同时出现，这个表存放着该类的虚函数指针，调用的时候可以找到该类虚函数表，通过虚函数表的偏移找到函数的入口地址，从而找到要使用的虚函数。
当实例化一个该类的子类对象的时候，如果该类的子类并没有定义虚函数，在实例化该类子类对象的时候也会产生一个虚函数表，这个虚函数表是子类的虚函数表，但是记录的子类的虚函数地址与父类的是一样的。所以，此时通过子类对象调用虚函数就会调用到父类的函数。如果我们在子类中定义了从父类继承来的虚函数，对于父类来说情况是不变的，对于子类来说它的虚函数表与之前的虚函数表是一样的，但是此时它的虚函数表中这个函数的指针就会覆盖掉原有的指向父类函数的指针的值，此时再调用该函数就会调用自己的函数了。

然后，再讨论一下公有继承的意义和使用场景。公有继承能够调用基类的非私有成员并且能重载基类的虚函数实现动态多态，《effective C++》中将其描述为”是一个…”、”是一种…”，挺形象的。例如：

class Student{
public:
    virtual void learn(){}
protect:
    int height;
}
class Tom:public Student{   // 汤姆是一个学生
public:
    void learn(){}
}

class Bird{
public:
    virtual void egg() = 0；
}
class Sparrow:public Bird{  // 麻雀是一种鸟
public:
    virtual void egg(){}
}

私有继承
私有继承和公有继承的区别在于，继承的时候声明为private：class A:private B。再看个例子：

class ExampleA {
public:
    virtual void func() {}
    int a = 0;
protected:
    int b = 1;
private:
    int c = 2;
};
class ExampleB : private ExampleA {
public:
    void func() {}
    void test() { a; b; c; }                        // 无法使用基类的私有成员c
};
class ExampleC : public ExampleB {
public:
    void test() { a; b; c; }                        // 无法使用a、b、c
};

int main()
{
    ExampleA* a = new ExampleB;                    // 编译失败，B无法转换成A
    return 0;
}

上面的代码有几个关键点：
- 使用私有继承后，基类所有访问权限都会变成private。
- 私有继承无法转换成基类类型。也就是说，虽然A声明了一个虚函数且B重写了虚函数，但是在私有继承中无法实现动态多态。

私有继承能够调用基类的非私有成员但是不能实现动态多态，由此可见，私有继承和公有继承不同，并不是”是一个…”、”是一种…”的意义。《effective C++》中将其描述为”用….来实现”，也就是说私有继承只是使用了基类中的部分或者全部的成员来实现自身的功能。其实，把类作为成员也能使用类的部分成员，那么为什么非要用私有继承呢？
总结了几种情况，一是需要调用类中的protected成员，包含类无法调用。这种情况也能用来隐藏底层类，只要把底层类的成员都写成protected类型，再进行私有继承，这样就只能使用派生类无法使用基类。

class ExampleA {
public:
    virtual void func() {}
    int a = 0;
protected:
    int b = 1;
private:
    int c = 2;
};
class ExampleB : {
public:
    void func() { exa.b; }                         // 无法使用类成员的protected成员      
private:
    ExampleA exa;
};
class ExampleC : private ExampleA  {
public:
    void func() { b; }                            // 可以使用私有继承父类的protected成员    
};

二是，有时候需要重写类的虚函数，包含类无法重写：

class ExampleA {
public:
    virtual std::string random() { return "1"; }      // 实现某种算法，返回数字结果字符串
    virtual int number()                              // 将字符串转化成int
    {
        return atoi(random().c_str());
    }
};

class ExampleB {
public:
    virtual void print_string() { std::cout << "1" << std::endl; }  // 打印字符串
};

class ExampleC : private ExampleA, public ExampleB{                 // 这里用到了多继承，在下面的内容中会说明
public:
    std::string random() { return "2"; }                            // 重写ExampleA的算法，返回不同结果
    virtual void print_string() { std::cout << number() << std::endl; }    // 打印出算法算出的数字
};

int main()
{
    ExampleC c;
    c.print_string();

    return 0;
}

多继承
C++支持继承多个基类，就是所谓的多继承（multiple inheritance）。多继承能够让类拥有多个类的特性，在一篇文章(https://blog.youkuaiyun.com/qcyfred/article/details/53440536)中看到了一个有意思的例子，大概是这样：

class Bed {
public:
    virtual void sleep() {}
};
class Sofa {
public:
    virtual void sit() {}
};
class Sofabed {
public:
    void sleep() {}
    void sit() {}
};

但是，多继承同样会引起一些问题，例如成员的二义性，就是在两个基类中有同名的成员时，这个时候必须要指明使用的是哪个基类的成员：

class Bed {
public:
    virtual void sleep() {}
    virtual std::string get_name() { return name; }
private:
    std::string name = "Bed";
};
class Sofa {
public:
    virtual void sit() {}
    virtual std::string get_name() { return name; }
private:
    std::string name = "Sofa";
};
class Sofabed : public Sofa, public Bed {
public:
    void sleep() {}
    void sit() {}
};

int main()
{
    Sofabed* sofabed = new Sofabed;
    sofabed->get_name();              // 二义性，ambiguous access of 'get_material'
    sofabed->Sofa::get_name();
    sofabed->Bed::get_name();
    return 0;
}

这样做了之后，Sofabed 就失去了虚函数的动态多态特性，只能调用到指定的基类成员。

class MySofabed : public Sofabed {
public:
    std::string get_name() { return "MySofabed"; }
};

int main()
{
    Sofabed* sofabed = new MySofabed;                             
    std::cout << sofabed->get_name() << std::endl;   // 二义性，sofabed虚表中的对应的虚指针不能确定，因此失去了动态多态特性

    return 0;
}

同时还有一个问题，那就是无法同时重写两个基类的同名函数，因为一个类中只能有一个同名、同参数、同返回值的函数。有一种方法可以解决这个问题，就是继承基类后重新定义一个不同名但是功能相同的函数，然后进行重写：

class Bed {
public:
    virtual void sleep() {}
    virtual std::string get_name() { return name; }
private:
    std::string name = "Bed";
};
class OtherBed: public Bed {
public:
    virtual std::string get_bedname() = 0;             // 定义另一个名字的同功能接口
    std::string get_name() { return get_bedname(); }
};

class Sofa {
public:
    virtual void sit() {}
    virtual std::string get_name() { return name; }
private:
    std::string name = "Sofa";
};
class OtherSofa : public Sofa {
public:
    virtual std::string get_sofaname() = 0;            // 定义另一个名字的同功能接口
    std::string get_name() { return get_sofaname(); }
};

class Sofabed : public OtherSofa, public OtherBed {
public:
    std::string get_sofaname() { return "OtherSofa"; }    // 重写同功能接口
    std::string get_bedname() { return "OtherBed"; }      // 重写同功能接口
};

int main()
{
    Sofabed* sofabed = new Sofabed;
    Sofa* sofa = sofabed;
    Bed* bed = sofabed;
    std::cout << sofa->get_name() << std::endl;   // OtherSofa
    std::cout << bed->get_name() << std::endl;    // OtherBed

    getchar();
    return 0;
}

这个方法的确解决了无法重写的问题，但是也引入了在程序设计中没有实际意义的类，它的存在只是为了解决问题。看到这里，我们已经可以看到多继承可能会遇到的一部分问题，实际上还会有另外的问题：菱形继承结构。

菱形继承结构 

class A {
public:
    int a;
};
class B : public A {
public:
    B() { a = 1; }
    int b;
};
class C : public A {
public:
    C() { a = 2; }
    int c;
};
class D : public B, public C {
public:
    int d;
};

这种结构会导致类D拥有两个类A的实例，如果希望只有一个A的实例怎么办？这时候需要使用继承，让类B和类C虚继承于类A。使用虚继承之后，D的对象就只会有一个A的实例，同时类D对象的内存分部也会有所改变。原来是A+B+A+C+D的连续分布，使用虚继承之后就可能会变成B+A指针+C+A指针+D（视编译器不同，不过大体思路就是这样），这样自然会牺牲一部分的空间。

class A {
public:
    int a;
};
class B : virtual public A {    // 虚继承类A
public:
    B() { a = 1; }
    int b;
};
class C : virtual public A {    // 虚继承类A
public:
    C() { a = 2; }
    int c;
};
class D : public B, public C {
public:
    int d;
};

看起来这样挺完美的，但是实际类设计中我们很难预测到是否会有人同时继承B和C，也就很难去决定是否使用虚继承。这样看起来，多继承有很多很多的问题，那么是不是干脆不用？但是在上面的私有继承中的一个例子，用到了多继承来解决一些问题，所以还是有一些场景还是有用的，不过需要我们小心谨慎的使用。

保护继承
保护继承的作用是让外部无法访问基类的公有和保护成员，但是从保护继承派生的类能够访问基类的公有和保护成员。就像下面的代码，ExampleC能够访问ExampleA中的成员a和b，但是类外就不行。

class ExampleA {
public:
    virtual void func() {}
    int a = 0;
protected:
    int b = 1;
private:
    int c = 2;
};
class ExampleB : protected ExampleA {
public:
    void func() {}
    void test() { a; b; }                        // 能够使用基类的公有和保护成员
};
class ExampleC : public ExampleB {
public:
    void test() { a; b; }                       // 能够使用基类的公有和保护成员
};

int main()
{
    ExampleA* a = new ExampleB;                    // 编译失败，B无法转换成A
    ExampleB b;
    b.a; b.b; b.c;                                 // 无法使用a、b、c
    return 0;
}
  • 和公有继承的差别：禁止了类外访问基类的公有成员，禁止了对象的转化为基类。

  • 和私有继承的差别：保护继承的派生类能够访问基类的公有和保护成员。

    《effective C++》中只说了保护继承还没有发现用处，根据以上两个差别进行猜测，可能可以用于不希望外部访问公有成员但是派生类能访问的情况。

WizardtoH
关注
【C++】继承中的权限
xiaoxiaoguailou的博客
03-03 2620
文章目录一、默认权限二、默认继承权限（1）class 继承 struct（2）struct 继承 class三、继承权限探究（1）公有继承（2）私有继承（3）保护继承四、继承和派生类中定义基类成员权限的区别 一、默认权限 struct 默认公有权限 struct A { public: }; class 默认私有权限 class B { private: }; 二、默认继承权限 （1）class 继承 struct struct A{}; class B : A{}; //默认私有继承 （2）str
C++中的继承方式
GOLOJO的博客
06-08 613
在 C++ 中，继承是一种让一个类（派生类）从另一个类（基类）获得属性和方法的机制。
C++学习笔记--继承的赋值兼容和函数重写
一念之间、
12-04 529
首先说说父类子类间的赋值兼容问题，什么意思呢，就是子类对象可以当做父类对象使用的兼容性问题。 子类对象可以直接赋值给父类对象。 子类对象可以直接初始化父类对象。 父类指针可以直接指向子类对象。 父类引用可以直接引用子类对象。 我们通过小例子说明这几个规则，首先定义一个父类一个子类，他们之间有继承关系。 class Parent { public: int mi;
多重继承中，孙子类可以继承爷爷类的属性和方法吗？
Khan的博客
03-22 3397
可以。 看如下代码： 爷爷类：Animal package com.Animal; public class Animal { private String color; private String feetNum; public String getColor() { return color; } public void setColor(String color) { this.color = color; }
C++中的继承与多态
m0_73987904的博客
05-10 1979
本文深入探讨了C++中的类继承机制，解释了继承的基本概念、语法格式及其在工程中的应用。文章详细介绍了类继承的三种方式（public、protected、private）及其对访问权限的影响，强调了public继承的广泛适用性。此外，文章还讨论了基类与派生类之间的赋值兼容性、内存切片现象以及继承中的作用域问题。通过示例代码和图示，文章展示了继承中可能出现的特殊现象，如隐藏和覆盖，并提供了实际代码运行结果以加深理解。最后，文章总结了继承在C++编程中的重要性，强调了其在扩展类功能和提高代码复用性方面的优势。
C++ 继承
m0_73900674的博客
03-23 2025
C++继承、虚拟继承、组合
C++-继承
zc331的博客
10-27 2515
可以把基类当作派生类中的一个自定义类型的属性，这个属性和string类似要调用自己的默认成员函数。
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 8万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
【C++】继承
Edward_Asia的博客
04-08 9474
目录 1. 概念 2. 定义 2.1. 使用格式 2.2. 继承方式与限定修饰符 3. 基类和派生类对象赋值转换 (public继承) 4. 继承中的作用域 5. 子类类的默认成员函数 6. 继承与友元 7. 静态成员 8. 菱形继承和虚继承 8.1 菱形继承 8.2 虚继承(virtual) 8.3 虚继承解决数据冗余和二义性的原理 9. 继承总结、继承与组合 9.1总结 9.2 继承与组合 1. 概念 继承(inheritance)机制是面向对象程序设..
C++ 中继承与动态内存分配的详解
12-26
C++ 中继承与动态内存分配的详解 继承是怎样与动态内存分配进行互动的呢？例如,如果基类使用动态内存分配，并重新定义赋值和复制构造函数，这将怎样影响派生类的实现呢？这个问题的答案取决于派生类的属性。如果派生...
C++中继承与组合的区别详细解析
01-01
C++的“继承”特性可以提高程序的可复用性。正因为“继承”太有用、太容易用，才要防止乱用“继承”。我们要给“继承”立一些使用规则： 一、如果类A 和类B 毫不相关，不可以为了使B 的功能更多些而让B 继承A 的功能...
C++面向对象程序设计习题继承与派生.pdf
09-30
在多继承中，可能会出现二义性问题，例如调用不同基类的同名成员时产生二义性，或者访问共同基类的成员时产生二义性。为了解决二义性问题，可以使用成员名限定方式或虚基类。 虚基类是一种继承方式，它可以使得基类...
C++——继承
2301_80401288的博客
10-05 4419
《C++——继承》 求点赞收藏评论关注！！！ 感谢各位大佬的支持！！！
C++继承详解
lim6ere的博客
03-29 1486
在本篇文章中我们将会学到有关继承方面的知识，其中C++中三大特性分别为：封装，继承多态。由此可见继承在学习中的重要性，接下来我们来一起看一下有关继承方面的知识吧！！！！😘 😚😘 😚😘 😚以上就是今天要讲的内容，本文仅仅详细介绍了C++继承的相关知识。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
Nodejs后端服务构建与数据库缓存集成实践项目_通过Nodejs环境搭建实现MySQL数据库连接与Redis缓存机制整合的完整示例_旨在为开发者提供一个清晰易懂的教程式代码库.zip
最新发布
01-08
Nodejs后端服务构建与数据库缓存集成实践项目_通过Nodejs环境搭建实现MySQL数据库连接与Redis缓存机制整合的完整示例_旨在为开发者提供一个清晰易懂的教程式代码库.zip
关闭126邮箱和163邮箱的网易广告
01-08
代码转载自：https://pan.quark.cn/s/149513ca1c18 此实例主要用于教学目的供参考，其中包含了SetTimer()函数的运用，FindWindow()函数的调用，GetWindowThreadProcessId()函数的执行，OpenProcess()函数的应用以及TerminateProcess()函数的简单操作
C++中继承和派生向量类模板与字符串类实现
在公共继承中，基类的公有成员（public）和保护成员（protected）在派生类中保持原有的访问权限，而私有成员（private）则不可直接访问。这种继承方式表明派生类是基类的具体类型。 #### 向量类模板Vector的实现 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值