3.4.6继承 - AC

4.6 继承#

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

1544861202252

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

4.6.1 继承的基本语法#

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同

接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

普通实现 ：

1
#include<iostream>
2

3
//Java页面
4
class Java
5
{
6
public:
7
    void header()
8
    {
9
        std::cout << "首页、公开课、登录、注册...（公共头部）" << std::endl;
10
    }
11
    void footer()
12
    {
13
        std::cout << "帮助中心、交流合作、站内地图...(公共底部)" << std::endl;
14
    }
15
    void left()
16
    {
17
        std::cout << "Java,Python,C++...(公共分类列表)" << std::endl;
18
    }
19
    void content()
20
    {
21
        std::cout << "JAVA学科视频" << std::endl;
22
    }
23
};
24
//Python页面
25
class Python
26
{
27
public:
28
    void header()
29
    {
30
        std::cout << "首页、公开课、登录、注册...（公共头部）" << std::endl;
31
    }
32
    void footer()
33
    {
34
        std::cout << "帮助中心、交流合作、站内地图...(公共底部)" << std::endl;
35
    }
36
    void left()
37
    {
38
        std::cout << "Java,Python,C++...(公共分类列表)" << std::endl;
39
    }
40
    void content()
41
    {
42
        std::cout << "Python学科视频" << std::endl;
43
    }
44
};
45
//C++页面
46
class CPP
47
{
48
public:
49
    void header()
50
    {
51
        std::cout << "首页、公开课、登录、注册...（公共头部）" << std::endl;
52
    }
53
    void footer()
54
    {
55
        std::cout << "帮助中心、交流合作、站内地图...(公共底部)" << std::endl;
56
    }
57
    void left()
58
    {
59
        std::cout << "Java,Python,C++...(公共分类列表)" << std::endl;
60
    }
61
    void content()
62
    {
63
        std::cout << "C++学科视频" << std::endl;
64
    }
65
};
66

67
void test1()
68
{
69
    //Java页面
70
    std::cout << "Java下载视频页面如下： " << std::endl;
71
    Java ja;
72
    ja.header();
73
    ja.footer();
74
    ja.left();
75
    ja.content();
76
    std::cout << "--------------------" << std::endl;
77

78
    //Python页面
79
    std::cout << "Python下载视频页面如下： " << std::endl;
80
    Python py;
81
    py.header();
82
    py.footer();
83
    py.left();
84
    py.content();
85
    std::cout << "--------------------" << std::endl;
86

87
    //C++页面
88
    std::cout << "C++下载视频页面如下： " << std::endl;
89
    CPP cp;
90
    cp.header();
91
    cp.footer();
92
    cp.left();
93
    cp.content();
94

95
}
96

97
int main() {
98

99
    test1();
100

101
    return 0;
102
}

继承实现 ：

1
#include<iostream>
2

3
//公共页面
4
class BasePage
5
{
6
public:
7
    void header()
8
    {
9
        std::cout << "首页、公开课、登录、注册...（公共头部）" << std::endl;
10
    }
11

12
    void footer()
13
    {
14
        std::cout << "帮助中心、交流合作、站内地图...(公共底部)" << std::endl;
15
    }
16
    void left()
17
    {
18
        std::cout << "Java,Python,C++...(公共分类列表)" << std::endl;
19
    }
20

21
};
22

23
//Java页面
24
class Java : public BasePage
25
{
26
public:
27
    void content()
28
    {
29
        std::cout << "JAVA学科视频" << std::endl;
30
    }
31
};
32
//Python页面
33
class Python : public BasePage
34
{
35
public:
36
    void content()
37
    {
38
        std::cout << "Python学科视频" << std::endl;
39
    }
40
};
41
//C++页面
42
class CPP : public BasePage
43
{
44
public:
45
    void content()
46
    {
47
        std::cout << "C++学科视频" << std::endl;
48
    }
49
};
50

51
void test1()
52
{
53
    //Java页面
54
    std::cout << "Java下载视频页面如下： " << std::endl;
55
    Java ja;
56
    ja.header();
57
    ja.footer();
58
    ja.left();
59
    ja.content();
60
    std::cout << "--------------------" << std::endl;
61

62
    //Python页面
63
    std::cout << "Python下载视频页面如下： " << std::endl;
64
    Python py;
65
    py.header();
66
    py.footer();
67
    py.left();
68
    py.content();
69
    std::cout << "--------------------" << std::endl;
70

71
    //C++页面
72
    std::cout << "C++下载视频页面如下： " << std::endl;
73
    CPP cp;
74
    cp.header();
75
    cp.footer();
76
    cp.left();
77
    cp.content();
78

79
}
80

81
int main() {
82

83
    test1();
84

85
    return 0;
86
}

总结：

继承的好处：可以减少重复的代码

class A : public B;

A 类称为子类或派生类

B 类称为父类或基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

4.6.2 继承方式#

继承的语法：class 子类 : 继承方式父类

继承方式一共有三种 ：

公共继承
保护继承
私有继承

示例：

1
#include<iostream>
2

3
class Base31
4
{
5
public:
6
    int m_A;
7
protected:
8
    int m_B;
9
private:
10
    int m_C;
11
};
12

13
//公共继承
14
class Son31 :public Base31
15
{
16
public:
17
    void func()
18
    {
19
        m_A; //可访问 public权限
20
        m_B; //可访问 protected权限
21
        //m_C; //不可访问
22
    }
23
};
24

25
void myClass()
26
{
27
    Son31 s1;
28
    s1.m_A; //其他类只能访问到公共权限
29
}
30

31
//保护继承
32
class Base32
33
{
34
public:
35
    int m_A;
36
protected:
37
    int m_B;
38
private:
39
    int m_C;
40
};
41

42
class Son2 :protected Base32
43
{
44
public:
45
    void func()
46
    {
47
        m_A; //可访问 protected权限
48
        m_B; //可访问 protected权限
49
        //m_C; //不可访问
50
    }
51
};
52
void myClass2()
53
{
54
    Son2 s;
55
    //s.m_A; //不可访问
56
}
57

58
//私有继承
59
class Base33
60
{
61
public:
62
    int m_A;
63
protected:
64
    int m_B;
65
private:
66
    int m_C;
67
};
68

69
class Son33 :private Base33
70
{
71
public:
72
    void func()
73
    {
74
        m_A; //可访问 private权限
75
        m_B; //可访问 private权限
76
        //m_C; //不可访问
77
    }
78
};
79

80
class GrandSon33 :public Son33
81
{
82
public:
83
    void func()
84
    {
85
        //Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
86
        //m_A;
87
        //m_B;
88
        //m_C;
89
    }
90
};

4.6.3 继承中的对象模型#

问题：从父类继承过来的成员，哪些属于子类对象中？

示例：

1
#include<iostream>
2

3
class Base3
4
{
5
public:
6
    int m_A;
7
protected:
8
    int m_B;
9
private:
10
    int m_C; //私有成员只是被隐藏了，但是还是会继承下去
11
};
12

13
//公共继承
14
class Son3 :public Base3
15
{
16
public:
17
    int m_D;
18
};
19

20
void test31()
21
{
22
    std::cout << "sizeof Son = " << sizeof(Son3) << std::endl;
23
}
24

25
int main() {
26

27
    test31();
28

29
    return 0;
30
}

利用工具查看：

1545881904150

打开工具窗口后，定位到当前CPP文件的盘符

然后输入： cl /d1 reportSingleClassLayout查看的类名所属文件名

例如 cl /d1 reportSingleClassLayoutSon3 03.继承中的对象模型.cpp

效果如下图：

1545882158050

结论：父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

4.6.4 继承中构造和析构顺序#

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

示例：

1
#include<iostream>
2

3
class Base4
4
{
5
public:
6
    Base4()
7
    {
8
        std::cout << "Base4构造函数!" << std::endl;
9
    }
10
    ~Base4()
11
    {
12
        std::cout << "Base4析构函数!" << std::endl;
13
    }
14
};
15

16
class Son4 : public Base4
17
{
18
public:
19
    Son4()
20
    {
21
        std::cout << "Son4构造函数!" << std::endl;
22
    }
23
    ~Son4()
24
    {
25
        std::cout << "Son4析构函数!" << std::endl;
26
    }
27

28
};
29

30
void test41()
31
{
32
    //继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
33
    Son4 s;
34
}
35

36
int main() {
37

38
    test41();
39

40
    return 0;
41
}

总结：继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

4.6.5 继承同名成员处理方式#

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

示例：

1
#include<iostream>
2

3
class Base5 {
4
public:
5
    Base5()
6
    {
7
        m_A = 100;
8
    }
9

10
    void func()
11
    {
12
        std::cout << "Base5 - func()调用" << std::endl;
13
    }
14

15
    void func(int a)
16
    {
17
        std::cout << "Base5 - func(int a)调用" << std::endl;
18
    }
19

20
public:
21
    int m_A;
22
};
23

24
class Son5 : public Base5 {
25
public:
26
    Son5()
27
    {
28
        m_A = 200;
29
    }
30

31
    //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
32
    //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
33
    void func()
34
    {
35
        std::cout << "Son5 - func()调用" << std::endl;
36
    }
37
public:
38
    int m_A;
39
};
40

41
void test51()
42
{
43
    Son5 s;
44

45
    std::cout << "Son5下的m_A = " << s.m_A << std::endl;
46
    std::cout << "Base5下的m_A = " << s.Base5::m_A << std::endl;
47

48
    s.func();
49
    s.Base5::func();
50
    s.Base5::func(10);
51

52
}
53
int main() {
54

55
    test51();
56

57
    return 0;
58
}

总结：

子类对象可以直接访问到子类中同名成员
子类对象加作用域可以访问到父类同名成员
当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

4.6.6 继承同名静态成员处理方式#

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

示例：

1
#include<iostream>
2

3
class Base6 {
4
public:
5
    static void func()
6
    {
7
        std::cout << "Base6 - static void func()" << std::endl;
8
    }
9
    static void func(int a)
10
    {
11
        std::cout << "Base6 - static void func(int a)" << std::endl;
12
    }
13

14
    static int m_A;
15
};
16

17
int Base6::m_A = 100;
18

19
class Son6 : public Base6 {
20
public:
21
    static void func()
22
    {
23
        std::cout << "Son6 - static void func()" << std::endl;
24
    }
25
    static int m_A;
26
};
27

28
int Son6::m_A = 200;
29

30
//同名成员属性
31
void test61()
32
{
33
    //通过对象访问
34
    std::cout << "通过对象访问： " << std::endl;
35
    Son6 s;
36
    std::cout << "Son6  下 m_A = " << s.m_A << std::endl;
37
    std::cout << "Base6 下 m_A = " << s.Base6::m_A << std::endl;
38

39
    //通过类名访问
40
    std::cout << "通过类名访问： " << std::endl;
41
    std::cout << "Son6  下 m_A = " << Son6::m_A << std::endl;
42
    std::cout << "Base6 下 m_A = " << Son6::Base6::m_A << std::endl;
43
}
44

45
//同名成员函数
46
void test62()
47
{
48
    //通过对象访问
49
    std::cout << "通过对象访问： " << std::endl;
50
    Son6 s;
51
    s.func();
52
    s.Base6::func();
53

54
    std::cout << "通过类名访问： " << std::endl;
55
    Son6::func();
56
    Son6::Base6::func();
57
    //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
58
    Son6::Base6::func(100);
59
}
60
int main() {
61

62
    //test61();
63
    test62();
64

65
    return 0;
66
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通过类名）

4.6.7 多继承语法#

C++允许一个类继承多个类

语法： class 子类：继承方式父类1 ，继承方式父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

示例：

1
#include<iostream>
2

3
class Base71 {
4
public:
5
    Base71()
6
    {
7
        m_A = 100;
8
    }
9
public:
10
    int m_A;
11
};
12

13
class Base72 {
14
public:
15
    Base72()
16
    {
17
        m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
18
    }
19
public:
20
    int m_A;
21
};
22

23
//语法：class 子类：继承方式 父类1 ，继承方式 父类2
24
class Son7 : public Base72, public Base71
25
{
26
public:
27
    Son7()
28
    {
29
        m_C = 300;
30
        m_D = 400;
31
    }
32
public:
33
    int m_C;
34
    int m_D;
35
};
36

37

38
//多继承容易产生成员同名的情况
39
//通过使用类名作用域可以区分调用哪一个基类的成员
40
void test71()
41
{
42
    Son7 s;
43
    std::cout << "sizeof Son7 = " << sizeof(s) << std::endl;
44
    std::cout << s.Base71::m_A << std::endl;
45
    std::cout << s.Base72::m_A << std::endl;
46
}
47

48
int main() {
49

50
    test71();
51

52
    return 0;
53
}

总结：多继承中如果父类中出现了同名情况，子类使用时候要加作用域

4.6.8 菱形继承#

菱形继承概念 ：

两个派生类继承同一个基类

又有某个类同时继承者两个派生类

这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例 ：

菱形继承问题 ：

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

示例：

1
#include<iostream>
2

3
class Animal
4
{
5
public:
6
    int m_Age;
7
};
8

9
//继承前加virtual关键字后，变为虚继承
10
//此时公共的父类Animal称为虚基类
11
class Sheep : virtual public Animal {};
12
class Tuo : virtual public Animal {};
13
class SheepTuo : public Sheep, public Tuo {};
14

15
void test81()
16
{
17
    SheepTuo st;
18
    st.Sheep::m_Age = 100;
19
    st.Tuo::m_Age = 200;
20

21
    std::cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << std::endl;
22
    std::cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << std::endl;
23
    std::cout << "st.m_Age = " << st.m_Age << std::endl;
24
}
25

26
int main() {
27

28
    test81();
29

30
    return 0;
31
}

总结：

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
利用虚继承可以解决菱形继承问题