【C++进阶1--继承】面向对象三大特性之一（附菱形继承讲解

原创已于 2024-04-15 15:30:52 修改 · 856 阅读

6 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#c++ #开发语言 #java

于 2023-05-10 20:10:59 首次发布

C++ 专栏收录该内容

18 篇文章

订阅专栏

文章详细介绍了C++中的继承概念，包括单继承、多继承和菱形继承，讨论了继承的访问权限、切片问题、隐藏与重载的区别，以及析构函数、友元和static成员在继承中的行为。还提到了虚拟继承用于解决菱形继承中的数据冗余和访问二义性问题，并对比了继承与组合两种复用方式的耦合度差异。

继承是面向对象中很重要的特性，今天就来讲讲C++中的继承。

文中不足错漏之处望请斧正！

什么是继承？

是一种类的复用，可以让B类继承A类，从而使B类获得A类的所有成员。

A类叫做父类或基类，B类叫做子类或派生类。

而继承分为单继承和多继承。

单继承

是什么

子类只继承于一个父类。

怎么用

class 父类
{};

class 子类 : 继承方式 父类
{};

子类可通过派生类列表明确从哪个类而来。

class Base
{
    int _b;
};

class Derive : public Base
{
    int _d;
};

int main()
{
    Base b;
    Derive d;
    return 0;
}

Derive类后跟冒号，冒号后是类派生列表，public是继承方式，Base是要继承的类。

Derive就是子类，Base就是父类。
在这里插入图片描述

通过继承我们能看见，Derive对象确实成功继承了Base类的成员。

但父类的不同成员，按照继承方式在子类中应该会得到不同的访问限定符吧？那限定符继承后到底是什么样的，有什么规律吗？

有的。

第一点：继承中的访问权限

在这里插入图片描述

子类中父类成员的访问权限限定符规则，可看作一个min函数的调用结果：

min(父类成员在父类中的访问权限，继承方式)。

*private < protected < public

*父类的private成员同样会继承到子类，只是不可见

从这里其实我们也可以看出，C++想覆盖尽可能多的继承场景，但是实际上，除了public继承外，其他都不怎么用：

protected继承：子类外不能访问，扩展性变差
private继承：子类都不能访问了，丢了继承的初衷

这里我们就可以谈谈protected有什么用了。

protected

其实就是能被子类访问但不能被其他人访问的成员。

第二点：父类成员的访问权限

父类的

public成员：父子类内外都能访问
protected成员：父子类内可以访问
private成员：只有父类内可以访问

子类的默认成员函数

一句话简单说：父类和子类分开处理，父类部分调用父类的默认成员函数；子类部分调用子类的默认成员函数。

构造和析构的顺序：

父类构造 → 子类构造 → 子类析构 → 父类析构

继承中的Destructor

父子类的析构，函数名都会被处理成destructor，这是为了兼容多态而添加的一个特性。因为多态需要父子类析构同名，才有机会构成重写（不重写析构可能内存泄漏）。

此外，因为父子类析构构成隐藏，所以调用父类析构是要指定类域的，不过一般不用我们自己手动调，因为子类析构调用完后会自动调用父类析构。

继承中的友元

友元关系不会被继承，父类的友元不是子类的友元（你爹的朋友不一定是你的朋友）。

继承中的static成员

和以前的概念吻合：static成员在整个继承体系中只有一个。

类指针的意义

这里强调一下类指针的意义，在继承中容易搞混。

类指针访问属性：->的意义是解引用找属性
类指针访问方法：->的意义是传递this调用代码段的方法
类指针访问static成员：->的意义是访问数据段的静态成员

struct A {
    int _a;

    void func() { cout << "func called..." << endl;}
    static int _s;
};

int A::_s = 999;

int main() {
    A *ptr = nullptr;

    cout << ptr->_a << endl; //err
    ptr->func();
    cout << ptr->_s << endl;

    return 0;
}

主要看有没有解引用找属性。

多继承

是什么

一个子类继承于多个父类多继承。

为什么

有场景：我既需要A类的属性，也需要B的属性

#菱形继承

是什么

在这里插入图片描述

class A {
public:
    int _a;
};

class B: public A {
public:
    int _b;
};

class C: public A { 
public:
    int _c;
};

class D: public B, public C {
public:
    int _d;
};

设计类的时候尽量不要设计这种类，非常复杂，难以玩转。

数据冗余和访问二义性

int main() {
    D d;
    d._a = 10;
    return 0;
}

err:
non-static member '_a' found in multiple base-class subobjects of type 'A':
    class D -> class B -> class A
    class D -> class C -> class A
    d._a = 10;
      ^

菱形继承中最开始的基类属性会被最后的派生类继承两份
访问_a的时候，不确定是B::_a还是C::_a

那么如何解决这两个问题呢？

虚拟继承

虚拟继承的核心思想是共享公共基类的成员。

通过 virtual 继承方式派生出的派生类，实际上并不拥有虚基类成员，而是通过偏移量访问虚基类成员。

*被派生类使用虚拟继承来继承的基类称为虚基类。

怎么用

class A {
public:
    int _a;
};

class B: virtual public A { //通过偏移量访问_a
public:
    int _b;
};

class C: virtual public A { //通过偏移量访问_a
public:
    int _c;
};

class D: public B, public C {
public:
    int _d;
};

int main() {
    D d;
    d._a = 10;
    return 0;
}

在这里插入图片描述

使用虚拟继承，避免了数据冗余的问题。上面 d 对象修改了 _a，我们发现在 d 对象内的 B、C类对象内的 _a 也同时改变，验证了虚拟集成的子类通过偏移量访问基类成员。

虚拟继承原理

通过偏移量访问，它是怎么个访问法？

派生类虚拟继承自基类，派生类对象实际上会得到一个指针，这个指针指向一个关于A类的偏移量表。

偏移量表中有偏移量，还有虚基类部分的地址。虚基类部分的地址 + 偏移量 = 能够直接访问虚基类的成员。这个偏移量表就叫做虚基表。

int main() {
    D d;

    d._b = 1;
    d._c = 2;
    d._d = 3;
    d._a = 4;

    return 0;
}

在这里插入图片描述

*32位机

查询 d 对象的地址，在前4个字节，我们首先看到的就是一个指针（就是虚基表指针）。查看指针指向的内容，发现了前四个字节是零值（应该是空指针），而后就是一个0x14，即20，这就是d对象要访问A类成员_a需要的偏移量。你数数，从d的第一个字节开始，往后20个字节，就是_a。

继承和组合

继承是一种 “is-a” 的感觉，比如 Student 是 Person，Student 属于 Person。这种复用称为白箱复用，会暴露底层细节。
组合是一种“has-a”的感觉，比如B类中有A类的对象。这种复用称为黑箱复用，不暴露底层细节。

其中，继承耦合度 > 组合耦合度。

小练

选出正确的描述

class B {public: int b;};

class C1: public B {public: int c1;};

class C2: public B {public: int c2;};

class D : public C1, public C2 {public: int d;};