第1页 / 共210页
第2页 / 共210页
第3页 / 共210页
第4页 / 共210页
第5页 / 共210页
第6页 / 共210页
第7页 / 共210页
第8页 / 共210页
王桂林老师c++基础与提高.pdf
作者：王桂林
技术交流:qq329973169
C++基础与提高
王桂林
Mail:guilin_wang@163.com
1. 综述 C++................................................................................................................................ 1
1.1. 作者...................................................................................................................................1
1.1.1. 历史背景................................................................................................................1
1.1.2. 应“运”而生？运为何？....................................................................................1
1.1.3. C++发展大记事.................................................................................................... 1
1.2. 应用领域...........................................................................................................................2
1.2.1. 系统层软件开发....................................................................................................2
1.2.2. 服务器程序开发....................................................................................................2
1.2.3. 流戏，网络，分布式，云计算............................................................................2
1.2.4. 科学计算................................................................................................................2
1.3. 内容...................................................................................................................................2
1.4. 书籍推荐...........................................................................................................................3
2. C++对 C 的扩展(Externsion)............................................................................................... 4
2.1. 类型增强...........................................................................................................................4
2.1.1. 类型检查更严格....................................................................................................4
2.1.2. 布尔类型（bool）............................................................................................... 4
2.1.3. 真正的枚举(enum).............................................................................................. 4
2.1.4. 表达式的值可被赋值............................................................................................5
2.2. 输入与输出(cin /cout)...................................................................................................5
2.2.1. cin && cout..........................................................................................................5
2.2.2. 格式化....................................................................................................................5
2.3. 函数重载(function overload)......................................................................................6
2.3.1. 引例........................................................................................................................6
2.3.2. 重载规则与调用匹配（overload&match）....................................................7
2.3.3. 重载底层实现（name mangling）..................................................................8
2.3.4. extern “C”......................................................................................................... 8
2.4. 操作符重载(operator overload)................................................................................. 9
2.5. 默认参数(default parameters)................................................................................. 10
2.5.1. 示例......................................................................................................................10
2.5.2. 规则......................................................................................................................11
2.6. 引用(Reference)...........................................................................................................11
2.6.1. 引用的概念..........................................................................................................11
2.6.2. 规则......................................................................................................................11
2.6.3. 应用......................................................................................................................12
2.6.4. 引用提高..............................................................................................................12
2.6.5. 引用的本质浅析..................................................................................................15
2.7. new/delete Operator.................................................................................................17
2.7.1. new/new[]用法:................................................................................................. 17
2.7.2. delete /delete[]用法:........................................................................................ 18
2.7.3. 综合用法..............................................................................................................18
2.7.4. 关于返回值..........................................................................................................19
2.7.5. 注意事项..............................................................................................................19
2.7.6. 更进一步..............................................................................................................19
2.8. 内联函数(inline function).......................................................................................... 19
2.8.1. 内联......................................................................................................................19
2.8.2. 语法......................................................................................................................20
2.8.3. 评价......................................................................................................................20
2.9. 类型强转(type cast).................................................................................................... 20
2.9.1. 静态类型转换：..................................................................................................21
2.9.2. 重解释类型转换：..............................................................................................21
2.9.3. (脱)常类型转换：................................................................................................22
2.9.4. 动态类型转换：..................................................................................................23
2.10. 命名空间(namespace scope)................................................................................. 23
2.10.1. 为什么要引入 namespace............................................................................. 23
2.10.2. 默认 NameSpace（Global &Function）.................................................. 24
2.10.3. 语法规则............................................................................................................24
2.11. 系统 string 类............................................................................................................. 28
2.11.1. 定义及初始化....................................................................................................28
2.11.2. 类型大小............................................................................................................28
2.11.3. 常用运算............................................................................................................28
2.11.4. 常见的成员函数................................................................................................29
2.11.5. string 类型数组................................................................................................29
2.12. C++之父给 C 程序员的建议......................................................................................30
2.13. 练习..............................................................................................................................30
2.13.1. 格式输出时钟....................................................................................................30
2.13.2. string 数组的使用.............................................................................................30
3. 封装(Encapsulation).......................................................................................................... 31
3.1. 封装................................................................................................................................ 31
3.1.1. 从 struct 说起.....................................................................................................31
3.1.2. 封装......................................................................................................................33
3.1.3. 用 class 去封装带行为的类...............................................................................33
3.2. 练习封装........................................................................................................................ 36
3.2.1. 封装自己的 list................................................................................................... 36
4. 类与对象(Class &&object)............................................................................................... 37
4.1. stack 声明与定义.......................................................................................................... 37
4.2. 构造器（Constructor）..............................................................................................38
4.2.1. 定义及意义..........................................................................................................38
4.2.2. 参数初始化表......................................................................................................39
4.3. 析造器(Destructor)..................................................................................................... 40
4.3.1. 对象销毁时期......................................................................................................40
4.3.2. 析构器的定义及意义..........................................................................................40
4.3.3. 小结......................................................................................................................40
4.4. 构造与析构小结............................................................................................................ 40
4.5. 多文件编程.................................................................................................................... 41
4.6. 拷贝构造(Copy contructor)...................................................................................... 41
4.6.1. 拷贝构造的定义及意义......................................................................................41
4.6.2. 拷贝构造发生的时机。......................................................................................41
4.6.3. 深拷贝与浅拷贝..................................................................................................42
4.7. this 指针......................................................................................................................... 43
4.7.1. 意义......................................................................................................................43
4.7.2. 作用......................................................................................................................43
4.8. 赋值运算符重载(Operator=)..................................................................................... 44
4.8.1. 发生的时机..........................................................................................................44
4.8.2. 定义......................................................................................................................44
4.8.3. 规则......................................................................................................................44
4.9. 返回栈上引用与对象.................................................................................................... 45
4.9.1. c 语言返回栈变量................................................................................................45
4.9.2. c++返回栈对象...................................................................................................45
4.9.3. c++返回栈对象引用...........................................................................................48
4.10. 案例系统 string 与 MyString..................................................................................49
4.10.1. string 的使用.....................................................................................................49
4.10.2. MyString 声明................................................................................................. 49
4.10.3. 构造....................................................................................................................50
4.10.4. 析构....................................................................................................................50
4.10.5. 拷贝构造（深拷贝）........................................................................................50
4.10.6. 赋值运算符重载................................................................................................50
4.10.7. 加法运算符重载................................................................................................50
4.10.8. 关系运算符重载................................................................................................51
4.10.9. []运算符重载......................................................................................................51
4.10.10. 测试..................................................................................................................51
4.11. 课常练习...................................................................................................................... 52
4.11.1. 实现钟表类........................................................................................................52
4.11.2. 分析：................................................................................................................52
4.11.3. 代码....................................................................................................................52
4.12. 栈和堆上的对象及对象数组......................................................................................53
4.12.1. 引例....................................................................................................................53
4.12.2. 用 new 和 delete 生成销毁堆对象...............................................................54
4.12.3. 栈对象数组........................................................................................................54
4.12.4. 堆对象数组........................................................................................................54
4.12.5. 结论....................................................................................................................54
4.13. 成员函数的存储方式..................................................................................................54
4.13.1. 类成员可能的组成............................................................................................54
4.13.2. 类成员实际的组成............................................................................................55
4.13.3. 调用原理............................................................................................................55
4.13.4. 注意事项............................................................................................................56
4.14. const 修饰符.............................................................................................................. 56
4.14.1. 常数据成员........................................................................................................56
4.14.2. 常成员函数........................................................................................................57
4.14.3. 常对象................................................................................................................58
4.15. static 修饰符...............................................................................................................58
4.15.1. 类静态数据成员的定义及初始化....................................................................58
4.15.2. 类静态成员函数的定义....................................................................................59
4.15.3. 综合案例............................................................................................................61
4.16. static const 成员....................................................................................................... 62
4.17. 指向类成员的指针......................................................................................................63
4.17.1. 指向普通变量和函数的指针............................................................................63
4.17.2. 指向类数据成员的指针....................................................................................63
4.17.3. 指向类成员函数的指针....................................................................................64
4.17.4. 指向类成员指针小结：....................................................................................65
4.17.5. 应用提高............................................................................................................65
4.17.6. 指向类静态成员的指针....................................................................................66
4.18. 作业..............................................................................................................................67
4.18.1. 按需求设计一个圆类........................................................................................67
4.18.2. 编写 C++程序完成以下功能：......................................................................67
5. 友元(Friend).........................................................................................................................68
5.1. 同类对象间无私处........................................................................................................ 68
5.2. 异类对象间有友员........................................................................................................ 68
5.2.1. 友元函数..............................................................................................................68
5.2.2. 友元类..................................................................................................................70
5.3. 论友元............................................................................................................................ 71
5.3.1. 声明位置..............................................................................................................71
5.3.2. 友元的利弊..........................................................................................................71
5.3.3. 注意事项..............................................................................................................71
6. 运算符重载(Operator OverLoad)....................................................................................72
6.1. 重载入门........................................................................................................................ 72
6.1.1. 语法格式..............................................................................................................72
6.1.2. 友元重载..............................................................................................................72
6.1.3. 成员重载..............................................................................................................73
6.1.4. 重载规则..............................................................................................................74
6.2. 重载例举........................................................................................................................ 76
6.2.1. 双目运算符例举..................................................................................................76
6.2.2. 单目运算符例举..................................................................................................78
6.2.3. 流输入输出运算符重载......................................................................................81
6.3. 运算符重载小结............................................................................................................ 83
6.3.1. 重载格式..............................................................................................................83
6.3.2. 不可重载的运算符..............................................................................................83
6.3.3. 只能重载为成员函数的运算符..........................................................................83
6.3.4. 常规建议..............................................................................................................83
6.3.5. 友元还是成员？..................................................................................................83
6.4. 类型转换........................................................................................................................ 85
6.4.1. 标准类型间转换..................................................................................................85
6.4.2. 用类型转换构造函数进行类型转换..................................................................85
6.4.3. 用类型转换操作符函数进行转换......................................................................87
6.4.4. 小结......................................................................................................................88
6.4.5. 作业......................................................................................................................88
6.5. 运算符重载提高篇........................................................................................................ 89
6.5.1. 函数操作符（()）---仿函数..............................................................................89
6.5.2. 堆内存操作符 （new delete）.......................................................................90
6.5.3. 解引用与智能指针（-> /*）............................................................................ 93
6.6. 作业................................................................................................................................ 95
6.6.1. 设计 TDate 类.................................................................................................... 95
6.6.2. 设计一个矩阵类..................................................................................................96
6.6.3. 设计代理类..........................................................................................................96
7. 继承与派生(Inherit&&Derive)......................................................................................... 98
7.1. 引入................................................................................................................................ 98
7.1.1. 归类......................................................................................................................98
7.1.2. 抽取......................................................................................................................98
7.1.3. 继承......................................................................................................................98
7.1.4. 重用......................................................................................................................98
7.2. 定义................................................................................................................................ 99
7.3. 继承................................................................................................................................ 99
7.3.1. 关系定性 is-a/has-a..........................................................................................99
7.3.2. 语法................................................................................................................... 100
7.3.3. 继承方式........................................................................................................... 100
7.3.4. 派生类的组成................................................................................................... 101
7.4. 派生类的构造..............................................................................................................103
7.4.1. 派生类构造函数的语法：............................................................................... 103
7.4.2. 代码实现........................................................................................................... 104
7.4.3. 结论................................................................................................................... 107
7.5. 派生类的拷贝构造......................................................................................................107
7.5.1. 格式................................................................................................................... 107
7.5.2. 代码................................................................................................................... 107
7.5.3. 结论：............................................................................................................... 109
7.6. 派生类的赋值运算符重载..........................................................................................109
7.6.1. 格式................................................................................................................... 109
7.6.2. 代码................................................................................................................... 109
7.6.3. 结论:.................................................................................................................. 110
7.7. 派生类友元函数..........................................................................................................110
7.8. 派生类析构函数的语法..............................................................................................111
7.9. 派生类成员的标识和访问..........................................................................................112
7.9.1. 作用域分辨符................................................................................................... 112
7.9.2. 继承方式........................................................................................................... 113
7.9.3. 派生类成员属性划分为四种：....................................................................... 114
7.10. why public................................................................................................................115
7.10.1. 继承方式与成员访问属性............................................................................. 115
7.10.2. 公有继承的意义：......................................................................................... 115
7.10.3. 使用 Qt 类库...................................................................................................117
7.10.4. 私有继承和保护继承的存在意义................................................................. 117
7.11. 多继承........................................................................................................................118
7.11.1. 多继承的意义................................................................................................. 118
7.11.2. 继承语法......................................................................................................... 118
7.11.3. 沙发床实现..................................................................................................... 118
7.11.4. 三角问题(二义性问题)...................................................................................121
7.11.5. 钻石问题......................................................................................................... 122
7.11.6. 多继承实现的原理......................................................................................... 125
8. 多态（PolyMorphism）..................................................................................................126
8.1. 浅析多态的意义..........................................................................................................126
8.2. 赋值兼容(多态实现的前提)....................................................................................... 126
8.2.1. 规则................................................................................................................... 126
8.2.2. 代码................................................................................................................... 126
8.2.3. 补充：............................................................................................................... 127
8.3. 多态形成的条件..........................................................................................................128
8.3.1. 多态................................................................................................................... 128
8.3.2. 虚函数............................................................................................................... 128
8.3.3. 虚函数小结....................................................................................................... 129
8.3.4. 纯虚函数........................................................................................................... 130
8.3.5. 纯虚函数小结................................................................................................... 131
8.3.6. 含有虚函数的析构........................................................................................... 131
8.3.7. 若干限制........................................................................................................... 131
8.4. 案例..............................................................................................................................131
8.4.1. 覆写--基于 qt 覆写鼠标事件..........................................................................131
8.4.2. 虚析构--动物园里欢乐多................................................................................133
8.4.3. 设计模式--听妈妈讲故事................................................................................135
8.4.4. 组装电脑系统................................................................................................... 139
8.4.5. 企业员工信息管理系统................................................................................... 140
8.4.6. cocos 跨平台入口分析.................................................................................... 146
8.4.7. 实现一个简单渲染树....................................................................................... 148
8.5. 运行时类型信息(RTTI)...............................................................................................149
8.5.1. typeid................................................................................................................ 149
8.5.2. typecast............................................................................................................ 151
8.5.3. RTTI 应用...........................................................................................................152
8.6. 多态实现浅浅析..........................................................................................................153
8.6.1. 虚函数表........................................................................................................... 153
8.6.2. 一般继承（无虚函数覆写）........................................................................... 154
8.6.3. 一般继承（有虚函数覆写）........................................................................... 155
8.6.4. 静态代码发生了什么？................................................................................... 156
8.6.5. 评价多态........................................................................................................... 156
8.6.6. 常见问答........................................................................................................... 156
8.6.7. 练习................................................................................................................... 158
9. 模板(Templates)............................................................................................................... 159
9.1. 函数模板......................................................................................................................159
9.1.1. 函数重载实现的泛型....................................................................................... 159
9.1.2. 函数模板的引入............................................................................................... 159
9.1.3. 函数模板的实例............................................................................................... 160
9.1.4. 小结................................................................................................................... 160
9.2. 类模板..........................................................................................................................160
9.2.1. 引例................................................................................................................... 160
9.2.2. 类模板语法....................................................................................................... 162
9.2.3. 类模板实例....................................................................................................... 162
9.2.4. 练习................................................................................................................... 164
10. 输入输出 IO 流.................................................................................................................167
10.1. io 类图关系................................................................................................................167
10.2. 流类综述....................................................................................................................168
10.2.1. IO 对象不可复制或赋值................................................................................168
10.2.2. IO 对象是缓冲的.............................................................................................168
10.2.3. 重载了<< 和 >>运算符............................................................................. 169
10.3. 标准输出....................................................................................................................169
10.3.1. iomanip...........................................................................................................169
10.3.2. 成员函数......................................................................................................... 172
10.4. 标准输入 cin............................................................................................................. 172
相关推荐
2023年江西萍乡中考道德与法治真题及答案.doc
2012年重庆南川中考生物真题及答案.doc
2013年江西师范大学地理学综合及文艺理论基础考研真题.doc
2020年四川甘孜小升初语文真题及答案I卷.doc
2020年注册岩土工程师专业基础考试真题及答案.doc
2023-2024学年福建省厦门市九年级上学期数学月考试题及答案.doc
2021-2022学年辽宁省沈阳市大东区九年级上学期语文期末试题及答案.doc
2022-2023学年北京东城区初三第一学期物理期末试卷及答案.doc
2018上半年江西教师资格初中地理学科知识与教学能力真题及答案.doc
2012年河北国家公务员申论考试真题及答案-省级.doc
2020-2021学年江苏省扬州市江都区邵樊片九年级上学期数学第一次质量检测试题及答案.doc
2022下半年黑龙江教师资格证中学综合素质真题及答案.doc
