C++继承、多继承及菱形继承

继承

继承是C++面向对象的三大特性之一（封装、继承和多态）。

一、构造和析构顺序

先执行父类构造函数，再执行子类构造函数；
先执行子类析构函数，在执行父类析构函数。

二、同名隐藏

2.1 概念

子类中的同名属性和成员函数，会隐藏掉父类中的同名属性和成员函数，如果父类中的同名成员函数有重载，也会被隐藏。注意，同名隐藏是针对子类来说的，子类想要访问父类中的同名属性或者成员函数需要加父类的作用域。

2.2 代码示例

#include 
using namespace std;

class Base{
public:
    Base() { std::cout << "Base Construct call."  << std::endl; }
    ~Base() { std::cout << "Base Distroy call."  << std::endl; }
    
    // 普通成员函数及其重载
    void func(){ std::cout << "Base func() call."  << std::endl; }
    void func(int a) { std::cout << "Base func(int a) call."  << std::endl; }
	// 静态成员函数
    static void func_s() { std::cout << "Base ---> static func_s() call."  << std::endl; }
public:
    int m_A = 100; // 普通成员属性
    static int m_B; // 静态成员属性，需要在类外初始化
};

int Base::m_B = 10000; // 类外初始化

class Son : public Base{
public:
    Son() { std::cout << "Son Construct call."  << std::endl; }
    ~Son() { std::cout << "Son Distroy call."  << std::endl; }

    void func() { std::cout << "Son func() call."  << std::endl; }

    static void func_s() { std::cout << "Son ---> static func_s() call."  << std::endl; }
public:
    int m_A = 200;
    static int m_B;
};
int Son::m_B = 20000;


int main(int argc, char* argv[])
{
    std::cout << "================== 构造函数调用 ==================="  << std::endl;
    Son s1;

    std::cout << "================== 同名隐藏 ==================="  << std::endl;
    std::cout << "s1.m_A: " << s1.m_A << std::endl; // 隐藏了父类同名的m_A属性
    std::cout << "s1::Base::m_A: " << s1.Base::m_A << std::endl;

    s1.func();  // 隐藏了父类Base的所有同名及重载的func函数
    s1.Base::func(); // 可以加父类的作用域进行访问
    // s1.func(2);
    s1.Base::func(2); // 可以加父类的作用域进行访问


    // 类的静态属性和静态成员函数有两种访问方式
    std::cout << "============== 通过实例化对象访问静态属性及成员函数 ================"  << std::endl;
    // 1. 使用
    std::cout << "s1.m_B: " << s1.m_B << std::endl;
    std::cout << "s1::Base::m_B: " << s1.Base::m_B << std::endl;

	s1.func_s();
    s1.Base::func_s();

    std::cout << "================== 通过类访问静态属性及成员函数 ==================="  << std::endl;
    std::cout << "Son::m_B " << Son::m_B << std::endl;
    // std::cout << "Base::m_B " << Base::m_B << std::endl; // Base类本身就能访问本类的静态属性
    std::cout << "Son::Base::m_B " << Son::Base::m_B << std::endl; // 通过子类加父类作用域访问父类的静态属性
    
    Son::func_s();
    Son::Base::func_s();

    std::cout << "================== 析构函数调用 ==================="  << std::endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

运行结果：

三、多继承

C++允许一个类继承多个类。在多个父类有同名的属性时，容易出现二义性。

语法：

class 子类名: 继承方式 父类1, 继承方式 父类2{};
1

代码示例：

#include 
using namespace std;

class Base1{
public:
    int m_A = 100;
};

class Base2{
public:
    int m_A = 1000;
    int m_B = 200;
};

class Son: public Base1, public Base2{
public:
    int m_C = 300;    
};

int main(int argc, char* argv[])
{
    Son s;
    // std::cout << "s.m_A " << s.m_A << std::endl; // 错误
    // 当多个父类中出现同名的属性时，需要加作用域区分，否则编译器不能确定从哪个父类继承该属性
    std::cout << "s.Base1::m_A " << s.Base1::m_A << std::endl;
    std::cout << "s.Base2::m_A " << s.Base2::m_A << std::endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

四、菱形继承存在的问题及解决方法

4.1 什么是菱形继承？

两个子类继承同一个基类，然后，某个类又同时继承这两个子类，这种继承被称为菱形继承。菱形继承举例：

菱形继承的问题：

马继承了动物的年龄属性，驴也继承了年龄属性，当骡子用使用年龄属性时，会产生二义性。造成这种问题的原因在于，骡子继承了两份年龄属性，实际上只需要一份就可以了。

代码示例：

// 动物类
class Animal{
public:
    int m_age;
};

// 马
class Horse : public Animal{};
// 驴
class Donkey : public Animal{};

// 骡子
class Mule:public Horse, public Donkey{};

int main(int argc, char* argv[])
{
    Mule m;
    m.Horse::m_age = 10;
    m.Donkey::m_age = 20;

	// 菱形继承时，Mule的两个父类拥有相同的属性，需要加作用域区分
	// 缺点：内存中有两份，资源浪费
    std::cout << "m.Horse::m_age = " << m.Horse::m_age << std::endl;
    std::cout << "m.Donkey::m_age= " << m.Donkey::m_age << std::endl;

    std::cout << "Mule size = " << sizeof(m) << std::endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行结果：

分析：因为骡子本身没有属性，分别从马和驴继承了一个int型的年龄属性，所以 size = 8。

4.2 虚继承可以解决菱形继承问题

#include 
using namespace std;

// 动物类
class Animal{
public:
    int m_age;
};

// 马
// 继承之前加上virtual关键字，变为虚继承，Animal称为虚基类
class Horse : virtual public Animal{};

// 驴
class Donkey : virtual public Animal{};

// 骡子
class Mule:public Horse, public Donkey{};

int main(int argc, char* argv[])
{
    Mule m;
    m.Horse::m_age = 10;  // 先修改马的年龄为10
    m.Donkey::m_age = 20; // 再修改驴的年龄为20

    std::cout << "m.Horse::m_age = " << m.Horse::m_age << std::endl; // 输出 20
    std::cout << "m.Donkey::m_age = " << m.Donkey::m_age << std::endl;
    std::cout << "m.Donkey::m_age = " << m.m_age << std::endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

运行结果分析：

在使用虚继承后，m.Horse::m_age = 20，说明此时的他们的年龄属性，共用的是同一块内存空间，也就解决了菱形继承空间浪费的问题。

文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习: