C++高级编程【2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载】

C++高级编程PDF格式电子书版下载

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

第Ⅰ部分 专业的C＋＋简介3

第1章 C＋＋速成3

1.1 C＋＋基础知识3

1.1.1 小程序的“hello world”3

1.1.2 名称空间6

1.1.3 变量8

1.1.4 运算符9

1.1.5 类型12

1.1.6 条件14

1.1.7 循环16

1.1.8 数组18

1.1.9 函数19

1.2 深入研究C＋＋21

1.2.1 指针以及动态内存21

1.2.2 C＋＋中的字符串24

1.2.3 引用25

1.2.4 异常26

1.2.5 const的多种用法27

1.3 作为面向对象语言的C＋＋28

1.4 标准库30

1.5 第一个有用的C＋＋程序31

1.5.1 雇员记录系统31

1.5.2 Employee类32

1.5.3 Database类35

1.5.4 用户界面38

1.5.5 评估程序40

1.6 本章小结41

第2章 设计专业的C＋＋程序43

2.1 程序设计概述43

2.2 程序设计的重要性44

2.3 C＋＋设计的特点46

2.4 C＋＋设计的两个原则47

2.4.1 抽象47

2.4.2 重用48

2.5 重用代码49

2.5.1 关于术语的说明50

2.5.2 决定是否重用代码50

2.5.3 重用代码的策略52

2.5.4 绑定第三方应用程序56

2.5.5 开放源代码库56

2.5.6 C＋＋标准库57

2.6 设计模式以及技巧58

2.7 设计一个国际象棋程序58

2.7.1 需求58

2.7.2 设计步骤59

2.8 本章小结63

第3章 面向对象设计65

3.1 过程化的思考方式65

3.2 面向对象思想66

3.2.1 类66

3.2.2 组件66

3.2.3 属性67

3.2.4 行为67

3.2.5 综合考虑67

3.3 生活在对象世界里68

3.3.1 过度使用对象69

3.3.2 过于通用的对象69

3.4 对象之间的关系70

3.4.1 “有一个”关系70

3.4.2 “是一个”关系（继承）71

3.4.3 “有一个”与“是一个”的区别73

3.4.4 Not-a关系75

3.4.5 层次结构76

3.4.6 多重继承77

3.4.7 混入类78

3.5 抽象78

3.5.1 接口与实现78

3.5.2 决定公开的接口78

3.5.3 设计成功的抽象80

3.6 本章小结81

第4章 设计可重用代码83

4.1 重用哲学83

4.2 如何设计可重用的代码84

4.2.1 使用抽象84

4.2.2 构建理想的重用代码85

4.2.3 设计有用的接口89

4.2.4 协调通用性以及使用性92

4.3 本章小结93

第5章 编码风格95

5.1 良好外观的重要性95

5.1.1 事先考虑95

5.1.2 良好风格的元素96

5.2 为代码编写文档96

5.2.1 使用注释的原因96

5.2.2 注释的风格99

5.2.3 本书的注释103

5.3 分解103

5.3.1 通过重构分解104

5.3.2 通过设计分解104

5.3.3 本书中的分解104

5.4 命名104

5.4.1 选择一个恰当的名称105

5.4.2 命名约定105

5.5 使用具有风格的语言特性107

5.5.1 使用常量108

5.5.2 使用引用代替指针108

5.5.3 使用自定义异常108

5.6 格式109

5.6.1 关于大括号对齐的争论109

5.6.2 关于空格以及圆括号的争论110

5.6.3 空格以及制表符110

5.7 风格的挑战110

5.8 本章小结111

第Ⅱ部分 专业的C＋＋编码方法第6章 熟悉类和对象115

6.1 电子表格示例介绍115

6.2 编写类116

6.2.1 类定义116

6.2.2 定义方法118

6.2.3 使用对象122

6.3 对象的生命周期123

6.3.1 创建对象124

6.3.2 销毁对象139

6.3.3 对象赋值140

6.3.4 复制以及赋值的区别142

6.4 本章小结144

第7章 掌握类与对象145

7.1 对象的动态内存分配145

7.1.1 Spreadsheet类146

7.1.2 使用析构函数释放内存147

7.1.3 处理复制以及赋值148

7.2 定义数据成员的类型155

7.2.1 静态数据成员155

7.2.2 常量数据成员157

7.2.3 引用数据成员158

7.2.4 常量引用数据成员159

7.3 与方法有关的更多内容159

7.3.1 静态方法159

7.3.2 const方法160

7.3.3 方法重载162

7.3.4 默认参数163

7.3.5 内联方法164

7.4 嵌套类165

7.5 类内的枚举类型167

7.6 友元168

7.7 运算符重载169

7.7.1 示例：为SpreadsheetCell实现加法169

7.7.2 重载算术运算符174

7.7.3 重载比较运算符176

7.7.4 创建具有运算符重载的类型177

7.8 创建稳定的接口178

7.9 本章小结181

第8章 揭秘继承技术183

8.1 使用继承构建类183

8.1.1 扩展类184

8.1.2 重写方法187

8.2 使用继承重用代码190

8.2.1 WeatherPrediction类190

8.2.2 在子类中添加功能191

8.2.3 在子类中替换功能192

8.3 利用父类193

8.3.1 父类构造函数193

8.3.2 父类的析构函数195

8.3.3 使用父类方法196

8.3.4 向上转型以及向下转型198

8.4 继承与多态性200

8.4.1 回到电子表格200

8.4.2 设计多态性的电子表格单元格200

8.4.3 电子表格单元格的基类201

8.4.4 独立的子类203

8.4.5 利用多态性205

8.4.6 考虑将来206

8.5 多重继承207

8.5.1 从多个类继承207

8.5.2 名称冲突以及歧义基类208

8.6 有趣而晦涩的继承问题211

8.6.1 修改重写方法的特征211

8.6.2 继承构造函数（仅限C++11）215

8.6.3 重写方法时的特殊情况218

8.6.4 子类中的复制构造函数以及赋值运算符224

8.6.5 virtual的真相225

8.6.6 运行时类型工具228

8.6.7 非public继承229

8.6.8 虚基类230

8.7 本章小结231

第9章 理解灵活而奇特的C＋＋233

9.1 引用233

9.1.1 引用变量234

9.1.2 引用数据成员236

9.1.3 引用参数236

9.1.4 引用作为返回值238

9.1.5 使用引用还是指针238

9.1.6 右值引用（仅限C++11）241

9.2 关键字的疑问246

9.2.1 const关键字246

9.2.2 static关键字250

9.2.3 非局部变量的初始化顺序254

9.3 类型以及类型转换254

9.3.1 typedef254

9.3.2 函数指针typedef255

9.3.3 类型别名（仅限C++11）256

9.3.4 类型转换257

9.4 作用域解析261

9.5 C++11262

9.5.1 统一初始化262

9.5.2 可选函数语法264

9.5.3 空指针文本265

9.5.4 尖括号265

9.5.5 初始化列表266

9.5.6 显式转换运算符266

9.5.7 特性267

9.5.8 用户定义的字面量268

9.6 头文件270

9.7 C的实用工具271

9.7.1 变长参数列表271

9.7.2 预处理器宏273

9.8 本章小结274

第10章 错误处理275

10.1 错误与异常275

10.1.1 异常的含义276

10.1.2 C＋＋中异常的优点276

10.1.3 C＋＋中异常的缺点277

10.1.4 我们的建议277

10.2 异常机制277

10.2.1 抛出并捕获异常278

10.2.2 异常类型281

10.2.3 抛出并捕获多个异常283

10.2.4 未捕获的异常285

10.2.5 抛出列表287

10.3 异常与多态性291

10.3.1 标准异常体系291

10.3.2 在类层次结构中捕获异常293

10.3.3 编写自己的异常类294

10.3.4 嵌套异常（仅限C++11）297

10.4 堆栈的释放与清理299

10.4.1 使用智能指针300

10.4.2 捕获、清理并重新抛出301

10.5 常见的错误处理问题301

10.5.1 内存分配错误301

10.5.2 构造函数中的错误304

10.5.3 构造函数的function-try-blocks306

10.5.4 析构函数中的错误308

10.6 综合应用308

10.7 本章小结312

第11章 深入探讨标准库313

11.1 编码原则314

11.1.1 使用模板314

11.1.2 使用运算符重载317

11.2 C＋＋标准库概述317

11.2.1 字符串317

11.2.2 I/O流318

11.2.3 本地化318

11.2.4 智能指针318

11.2.5 异常318

11.2.6 数学工具319

11.2.7 时间工具（仅限C++11）319

11.2.8 随机数（仅限C++11）319

11.2.9 编译时有理数运算（仅限C++11）319

11.2.10 元组（仅限C++11）319

11.2.11 正则表达式（仅限C++11）320

11.2.12 标准模板库320

11.2.13 STL算法326

11.2.14 STL中还缺什么333

11.3 本章小结333

第12章 理解容器与迭代器335

12.1 容器概述335

12.1.1 元素的需求336

12.1.2 异常和错误检查338

12.1.3 迭代器338

12.1.4 C++11的变化340

12.2 顺序容器342

12.2.1 vector342

12.2.2 vector＜bool＞特化359

12.2.3 deque359

12.2.4 list360

12.2.5 array（仅限C++11）364

12.2.6 forward_list（仅限C++11）364

12.3 容器适配器366

12.3.1 queue366

12.3.2 priority_queue369

12.3.3 stack372

12.4 关联容器373

12.4.1 pair工具类373

12.4.2 map374

12.4.3 multimap382

12.4.4 set385

12.4.5 multiset387

12.5 无序关联容器／哈希表（仅限C＋＋11）387

12.5.1 哈希函数387

12.5.2 unordered_map388

12.5.3 unordered_multimap391

12.5.4 unordered_set/unordered_multiset391

12.6 其他容器391

12.6.1 标准C风格数组392

12.6.2 string392

12.6.3 流393

12.6.4 bitset393

12.7 本章小结397

第13章 掌握STL算法399

13.1 算法概述399

13.1.1 find和find_if算法400

13.1.2 accumulate算法402

13.1.3 在算法中使用C++11的移动语义404

13.2 lambda表达式（仅限C++11）404

13.2.1 语法404

13.2.2 捕捉块406

13.2.3 将lambda表达式用作返回值406

13.2.4 将lambda表达式用作参数407

13.2.5 示例408

13.3 函数对象410

13.3.1 算术函数对象410

13.3.2 比较函数对象411

13.3.3 逻辑函数对象412

13.3.4 按位函数对象（仅限C++11）412

13.3.5 函数对象适配器413

13.3.6 编写自己的函数对象419

13.4 算法详解420

13.4.1 工具算法421

13.4.2 非修改算法422

13.4.3 修改算法428

13.4.4 排序算法436

13.4.5 集合算法438

13.5 算法示例：审核选民登记440

13.5.1 选民登记审核问题描述440

13.5.2 auditVoterRolls函数440

13.5.3 getDuplicates函数441

13.5.4 测试auditVoterRolls函数443

13.6 本章小结443

第14章 使用字符串与正则表达式445

14.1 动态字符串445

14.1.1 C风格字符串446

14.1.2 字符串字面量447

14.1.3 C++string类448

14.1.4 原始字符串字面量（仅限C++11）451

14.2 本地化452

14.2.1 本地化字符串字面量452

14.2.2 宽字符453

14.2.3 非西方字符集453

14.2.4 locale和facet455

14.3 正则表达式（仅限C++11）457

14.3.1 ECMAScript语法458

14.3.2 regex库463

14.3.3 regex_match（）464

14.3.4 regex_search（）467

14.3.5 regex_iterator468

14.3.6 regex_token_iterator469

14.3.7 regex_replace（）472

14.4 本章小结475

第15章 C++I/O揭秘477

15.1 使用流477

15.1.1 流的含义478

15.1.2 流的来源和目标478

15.1.3 流式输出479

15.1.4 流式输入483

15.1.5 对象的输入输出489

15.2 字符串流491

15.3 文件流492

15.3.1 通过seek（）和tell（）在文件中转移493

15.3.2 将流连接在一起495

15.4 双向I/O496

15.5 本章小结497

第16章 其他库工具499

16.1 STD∷FUNCTION499

16.2 有理数501

16.3 Chrono库503

16.3.1 持续时间503

16.3.2 时钟507

16.3.3 时点508

16.4 生成随机数509

16.4.1 随机数引擎510

16.4.2 随机数引擎适配器512

16.4.3 预定义的引擎和引擎适配器512

16.4.4 生成随机数513

16.4.5 随机数分布514

16.5 元组517

16.6 本章小结520

第17章 自定义和扩展STL521

17.1 分配器521

17.2 迭代器适配器522

17.2.1 反向迭代器522

17.2.2 流迭代器524

17.2.3 插入迭代器524

17.2.4 移动迭代器（仅限C++11）525

17.3 扩展STL527

17.3.1 扩展STL的原因527

17.3.2 编写一个STL算法527

17.3.3 编写一个STL容器530

17.4 本章小结564

第Ⅲ部分 掌握C＋＋的高级特性第18章 C＋＋运算符重载567

18.1 运算符重载概述567

18.1.1 重载运算符的原因568

18.1.2 运算符重载的限制568

18.1.3 运算符重载的决策568

18.1.4 不要重载的运算符570

18.1.5 可重载运算符小结571

18.1.6 右值引用（仅限C++11）574

18.2 重载算术运算符574

18.2.1 重载一元负号和一元正号574

18.2.2 重载递增和递减运算符575

18.3 重载按位运算符和二元逻辑运算符577

18.4 重载插入运算符和提取运算符577

18.5 重载下标运算符579

18.5.1 通过operator［］提供只读访问582

18.5.2 非整数数组索引583

18.6 重载函数调用运算符583

18.7 重载解除引用运算符585

18.7.1 实现operator586

18.7.2 实现operator-＞587

18.7.3 operator-＞*的含义588

18.8 编写转换运算符588

18.8.1 转换运算符的多义性问题590

18.8.2 用于布尔表达式的转换591

18.9 重载内存分配和释放运算符593

18.9.1 new和delete的工作原理593

18.9.2 重载operator new和operator delete595

18.9.3 重载带有额外参数的operator new和operator delete597

18.9.4 显式地删除／默认化operator new和operator delete（仅限C++11）599

18.10 本章小结599

第19章 利用模板编写泛型代码601

19.1 模板概述602

19.2 类模板602

19.2.1 编写类模板602

19.2.2 编译器处理模板的原理610

19.2.3 将模板代码分布在多个文件中611

19.2.4 模板参数612

19.2.5 方法模板614

19.2.6 模板类特例化619

19.2.7 子类化模板类622

19.2.8 继承还是特例化623

19.2.9 模板别名（仅限C++11）623

19.2.10 替换函数语法（仅限C++11）624

19.3 函数模板625

19.3.1 函数模板特例化626

19.3.2 函数模板重载627

19.3.3 类模板的friend函数模板628

19.4 本章小结629

第20章 模板的高级特性631

20.1 深入了解模板参数631

20.1.1 深入了解模板类型参数631

20.1.2 模板参数模板介绍635

20.1.3 深入了解非类型模板参数636

20.2 模板类部分特例化639

20.3 通过重载模拟函数部分特例化643

20.4 模板递归645

20.4.1 一个N维网格：初次尝试645

20.4.2 一个真正的N维网格647

20.5 类型推导（仅限C++11）652

20.5.1 auto关键字652

20.5.2 decltype关键字653

20.5.3 结合模板使用auto和decltype653

20.6 可变参数模板（仅限C++11）655

20.6.1 类型安全的可变长度参数列表656

20.6.2 可变数目的混入类658

20.7 元编程659

20.7.1 编译时阶乘659

20.7.2 循环展开660

20.7.3 打印元组（仅限C++11）661

20.7.4 类型trait（仅限C++11）663

20.7.5 结论668

20.8 本章小结668

第21章 高效的内存管理669

21.1 使用动态内存669

21.1.1 如何描绘内存670

21.1.2 分配和释放671

21.1.3 数组672

21.1.4 使用指针679

21.2 数组-指针的对偶性681

21.2.1 数组就是指针681

21.2.2 并非所有的指针都是数组682

21.3 低级内存操作683

21.3.1 指针运算683

21.3.2 自定义内存管理684

21.3.3 垃圾回收684

21.3.4 对象池685

21.3.5 函数指针685

21.3.6 方法和成员的指针687

21.4 智能指针687

21.4.1 旧的过时的auto_ptr688

21.4.2 新的C++11智能指针688

21.4.3 编写自己的智能指针类692

21.5 内存常见的陷阱697

21.5.1 分配不足的字符串697

21.5.2 内存泄漏698

21.5.3 双重删除和无效指针701

21.5.4 访问内存越界701

21.6 本章小结702

第22章 C＋＋多线程编程703

22.1 简介703

22.2 原子操作库707

22.2.1 原子类型示例708

22.2.2 原子操作710

22.3 线程711

22.3.1 通过函数指针创建线程712

22.3.2 通过函数对象创建线程714

22.3.3 通过lambda创建线程715

22.3.4 通过成员函数创建线程716

22.3.5 线程本地存储717

22.3.6 取消线程717

22.3.7 从线程获得结果717

22.3.8 复制和重新抛出异常717

22.4 互斥720

22.4.1 互斥体类720

22.4.2 锁721

22.4.3 std∷call_once723

22.4.4 互斥体的用法示例724

22.5 条件变量727

22.6 future729

22.7 示例：多线程日志记录器类731

22.8 线程池736

22.9 线程设计和最佳实践737

22.10 本章小结738

第Ⅳ部分 C＋＋软件工程741

第23章 充分利用软件工程方法741

23.1 过程的必要性741

23.2 软件生命周期模型742

23.2.1 分段模型和瀑布模型742

23.2.2 螺旋模型745

23.2.3 Rational统一过程747

23.3 软件工程方法学748

23.3.1 敏捷748

23.3.2 Scrum748

23.3.3 极限编程（XP）750

23.3.4 软件分流754

23.4 构建自己的过程和方法754

23.4.1 对新思想采取开放态度754

23.4.2 提出新想法754

23.4.3 知道什么行得通什么行不通754

23.4.4 不要逃避755

23.5 源代码控制755

23.6 本章小结757

第24章 编写高效的C＋＋程序759

24.1 性能和效率概述759

24.1.1 提升效率的两种方式760

24.1.2 两种程序760

24.1.3 C＋＋是不是低效的语言760

24.2 语言层次的效率761

24.2.1 高效地操纵对象761

24.2.2 使用内联方法和函数765

24.3 设计层次的效率765

24.3.1 尽可能多地缓存765

24.3.2 使用对象池766

24.4 剖析770

24.4.1 使用gprof的剖析范例770

24.4.2 使用Visual C++2010的剖析范例778

24.5 本章小结780

第25章 开发跨平台和跨语言的应用程序781

25.1 跨平台开发781

25.1.1 硬件架构问题782

25.1.2 实现问题783

25.1.3 平台相关的特性784

25.2 跨语言开发785

25.2.1 混合使用C和C＋＋785

25.2.2 转移范例786

25.2.3 和C代码链接788

25.2.4 混合使用C＃与C＋＋790

25.2.5 通过JNI混合Java和C＋＋791

25.2.6 混合C＋＋使用Perl和shell脚本794

25.2.7 混合使用C＋＋和汇编代码797

25.3 本章小结798

第26章 成为测试专家799

26.1 质量控制800

26.1.1 测试是谁的职责800

26.1.2 bug的生命周期800

26.1.3 bug跟踪工具801

26.2 单元测试802

26.2.1 单元测试的方法803

26.2.2 单元测试过程803

26.2.3 单元测试实例807

26.3 更高级别的测试813

26.3.1 集成测试813

26.3.2 系统测试815

26.3.3 回归测试815

26.4 成功测试的技巧816

26.5 本章小结816

第27章 熟练掌握调试技术819

27.1 调试的基本定律819

27.2 bug分类学820

27.3 避免bug820

27.4 为bug做好规划820

27.4.1 错误日志821

27.4.2 调试跟踪822

27.4.3 断言833

27.4.4 静态断言（仅限C++11）834

27.5 调试技术835

27.5.1 重现bug835

27.5.2 调试可重复的bug836

27.5.3 调试不可重现的bug836

27.5.4 调试内存问题837

27.5.5 调试多线程程序841

27.5.6 调试示例：文章引用841

27.5.7 从ArticleCitations示例中总结的教训853

27.6 本章小结853

第28章 将设计技术和框架结合使用855

28.1 C＋＋编码示例856

28.1.1 编写一个类856

28.1.2 子类化已有的类857

28.1.3 抛出和捕获异常858

28.1.4 从文件中读取858

28.1.5 写入文件859

28.1.6 写一个模板类859

28.2 肯定有更好的方法860

28.2.1 双分派861

28.2.2 混入类866

28.3 面向对象的框架868

28.3.1 使用框架868

28.3.2 模型-视图-控制器范例869

28.4 本章小结870

第29章 应用设计模式871

29.1 迭代器模式872

29.2 单实例模式872

29.2.1 示例：一种日志机制873

29.2.2 实现一个单实例873

29.2.3 使用一个单实例877

29.2.4 单实例模式和多线程877

29.3 工厂模式880

29.3.1 示例：汽车工厂模拟880

29.3.2 实现一个工厂882

29.3.3 使用一个工厂884

29.3.4 工厂的其他用途885

29.4 代理模式885

29.4.1 示例：隐藏网络连接的问题885

29.4.2 实现一个代理886

29.4.3 使用代理886

29.5 适配器模式887

29.5.1 示例：适配一个Logger类887

29.5.2 实现一个适配器888

29.5.3 使用适配器888

29.6 装饰器模式889

29.6.1 示例：在网页中定义样式889

29.6.2 装饰器的实现890

29.6.3 使用一个装饰器891

29.7 责任链模式892

29.7.1 示例：事件处理892

29.7.2 责任链的实现892

29.7.3 责任链的使用893

29.8 观察者模式894

29.8.1 示例：事件处理894

29.8.2 观察者的实现894

29.8.3 使用观察者895

29.9 本章小结896

附录A C＋＋面试897

附录B 带注解的参考文献917

附录C 标准库头文件927