-
c++学习---第四部分下
第四部分-继承和多态
4.6、继承
1、继承的基本语法
2、继承方式*
继承的语法：class 子类 ： 继承方式 父类
继承方式一共有三种：
公共继承
保护继承
私有继承
3、继承中的对象模型
**问题：**从父类继承过来的成员，那些属于子类对象中？
**结论：**父类中私有成员也是被子类继承下去，只是由编译器给隐藏后访问不到
4、继承中构造和析构的顺序
总结：继承中 先调用父类构造函数，在调用子类构造函数，析构顺序与构造相反
5、继承同名成员处理方式
总结:
1、子类对象可以直接访问到子类中同名成员
2、子类对象加作用域可以访问到父类同名成员
3、当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
6、继承同名静态成员处理方式
总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通过类名）
7、多继承语法
总结：多继承中如果父类出现了同名情况，子类使用时候要加作用域
8、菱形继承
vbptr解释
代码演示
总结：
菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
利用虚继承可以解决零星继承问题
4.7、多态
1、多态的基本概念
#includeusing namespace std; //多态 //动物类 class Animal { public: //虚函数 virtual void speak() { cout << "动物在说话" << endl; } }; class Cat :public Animal{ public: void speak() { cout << "猫在说话" << endl; } }; //执行说话的函数 //地址早绑定 在编译阶段确定函数地址 //如果想执行让猫说话，那么这个函数地址就不能提前绑定 //动态多台满足条件 //1、有继承关系 //2、子类重写父类的虚函数 //动态多态使用 // 父类的指针或者引用执行子类对象 void doSpeak(Animal &animal) {// Animal & animal = cat; animal.speak(); } void test01() { //重写 函数返回值类型 函数名 参数列表 完全相同 Cat cat; doSpeak(cat); } void test02() { cout << "sizeof Animal = " << sizeof(Animal) << endl; } int main() { //test01(); test02(); } - 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
内存指针层面的解释
2、多态案例一、计算器类
#includeusing namespace std; #include //普通写法 class Calculator { public: int getResult(string oper) { if (oper == "+") { return m_Num1 + m_Num2; } if (oper == "-") { return m_Num1 - m_Num2; } if (oper == "*") { return m_Num1 * m_Num2; } if (oper == "/") { return m_Num1 / m_Num2; } //如果想扩展新的功能，需求修改源码 //在真是开发中 提倡 开闭原则 //开闭原则：对扩展进行开发，对修改进行关闭 } int m_Num1; int m_Num2; }; void test01() { Calculator c; c.m_Num1 = 10; c.m_Num2 = 10; cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl; cout << c.m_Num1 << "-" << c.m_Num2 << "-" << c.getResult("-") << endl; cout << c.m_Num1 << "*" << c.m_Num2 << "*" << c.getResult("*") << endl; cout << c.m_Num1 << "/" << c.m_Num2 << "/" << c.getResult("/") << endl; } //利用多态实现计算器 //实现计算器抽象类 //1、组织结构清晰 //2、可读性强 //3、对于前期和后期扩展以及维护性高 class AbstractCaculator { public: virtual int getResult(){ return 0; } int m_Num1; int m_Num2; }; //加法计算器类 class AddCalculator : public AbstractCaculator { public: int getResult() { return m_Num1 + m_Num2; } }; class SubCalculator : public AbstractCaculator { public: int getResult() { return m_Num1 - m_Num2; } }; class MulCalculator : public AbstractCaculator { public: int getResult() { return m_Num1 * m_Num2; } }; void test02() { //多态使用 //父类指针或者引用指向子类对象 //加法对象 AbstractCaculator* abs = new AddCalculator; abs->m_Num1 = 10; abs->m_Num2 = 10; cout << abs->m_Num1 << "+" << abs->m_Num2 << "=" << abs->getResult() << endl; //用完记得销毁 delete abs; //减法运算 abs = new SubCalculator; abs->m_Num1 = 10; abs->m_Num2 = 10; cout << abs->m_Num1 << "-" << abs->m_Num2 << "=" << abs->getResult() << endl; delete abs; //乘法运算 abs = new MulCalculator; abs->m_Num1 = 10; abs->m_Num2 = 10; cout << abs->m_Num1 << "*" << abs->m_Num2 << "=" << abs->getResult() << endl; delete abs; } int main() { //test01(); test02(); } - 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
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
总结：c++开发提倡利用多态设计程序架构，因为多态优点很多
3、纯虚函数和抽象类
4、多态案例二-制作饮品
代码
#includeusing namespace std; //制作饮品 class AbstractDrinking { public: //煮水 virtual void Boil() = 0; //冲泡 virtual void Brew() = 0; //倒入杯中 virtual void PourInCup() = 0; //加入辅料 virtual void PutSomething() = 0; //制作 void makeDrink() { Boil(); Brew(); PourInCup(); PutSomething(); } }; //制作咖啡 class Coffee : public AbstractDrinking { public: //煮水 virtual void Boil() { cout << "煮农夫山泉" << endl; } //冲泡 virtual void Brew() { cout << "冲泡咖啡" << endl; } //倒入杯中 virtual void PourInCup() { cout << "倒入杯中" << endl; } //加入辅料 virtual void PutSomething() { cout << "加入糖" << endl; } }; //制作茶 class Tea : public AbstractDrinking { public: //煮水 virtual void Boil() { cout << "煮矿泉水" << endl; } //冲泡 virtual void Brew() { cout << "冲泡茶叶" << endl; } //倒入杯中 virtual void PourInCup() { cout << "倒入杯中" << endl; } //加入辅料 virtual void PutSomething() { cout << "加入柠檬" << endl; } }; void doWork(AbstractDrinking * abs) { //AbstractDrinking * abs = new Caffee abs->makeDrink(); delete abs;//释放 } void test01() { doWork(new Coffee); cout << "--------------" << endl; doWork(new Tea); } int main() { test01(); } - 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
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
5、虚析构和纯虚析构
#includeusing namespace std; #include class Animal { public: Animal() { cout << "Animal的构造函数调用" << endl; } //利用虚析构可以解决 父类指针释放子类对象时不干净的问题 /*virtual ~Animal() { cout << "Animal的析构函数调用" << endl; }*/ //纯虚析构 virtual ~Animal() = 0; //纯虚函数 virtual void speak() = 0; }; //纯虚析构需要声明，也需要具体实现 //有了纯虚析构之后，这个类也属于抽象类，无法实例化对象 Animal::~Animal() { cout << "Animal纯虚析构函数调用" << endl; } class Cat : public Animal { public: Cat(string name) { cout << "Cat的构造函数调用" << endl; m_Name = new string(name); } virtual void speak() { cout << *m_Name << "小猫在说话" << endl; } ~Cat() { if (m_Name != NULL) { cout << "Cat的析构函数" << endl; } } string* m_Name; }; void test01() { Animal* animal = new Cat("TOM"); animal->speak(); //父类指针在析构时候 不会调用子类中析构函数 导致子类对象可能清理不干净，造成内存泄露 //怎么解决？基类怎加一个虚析构函数 //析构函数就是用来解决通过父类指针释放子类对象 delete animal; } int main() { test01(); } - 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
6、多态案例三-电脑组装
案例分析
代码实现
#includeusing namespace std; //抽象不同零件类 //抽象cpu类 class CPU { public: virtual void calculat() = 0; }; //抽象显卡类 class VideoCard { public: virtual void display() = 0; }; //抽象内存条类 class Memory { public: virtual void storage() = 0; }; //电脑类 class Computer { public: Computer(CPU* cpu, VideoCard* vc, Memory* mem) { m_cpu = cpu; m_vc = vc; m_mem = mem; } void work() { m_cpu->calculat(); m_vc->display(); m_mem->storage(); } //提供一个析构函数释放三个电脑的零件 ~Computer() { //释放cpu if (m_cpu != NULL) { delete m_cpu; m_cpu = NULL; } //释放显卡 if (m_vc != NULL) { delete m_vc; m_vc = NULL; } //释放内存 if (m_mem != NULL) { delete m_mem; m_mem = NULL; } } private: CPU* m_cpu;//CPU零件指针 VideoCard* m_vc;//显卡零件指针 Memory* m_mem;//内存条零件指针 }; //具体厂商 //Inter厂商 class InterCPU : public CPU { public: virtual void calculat() { cout << "Inter的CPU开始计算了" << endl; } }; class InterVideoCard : public VideoCard { public: virtual void display() { cout << "Inter的显卡开始显示了" << endl; } }; class InterMemory : public Memory { public: virtual void storage() { cout << "Inter的内存条开始存储了" << endl; } }; //Lenovo厂商 class LenovoCPU : public CPU { public: virtual void calculat() { cout << "Lenovo的CPU开始计算了" << endl; } }; class LenovoVideoCard : public VideoCard { public: virtual void display() { cout << "Lenovo的显卡开始显示了" << endl; } }; class LenovoMemory : public Memory { public: virtual void storage() { cout << "Lenovo的内存条开始存储了" << endl; } }; void test01() { //第一台电脑的零件 CPU* interCpu = new InterCPU; VideoCard* interCar = new InterVideoCard; Memory* interMem = new InterMemory; //创建第一台电脑 Computer* computer1 = new Computer(interCpu, interCar, interMem); computer1->work(); delete computer1; cout << "----------" << endl; cout << "第二台开始工作" << endl; //创建第二台电脑 Computer* computer2 = new Computer(new LenovoCPU,new LenovoVideoCard,new LenovoMemory); computer2->work(); delete computer2; cout << "----------" << endl; cout << "第三台开始工作" << endl; //创建第二台电脑 Computer* computer3 = new Computer(new InterCPU, new LenovoVideoCard, new LenovoMemory); computer3->work(); delete computer3; } int main() { test01(); } - 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
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
-
相关阅读:
Java开发：实现用户注册登录的功能
JavaScript FormData基本方法介绍
iOS ijkplayer 硬解H265（hevc）4k视频问题解决
nacos - centos7.x环境单机与集群快速部署
前端三剑客—HTML
发布：iNeuOS工业互联网操作系统 V5 Preview1 版本（自主可控）
CentOS源码更新Linux最新内核
Spring Boot 3.2四个新特点提升运行性能
【读博日记】拓扑结构（待修正）
智能指针笔记
- 原文地址：https://blog.csdn.net/charles_zhang_/article/details/126456573