C++面向对象高效编程 第2版2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载

C++面向对象高效编程 第2版PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

第一部分 概念、实践和应用1

第1章 什么是面向对象编程1

1.1 背景1

1.1.1 面向过程编程示例2

1.1.2 银行账户的表示3

1.1.3 银行账户的安全4

1.1.4 用面向对象编程解决问题5

1.2 理解对象模型7

1.3 术语8

1.4 理解消息、方法和实例变量8

1.4.1 对象中包含的内容9

1.4.2 实例化（或创建）对象11

1.5 什么可以作为类11

1.6 什么不是类12

1.7 类的目的13

1.8 深入了解对象15

1.8.1 对象的状态15

1.8.2 对象状态的重要性15

1.8.3 谁控制对象的状态17

1.8.4 对象的行为18

1.9 面向对象软件开发的阶段18

1.9.1 面向对象分析（OOA）18

1.9.2 面向对象设计（OOD）20

1.10 面向对象编程（OOP）21

1.11 对象模型的关键要素21

1.12 OOP范式和语言24

1.13 面向对象编程语言的要求24

1.14 对象模型的优点25

1.15 小结26

第2章 什么是数据抽象27

2.1 接口和实现的分离30

2.2 对象接口的重要性31

2.3 实现的含义32

2.4 保护实现32

2.5 数据封装的优点34

2.6 接口、实现和数据封装之间的关系35

2.7 数据封装注意事项36

2.8 确定封装的内容36

2.9 抽象数据类型37

2.10 抽象数据类型——栈的实现38

2.11 C＋＋中的数据抽象40

2.12 类中的访问区域41

2.13 和类一起使用的术语47

2.14 类的实现者48

2.15 实现成员函数49

2.16 识别成员函数的目标对象49

2.17 程序示例52

2.18 对象是重点53

2.19 对接口的再认识53

2.20 什么是多线程安全类55

2.21 确保抽象的可靠性——类不变式和断言57

2.21.1 类不变式57

2.21.2 前置条件和后置条件57

2.21.3 使用断言实现不变式和条件59

2.21.4 高效使用断言60

2.22 面向对象设计的表示法60

2.23 Booch表示法61

2.24 Booch中类的关系61

2.24.1 关联62

2.24.2 聚集（has-a）62

2.24.3 “使用”关系65

2.24.4 继承关系（is-a）66

2.24.5 类范畴66

2.25 统一建模语言（UML）67

2.26 UML中类的关系68

2.27 关联69

2.27.1 作为聚集的关联71

2.27.2 OR关联72

2.28 组合72

2.29 泛化关系（is-a）74

2.30 has-a关系的重要性75

2.3 1 小结76

第3章 C＋＋与数据抽象77

3.1 类概念的基础77

3.2 类要素的细节78

3.2.1 访问区域78

3.2.2 分析79

3.3 复制构造函数81

3.4 赋值操作符89

3.5 this指针和名称重整的进一步说明95

3.6 const成员函数的概念98

3.7 编译器如何实现const成员函数99

3.8 C＋＋中类和结构的区别100

3.9 类可以包含什么100

3.10 设计期间的重点——类的接口101

3.11 类名、成员函数名、参数类型和文档102

3.12 参数传递模式——客户的角度103

3.13 采用语义106

3.14 为参数选择正确的模式108

3.15 函数返回值109

3.16 从函数中返回引用111

3.17 编写内存安全类112

3.18 客户对类和函数的责任113

3.19 小结114

第4章 OOP中的初始化和无用单元收集115

4.1 什么是初始化115

4.1.1 使用构造函数初始化117

4.1.2 使用内嵌对象必须遵守的规则124

4.2 无用单元收集问题125

4.2.1 无用单元125

4.2.2 悬挂引用125

4.2.3 无用单元收集和悬挂引用的补救126

4.2.4 无用单元收集和语言设计127

4.2.5 在C＋＋中何时产生无用单元129

4.2.6 对象何时获得资源130

4.3 C＋＋中的无用单元收集130

4.4 对象的标识132

4.5 对象复制的语义136

4.6 对象赋值的语义142

4.7 对象相等的语义145

4.8 为什么需要副本控制149

4.8.1 信号量示例150

4.8.2 许可证服务器示例152

4.8.3 字符串类示例154

4.9 分析160

4.10 “写时复制”的概念161

4.10.1 何时使用引用计数167

4.10.2 “写时复制”小结168

4.11 类和类型169

4.12 小结170

第5章 继承的概念171

5.1 继承的基本知识172

5.2 is-a关系的含义186

5.3 继承关系的效果187

5.4 多态置换原则187

5.5 用继承扩展类层次195

5.6 继承的一些基本优点197

5.7 动态绑定、虚函数和多态性198

5.7.1 动态绑定含义201

5.7.2 动态绑定的支持——虚函数202

5.8 继承对数据封装的影响204

5.9 多态的含义206

5.10 有效使用虚函数（动态绑定）207

5.11 虚析构函数的要求210

5.12 构造函数和虚函数214

5.13 一般—特殊的概念215

5.14 抽象（延期）类的概念215

5.15 抽象类的用途219

5.16 强大的继承232

5.17 有效的代码复用233

5.18 抽象基类的客户236

5.19 继承优点小结237

5.20 继承和动态绑定的危险238

5.20.1 C＋＋如何实现动态绑定（虚函数）240

5.20.2 虚函数的开销240

5.20.3 动态绑定和类型检查241

5.21 不必要的继承和动态绑定242

5.22 使用虚函数的不同模式254

5.23 小结256

第6章 多重继承概念257

6.1 多重继承的简单定义258

6.2 大学示例258

6.3 多重继承关系的含义264

6.4 多重继承场景265

6.4.1 C＋＋中解决名称冲突266

6.4.2 二义性基类问题270

6.5 多重继承的基本优点271

6.6 多重继承的替换方案271

6.6.1 第一种替换方案272

6.6.2 第二种替换方案274

6.7 重复继承276

6.8 重复继承的解决方案279

6.8.1 在C＋＋中通过虚基类共享对象279

6.8.2 虚基类的优点282

6.8.3 虚基类产生的新问题282

6.8.4 比较Eiffel和C＋＋中的多重继承287

6.9 继承的一般问题290

6.10 使用mixin类加入静态功能291

6.10.1 mixin类的定义291

6.10.2 何时使用mixin类296

6.11 动态变化情况的设计296

6.11.1 角色扮演类的设计灵活性302

6.11.2 如何使用角色扮演类302

6.11.3 管理角色的另一种方法311

6.11.4 TUniversityMember类对象的多态用法312

6.11.5 按要求改动现有类313

6.11.6 mixin类和角色对象的比较——适用范围314

6.12 C＋＋的私有派生316

6.12.1 何时使用私有派生319

6.12.2 重新导出私有基类的成员321

6.12.3 私有派生的替换方法——包含323

6.12.4 需要使用私有派生的情况324

6.13 mixin类和私有派生的实用示例327

6.14 继承与包含333

6.15 小结334

第7章 从类中选择性导出（友元函数）336

7.1 需要什么337

7.2 C＋＋的情况337

7.3 友元关系的含义340

7.4 非成员函数和友元函数的应用343

7.4.1 实例1：尽量减少类之间过多的交互343

7.4.2 实例2：克服语法问题349

7.4.3 实例3：需要和多个类进行通信的函数361

7.5 非成员函数的优点362

7.6 选择友元函数还是成员函数365

7.7 小结366

第8章 操作符重载的概念367

8.1 语言类型和程序员定义类型的区别367

8.2 什么是重载操作符370

8.3 操作符重载的优点和缺点371

8.3.1 更加简洁的抽象数据类型372

8.3.2 令人费解的操作符重载372

8.3.3 无法理解优先级和结合规则373

8.4 C＋＋中的重载操作符376

8.5 ＋＋和－－操作符的另一个应用380

8.6 更复杂的操作符——成员访问操作符：－＞387

8.7 非成员函数的操作符395

8.7.1 作为成员函数的操作符396

8.7.2 作为非成员函数实现的操作符398

8.7.3 为什么需要转换402

8.8 转换函数402

8.8.1 转换构造函数和转换函数之间的相互影响405

8.8.2 消除对临时对象的需求409

8.9 从操作符函数返回结果411

8.10 赋值操作符415

8.11 小结415

第9章 泛型类型417

9.1 重复性编码问题417

9.2 智能解决方案——泛型编程424

9.3 泛型类型（类）的基本知识427

9.4 泛型类型和代码重复433

9.5 泛型类实现者与客户之间的契约434

9.5.1 这是否是良好的设计439

9.5.2 泛型类实现中的操作符和成员函数441

9.5.3 替换解决方案——泛型类的特殊化443

9.6 模板特殊化444

9.6.1 模板成员函数的特殊化444

9.6.2 另一种替换方案：分离对象的比较446

9.6.3 不能随意停用模板类的原因448

9.7 模板类特殊化449

9.8 泛型函数的概念451

9.9 C＋＋中模板类和成员函数的实例化455

9.10 泛型类型和类型检查462

9.11 约束泛型和无约束泛型463

9.11.1 C＋＋中对模板参数的约束467

9.11.2 C＋＋中模板参数的特定类型468

9.11.3 模板参数的默认值469

9.12 C＋＋中对模板参数执行约束470

9.13 泛型类和选择性导出473

9.14 继承和泛型类476

9.15 泛型类继承的用途483

9.16 控制对象创建的一般技巧485

9.17 实现计数指针487

9.18 尽量减少模板对象的代码重复496

9.18.1 程序的内存占用498

9.18.2 减少模板代码的方案498

9.19 模板类和源代码保护510

9.20 共享（动态）库中的模板类510

9.20.1 共享库中的模板类——多实例问题513

9.20.2 消除共享库中的多个实例515

9.20.3 和现有共享库链接516

9.20.4 容器类517

9.21 泛型类和继承的比较518

9.22 小结519

第10章 处理异常情况520

10.1 处理错误状况的原因520

10.2 错误码的替换方案522

10.3 C＋＋异常处理模型523

10.3.1 C＋＋异常机制的工作方式524

10.3.2 try块的重要性526

10.3.3 throw表达式的重要性526

10.3.4 理解动态调用链528

10.3.5 处理多个异常530

10.3.6 catch块的责任531

10.4 Eiffel中的异常模型532

10.5 Eiffel和C＋＋异常模型的优缺点536

10.6 有效地使用C＋＋异常538

10.7 创建异常层次538

10.7.1 catch处理代码的顺序541

10.7.2 编写异常安全函数543

10.8 项目中的异常处理架构545

10.9 项目中错误管理的成功策略547

10.9.1 函数不是防火墙549

10.9.2 设计异常层次549

10.10 异常环境中的资源管理552

10.10.1 自动资源管理553

10.10.2 泛化资源管理解决方案556

10.11 异常和构造函数558

10.11.1 从函数中返回安全资源558

10.11.2 管理对象数组的辅助类562

10.11.3 自动无用单元收集的开销567

10.12 构造函数的部分完成568

10.13 使用异常创建安全数组568

10.14 小结574

第二部分 构建强大的面向对象软件575

第11章 掌握数据抽象575

11.1 隐藏抽象的实现细节575

11.1.1 使用句柄的优点579

11.1.2 使用句柄的缺点579

11.2 将指针作为数据成员使用（惰性求值）584

11.3 控制对象创建586

11.3.1 只允许使用new（）操作符创建对象586

11.3.2 防止使用new（）操作符创建对象589

11.4 使用指针和引用代替内嵌对象589

11.5 避免用大型数组作为自动变量（或数据成员）590

11.6 使用对象数组和对象指针数组591

11.7 用对象代替基本类型指针作为数据成员和成员函数的返回值593

11.8 与C的兼容性596

11.9 合理选择实现：对象大小和代码效率598

11.10 避免临时对象601

11.11 使用复制构造函数初始化对象602

11.12 有效使用代理对象603

11.12.1 代理对象有助于安全共享对象604

11.12.2 代理对象易于使用605

11.12.3 代理对象是远程对象的替身606

11.12.4 智能代理对象提供额外的功能607

11.12.5 代理对象解决语法／语义的问题608

11.12.6 泛型下标代理技术611

11.13 使用简单的抽象建立更复杂的抽象613

11.14 抽象必须允许客户以不同的方式使用类614

11.15 小结616

第12章 高效使用继承617

12.1 用继承实现简洁的菜单和命令617

12.2 封装创建对象的细节624

12.3 虚构造函数的概念626

12.4 为协议控制而组合使用虚函数和非虚函数629

12.5 双分派概念638

12.6 设计和实现容器类645

12.7 设计可处理不同类型的容器647

12.8 用泛型编程实现同质容器类659

12.8.1 设计目的660

12.8.2 基于模板的同质容器的优点665

12.9 基于模板的容器的缺点666

12.10 导航容器669

12.11 主动迭代器673

12.12 管理容器和迭代器——客户的角度682

12.12.1 样式1：在容器中创建并返回迭代器供用户使用683

12.12.2 样式2：按值返回用户可使用迭代器控制的容器683

12.13 C＋＋标准模板库（STL）685

12.13.1 STL容器686

12.13.2 迭代器687

12.13.3 STL中的算法687

12.14 小结690

12.15 TArray容器的实现代码691

第13章 理解C＋＋对象模型701

13.1 高效实现701

13.2 C＋＋表示对象的方式701

13.2.1 没有虚函数的类702

13.2.2 成员函数702

13.2.3 静态数据成员703

13.2.4 构造函数704

13.3 包含虚函数的类705

13.4 在共享库之间共享虚函数表708

13.5 虚函数和多重继承（非虚基类）709

13.6 虚基类715

13.6.1 虚基类的成员访问715

13.6.2 带虚函数的虚基类717

13.7 RTTI（运行时类型识别）的实现支持719

13.8 基于对象和面向对象编程720

13.9 引用、指针和值721

13.9.1 引用和指针的赋值721

13.9.2 复制构造函数722

13.9.3 构造函数的职责723

13.10 复制构造函数的责任726

13.11 优化对象的按值传递和按值返回727

13.11.1 按值传递727

13.11.2 按值返回729

13.12 运行时初始化732

13.13 小结732

附录A733

参考书目和推荐读物737

索引741