C++高级编程PDF|Epub|txt|kindle电子书版本网盘下载

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

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

第Ⅰ部分 专业的C+简介2

第1章 C++和标准库速成2

1.1 C+++基础知识2

1.1.1 小程序“hello world”3

1.1.2 名称空间5

1.1.3 字面量6

1.1.4 变量7

1.1.5 运算符8

1.1.6 类型10

1.1.7 条件语句12

1.1.8 逻辑比较运算符14

1.1.9 函数15

1.1.10 C风格的数组16

1.1.11 std::array17

1.1.12 std::vector17

1.1.13 结构化绑定18

1.1.14 循环18

1.1.15 初始化列表19

1.1.16 这些都是基础19

1.2 深入研究C+++20

1.2.1 C++++中的字符串20

1.2.2 指针和动态内存20

1.2.3 const的多种用法24

1.2.4 引用24

1.2.5 异常25

1.2.6 类型推断26

1.3 作为面向对象语言的C+++27

1.3.1 定义类27

1.3.2 使用类29

1.4 统一初始化29

1.5 标准库31

1.6 第一个有用的C+++程序31

1.6.1 雇员记录系统32

1.6.2 Employee类32

1.6.3 Database类34

1.6.4 用户界面36

1.6.5 评估程序38

1.7 本章小结38

第2章 使用string和string_view39

2.1 动态字符串39

2.1.1 C风格的字符串39

2.1.2 字符串字面量41

2.1.3 C++++std::string类42

2.1.4 std::string_view类46

2.1.5 非标准字符串47

2.2 本章小结47

第3章 编码风格48

3.1 良好外观的重要性48

3.1.1 事先考虑48

3.1.2 良好风格的元素49

3.2 为代码编写文档49

3.2.1 使用注释的原因49

3.2.2 注释的风格52

3.3 分解55

3.3.1 通过重构分解56

3.3.2 通过设计来分解56

3.3.3 本书中的分解56

3.4 命名56

3.4.1 选择恰当的名称57

3.4.2 命名约定57

3.5 使用具有风格的语言特性59

3.5.1 使用常量59

3.5.2 使用引用代替指针59

3.5.3 使用自定义异常59

3.6 格式60

3.6.1 关于大括号对齐的争论60

3.6.2 关于空格和圆括号的争论61

3.6.3 空格和制表符61

3.7 风格的挑战61

3.8 本章小结62

第Ⅱ部分 专业的C+软件设计64

第4章 设计专业的C++程序64

4.1 程序设计概述64

4.2 程序设计的重要性65

4.3 C+++设计的特点66

4.4 C+++设计的两个原则67

4.4.1 抽象67

4.4.2 重用68

4.5 重用代码69

4.5.1 关于术语的说明69

4.5.2 决定是否重用代码70

4.5.3 重用代码的策略71

4.5.4 绑定第三方应用程序74

4.5.5 开放源代码库75

4.5.6 C++++标准库76

4.6 设计一个国际象棋程序76

4.6.1 需求76

4.6.2 设计步骤77

4.7 本章小结80

第5章 面向对象设计82

5.1 过程化的思考方式82

5.2 面向对象思想83

5.2.1 类83

5.2.2 组件83

5.2.3 属性83

5.2.4 行为84

5.2.5 综合考虑84

5.3 生活在对象世界里85

5.3.1 过度使用对象85

5.3.2 过于通用的对象85

5.4 对象之间的关系86

5.4.1 “有一个”关系86

5.4.2 “是一个”关系（继承）87

5.4.3 “有一个”与“是一个”的区别88

5.4.4 not-a关系90

5.4.5 层次结构91

5.4.6 多重继承91

5.4.7 混入类92

5.5 抽象93

5.5.1 接口与实现93

5.5.2 决定公开的接口93

5.5.3 设计成功的抽象94

5.6 本章小结95

第6章 设计可重用代码96

6.1 重用哲学96

6.2 如何设计可重用代码97

6.2.1 使用抽象97

6.2.2 构建理想的重用代码98

6.2.3 设计有用的接口102

6.2.4 SOLID原则106

6.3 本章小结106

第Ⅲ部分 专业的C+编码方法108

第7章 内存管理108

7.1 使用动态内存108

7.1.1 如何描绘内存109

7.1.2 分配和释放110

7.1.3 数组111

7.1.4 使用指针116

7.2 数组-指针的对偶性117

7.2.1 数组就是指针117

7.2.2 并非所有指针都是数组119

7.3 低级内存操作119

7.3.1 指针运算119

7.3.2 自定义内存管理120

7.3.3 垃圾回收120

7.3.4 对象池121

7.4 智能指针121

7.4.1 unique_ptr122

7.4.2 shared_ptr124

7.4.3 weak_ptr125

7.4.4 移动语义126

7.4.5 enable_shared_from_this127

7.4.6 旧的、过时的／取消的auto_ptr127

7.5 常见的内存陷阱127

7.5.1 分配不足的字符串127

7.5.2 访问内存越界128

7.5.3 内存泄漏128

7.5.4 双重删除和无效指针131

7.6 本章小结131

第8章 熟悉类和对象132

8.1 电子表格示例介绍132

8.2 编写类133

8.2.1 类定义133

8.2.2 定义方法135

8.2.3 使用对象137

8.3 对象的生命周期138

8.3.1 创建对象138

8.3.2 销毁对象149

8.3.3 对象赋值149

8.3.4 编译器生成的复制构造函数和复制赋值运算符151

8.3.5 复制和赋值的区别151

8.4 本章小结153

第9章 精通类与对象154

9.1 友元154

9.2 对象的动态内存分配155

9.2.1 Spreadsheet类155

9.2.2 使用析构函数释放内存157

9.2.3 处理复制和赋值158

9.2.4 使用移动语义处理移动162

9.2.5 零规则167

9.3 与方法有关的更多内容167

9.3.1 静态方法167

9.3.2 const方法168

9.3.3 方法重载169

9.3.4 内联方法170

9.3.5 默认参数171

9.4 不同的数据成员类型172

9.4.1 静态数据成员172

9.4.2 静态常量数据成员173

9.4.3 引用数据成员174

9.4.4 常量引用数据成员175

9.5 嵌套类175

9.6 类内的枚举类型176

9.7 运算符重载177

9.7.1 示例：为SpreadsheetCell实现加法177

9.7.2 重载算术运算符179

9.7.3 重载比较运算符181

9.7.4 创建具有运算符重载的类型181

9.8 创建稳定的接口182

9.9 本章小结184

第10章 揭秘继承技术185

10.1 使用继承构建类185

10.1.1 扩展类186

10.1.2 重写方法188

10.2 使用继承重用代码194

10.2.1 WeatherPrediction类194

10.2.2 在派生类中添加功能195

10.2.3 在派生类中替换功能196

10.3 利用父类196

10.3.1 父类构造函数196

10.3.2 父类的析构函数197

10.3.3 使用父类方法198

10.3.4 向上转型和向下转型200

10.4 继承与多态性201

10.4.1 回到电子表格201

10.4.2 设计多态性的电子表格单元格201

10.4.3 SpreadsbeetCell基类202

10.4.4 独立的派生类203

10.4.5 利用多态性204

10.4.6 考虑将来205

10.5 多重继承206

10.5.1 从多个类继承206

10.5.2 名称冲突和歧义基类207

10.6 有趣而晦涩的继承问题209

10.6.1 修改重写方法的特征209

10.6.2 继承的构造函数211

10.6.3 重写方法时的特殊情况214

10.6.4 派生类中的复制构造函数和赋值运算符219

10.6.5 运行时类型工具220

10.6.6 非public继承221

10.6.7 虚基类221

10.7 本章小结222

第11章 理解灵活而奇特的C++223

11.1 引用223

11.1.1 引用变量224

11.1.2 引用数据成员225

11.1.3 引用参数225

11.1.4 将引用作为返回值226

11.1.5 右值引用226

11.1.6 使用引用还是指针227

11.2 关键字的疑问229

11.2.1 const关键字229

11.2.2 static关键字232

11.2.3 非局部变量的初始化顺序235

11.2.4 非局部变量的销毁顺序235

11.3 类型和类型转换235

11.3.1 类型别名235

11.3.2 函数指针的类型别名236

11.3.3 方法和数据成员的指针的类型别名238

11.3.4 typedef238

11.3.5 类型转换239

11.4 作用域解析242

11.5 特性243

11.5.1 ［［noreturn］］特性243

11.5.2 ［［deprecated］］特性244

11.5.3 ［［fallthrough］］特性244

11.5.4 ［［nodiscard］］特性244

11.5.5 ［［maybe_unused］］特性244

11.5.6 供应商专用特性245

11.6 用户定义的字面量245

11.7 头文件246

11.8 C的实用工具247

11.8.1 变长参数列表247

11.8.2 预处理器宏249

11.9 本章小结250

第12章 利用模板编写泛型代码251

12.1 模板概述252

12.2 类模板252

12.2.1 编写类模板252

12.2.2 尖括号258

12.2.3 编译器处理模板的原理258

12.2.4 将模板代码分布在多个文件中258

12.2.5 模板参数260

12.2.6 方法模板263

12.2.7 类模板的特例化266

12.2.8 从类模板派生267

12.2.9 继承还是特例化268

12.2.10 模板别名268

12.3 函数模板269

12.3.1 函数模板的特例化270

12.3.2 函数模板的重载271

12.3.3 类模板的友元函数模板271

12.3.4 对模板参数推导的更多介绍272

12.3.5 函数模板的返回类型272

12.4 可变模板274

12.5 本章小结274

第13章 C++ I/O揭秘275

13.1 使用流275

13.1.1 流的含义276

13.1.2 流的来源和目的地276

13.1.3 流式输出277

13.1.4 流式输入280

13.1.5 对象的输入输出285

13.2 字符串流286

13.3 文件流287

13.3.1 文本模式与二进制模式287

13.3.2 通过seek（）和tell（）在文件中转移288

13.3.3 将流链接在一起289

13.4 双向I/O290

13.5 本章小结291

第14章 错误处理292

14.1 错误与异常292

14.1.1 异常的含义292

14.1.2 C++++中异常的优点293

14.1.3 我们的建议294

14.2 异常机制294

14.2.1 抛出和捕获异常295

14.2.2 异常类型296

14.2.3 按const和引用捕获异常对象297

14.2.4 抛出并捕获多个异常297

14.2.5 未捕获的异常299

14.2.6 noexcept300

14.2.7 抛出列表（已不赞成使用／已删除）300

14.3 异常与多态性301

14.3.1 标准异常体系301

14.3.2 在类层次结构中捕获异常302

14.3.3 编写自己的异常类303

14.3.4 嵌套异常305

14.4 重新抛出异常306

14.5 堆栈的释放与清理307

14.5.1 使用智能指针308

14.5.2 捕获、清理并重新抛出309

14.6 常见的错误处理问题309

14.6.1 内存分配错误309

14.6.2 构造函数中的错误311

14.6.3 构造函数的function-try-blocks312

14.6.4 析构函数中的错误314

14.7 综合应用315

14.8 本章小结318

第15章 C++运算符重载319

15.1 运算符重载概述319

15.1.1 重载运算符的原因320

15.1.2 运算符重载的限制320

15.1.3 运算符重载的选择320

15.1.4 不应重载的运算符322

15.1.5 可重载运算符小结322

15.1.6 右值引用324

15.1.7 关系运算符325

15.2 重载算术运算符325

15.2.1 重载一元负号和一元正号运算符325

15.2.2 重载递增和递减运算符326

15.3 重载按位运算符和二元逻辑运算符327

15.4 重载插入运算符和提取运算符327

15.5 重载下标运算符328

15.5.1 通过operator［］提供只读访问330

15.5.2 非整数数组索引330

15.6 重载函数调用运算符331

15.7 重载解除引用运算符332

15.7.1 实现operator333

15.7.2 实现operator-＞333

15.7.3 operator.*和operator-＞*的含义334

15.8 编写转换运算符334

15.8.1 使用显式转换运算符解决多义性问题335

15.8.2 用于布尔表达式的转换335

15.9 重载内存分配和内存释放运算符337

15.9.1 new和delete的工作原理337

15.9.2 重载operator new和operator delete338

15.9.3 显式地删除／默认化operator new和operator delete340

15.9.4 重载带有额外参数的operator new和operator delete340

15.9.5 重载带有内存大小参数的operator delete340

15.10 本章小结341

第16章 C++标准库概述342

16.1 编码原则343

16.1.1 使用模板343

16.1.2 使用运算符重载343

16.2 C+++标准库概述343

16.2.1 字符串343

16.2.2 正则表达式344

16.2.3 I/O流344

16.2.4 智能指针344

16.2.5 异常344

16.2.6 数学工具344

16.2.7 时间工具345

16.2.8 随机数345

16.2.9 初始化列表345

16.2.10 pair和tuple345

16.2.11 optional、variant和any345

16.2.12 函数对象346

16.2.13 文件系统346

16.2.14 多线程346

16.2.15 类型特质346

16.2.16 标准整数类型346

16.2.17 容器346

16.2.18 算法351

16.2.19 标准库中还缺什么358

16.3 本章小结358

第17章 理解容器与迭代器359

17.1 容器概述359

17.1.1 对元素的要求360

17.1.2 异常和错误检查361

17.1.3 迭代器361

17.2 顺序容器363

17.2.1 vector363

17.2.2 vector＜bool＞特化376

17.2.3 deque377

17.2.4 list377

17.2.5 forward_list380

17.2.6 array381

17.3 容器适配器382

17.3.1 queue382

17.3.2 priority_queue384

17.3.3 stack386

17.4 有序关联容器387

17.4.1 pair工具类387

17.4.2 map388

17.4.3 multimap393

17.4.4 set396

17.4.5 multiset397

17.5 无序关联容器／哈希表397

17.5.1 哈希函数397

17.5.2 unordered_map399

17.5.3 unordered_multimap401

17.5.4 unordered_set/unordered_multiset402

17.6 其他容器402

17.6.1 标准C风格数组402

17.6.2 string403

17.6.3 流403

17.6.4 bitset403

17.7 本章小结407

第18章 掌握标准库算法408

18.1 算法概述408

18.1.1 find（）和find_if（）算法409

18.1.2 accumulate（）算法410

18.1.3 在算法中使用移动语义411

18.2 std::function411

18.3 lambda表达式413

18.3.1 语法413

18.3.2 泛型lambda表达式415

18.3.3 lambda捕捉表达式415

18.3.4 将lambda表达式用作返回类型415

18.3.5 将lambda表达式用作参数416

18.3.6 标准库算法示例416

18.4 函数对象417

18.4.1 算术函数对象417

18.4.2 比较函数对象418

18.4.3 逻辑函数对象419

18.4.4 按位函数对象419

18.4.5 函数对象适配器419

18.4.6 std::invoke（）422

18.4.7 编写自己的函数对象423

18.5 算法详解423

18.5.1 迭代器424

18.5.2 非修改序列算法424

18.5.3 修改序列算法427

18.5.4 操作算法433

18.5.5 交换算法434

18.5.6 分区算法435

18.5.7 排序算法436

18.5.8 二叉树搜索算法436

18.5.9 集合算法437

18.5.10 最大／最小算法439

18.5.11 并行算法440

18.5.12 数值处理算法440

18.6 算法示例：审核选民登记442

18.6.1 选民登记审核问题描述442

18.6.2 audit VoterRolls（）函数442

18.6.3 getDuplicates（）函数443

18.6.4 测试auditVoterRolls（）函数443

18.7 本章小结444

第19章 字符串的本地化与正则表达式445

19.1 本地化445

19.1.1 本地化字符串字面量445

19.1.2 宽字符446

19.1.3 非西方字符集446

19.1.4 转换447

19.1.5 locale和facet448

19.2 正则表达式450

19.2.1 ECMAScript语法451

19.2.2 regex库455

19.2.3 regex_match（）456

19.2.4 regex_search（）458

19.2.5 regex_iterator458

19.2.6 regex_token_iterator459

19.2.7 regex_replace（）461

19.3 本章小结462

第20章 其他库工具463

20.1 ratio库463

20.2 chrono库465

20.2.1 持续时间465

20.2.2 时钟468

20.2.3 时点469

20.3 生成随机数470

20.3.1 随机数引擎471

20.3.2 随机数引擎适配器472

20.3.3 预定义的随机数引擎和引擎适配器472

20.3.4 生成随机数473

20.3.5 随机数分布474

20.4 optional476

20.5 variant477

20.6 any478

20.7 元组479

20.7.1 分解元组481

20.7.2 串联481

20.7.3 比较482

20.7.4 make_from_tuple（）482

20.7.5 apply（）483

20.8 文件系统支持库483

20.8.1 path483

20.8.2 directory_entry484

20.8.3 辅助函数484

20.8.4 目录迭代484

20.9 本章小结485

第Ⅳ部分 掌握C+的高级特性488

第21章 自定义和扩展标准库488

21.1 分配器488

21.2 流适配器489

21.2.1 输出流迭代器489

21.2.2 输入流迭代器490

21.3 迭代器适配器490

21.3.1 反向迭代器490

21.3.2 插入迭代器491

21.3.3 移动迭代器492

21.4 扩展标准库493

21.4.1 扩展标准库的原因493

21.4.2 编写标准库算法493

21.4.3 编写标准库容器495

21.5 本章小结519

第22章 高级模板520

22.1 深入了解模板参数520

22.1.1 深入了解模板类型参数520

22.1.2 template template参数介绍522

22.1.3 深入了解非类型模板参数524

22.2 模板类部分特例化525

22.3 通过重载模拟函数部分特例化527

22.4 模板递归528

22.4.1 N维网格：初次尝试529

22.4.2 真正的N维网格529

22.5 可变参数模板531

22.5.1 类型安全的变长参数列表532

22.5.2 可变数目的混入类533

22.5.3 折叠表达式534

22.6 模板元编程535

22.6.1 编译时阶乘536

22.6.2 循环展开536

22.6.3 打印元组537

22.6.4 类型trait539

22.6.5 模板元编程结论545

22.7 本章小结545

第23章 C++多线程编程546

23.1 多线程编程概述547

23.1.1 争用条件548

23.1.2 撕裂549

23.1.3 死锁549

23.1.4 伪共享550

23.2 线程550

23.2.1 通过函数指针创建线程550

23.2.2 通过函数对象创建线程551

23.2.3 通过lambda创建线程552

23.2.4 通过成员函数创建线程553

23.2.5 线程本地存储553

23.2.6 取消线程553

23.2.7 从线程获得结果553

23.2.8 复制和重新抛出异常554

23.3 原子操作库555

23.3.1 原子类型示例556

23.3.2 原子操作557

23.4 互斥558

23.4.1 互斥体类558

23.4.2 锁560

23.4.3 std::call_once561

23.4.4 互斥体对象的用法示例562

23.5 条件变量565

23.5.1 假唤醒565

23.5.2 使用条件变量565

23.6 future566

23.6.1 std::promise和std::future567

23.6.2 std::packaged_task567

23.6.3 std::async568

23.6.4 异常处理568

23.6.5 std::shared_future569

23.7 示例：多线程的Logger类570

23.8 线程池573

23.9 线程设计和最佳实践573

23.10 本章小结574

第Ⅴ部分 C+软件工程576

第24章 充分利用软件工程方法576

24.1 过程的必要性576

24.2 软件生命周期模型577

24.2.1 瀑布模型577

24.2.2 生鱼片模型578

24.2.3 螺旋类模型579

24.2.4 敏捷581

24.3 软件工程方法论581

24.3.1 UP581

24.3.2 RUP582

24.3.3 Scrum583

24.3.4 极限编程584

24.3.5 软件分流587

24.4 构建自己的过程和方法588

24.4.1 对新思想采取开放态度588

24.4.2 提出新想法588

24.4.3 知道什么行得通、什么行不通588

24.4.4 不要逃避588

24.5 源代码控制588

24.6 本章小结590

第25章 编写高效的C++程序591

25.1 性能和效率概述591

25.1.1 提升效率的两种方式592

25.1.2 两种程序592

25.1.3 C++++是不是低效的语言592

25.2 语言层次的效率592

25.2.1 高效地操纵对象593

25.2.2 预分配内存596

25.2.3 使用内联方法和函数596

25.3 设计层次的效率596

25.3.1 尽可能多地缓存596

25.3.2 使用对象池597

25.4 剖析599

25.4.1 使用gprof的剖析示例600

25.4.2 使用Visual C++++ 2017的剖析示例605

25.5 本章小结608

第26章 熟练掌握测试技术609

26.1 质量控制609

26.1.1 谁负责测试610

26.1.2 bug的生命周期610

26.1.3 bug跟踪工具611

26.2 单元测试612

26.2.1 单元测试方法613

26.2.2 单元测试过程613

26.2.3 实际中的单元测试616

26.3 高级测试622

23.3.1 集成测试622

26.3.2 系统测试623

26.3.3 回归测试623

26.4 用于成功测试的建议624

26.5 本章小结624

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

27.1 调试的基本定律625

27.2 bug分类学626

27.3 避免bug626

27.4 为bug做好规划626

27.4.1 错误日志626

27.4.2 调试跟踪627

27.4.3 断言633

27.4.4 崩溃转储633

27.5 静态断言634

27.6 调试技术634

27.6.1 重现bug635

27.6.2 调试可重复的bug635

27.6.3 调试不可重现的bug635

27.6.4 调试退化636

27.6.5 调试内存问题636

27.6.6 调试多线程程序640

27.6.7 调试示例：文章引用640

27.6.8 从ArticleCitations示例中总结出的教训648

27.7 本章小结649

第28章 使用设计技术和框架650

28.1 容易忘记的语法651

28.1.1 编写类651

28.1.2 派生类652

28.1.3 使用“复制和交换”惯用语法652

28.1.4 抛出和捕捉异常653

28.1.5 读取文件654

28.1.6 写入文件654

28.1.7 写入模板类654

28.2 始终存在更好的方法655

28.2.1 RAII655

28.2.2 双分派657

28.2.3 混入类660

28.3 面向对象的框架662

28.3.1 使用框架662

28.3.2 MVC范型662

28.4 本章小结663

第29章 应用设计模式664

29.1 迭代器模式665

29.2 单例模式665

29.2.1 日志记录机制665

29.2.2 实现单例666

29.2.3 使用单例668

29.3 抽象工厂模式668

29.3.1 示例：模拟汽车工厂669

29.3.2 实现工厂670

29.3.3 使用工厂671

29.3.4 工厂的其他用法672

29.4 代理模式672

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

29.4.2 实现代理673

29.4.3 使用代理674

29.5 适配器模式674

29.5.1 示例：改编Logger类674

29.5.2 实现适配器675

29.5.3 使用适配器675

29.6 装饰器模式675

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

29.6.2 装饰器的实现676

29.6.3 使用装饰器677

29.7 责任链模式677

29.7.1 示例：事件处理678

29.7.2 实现责任链678

29.7.3 没有层次结构的责任链679

29.8 观察者模式680

29.8.1 实现观察者680

29.8.2 实现可观察类681

29.8.3 使用观察者681

29.9 本章小结682

第30章 开发跨平台和跨语言应用程序683

30.1 跨平台开发683

30.1.1 架构问题683

30.1.2 实现问题686

30.1.3 平台专用功能686

30.2 跨语言开发687

30.2.1 混用C和C++++687

30.2.2 改变范型688

30.2.3 链接C代码690

30.2.4 从C＃调用C++++代码691

30.2.5 在Java中使用JNI调用C++++代码692

30.2.6 从C++++代码调用脚本694

30.2.7 从脚本调用C++++代码694

30.2.8 从C++++调用汇编代码696

30.3 本章小结696

附录A C++面试697

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

附录C 标准库头文件721

附录D UML简介726