好书推荐 好书速递 排行榜 读书文摘

C++高级编程

C++高级编程
作者:(比)格莱戈尔(Gregoire, M.) / (美)索尔特(Solter, N.A.) / (美)凯乐普(Kleper, S.J.)著
译者:侯普秀 / 郑思遥
副标题:第2版
出版社:清华大学出版社
出版年:2012-10
ISBN:9787302298977
行业:计算机
浏览数:11

内容简介

精通c++语言最新版本:c++11

c++是当今最流行的高级程序设计语言之一,常用于编写性能卓越的企业级面向对象程序,如游戏或大型商业软件。但一个无法规避的事实是:c++语法纷繁复杂,学习难度较大。如何才能化繁为简,全面系统地快速掌握c++知识呢? c++高级编程(第2版) 将为您提供完美答案。这本权威书籍在大量实例的引导下,解密c++中鲜为人知的特性,揭示最新版本c++11带来的显著变化,并探讨有助于提高代码质量和编程效率的编程方法、可重用设计模式和良好编程风格。通过阅读本书,您将能得心应手地开发出优秀的c++11程序。

主要内容

提供详尽的代码范例,读者可随手在自己的代码中使用这些代码

全面介绍c++和stl技术,包括该语言不寻常和怪异的方面

展示应用c++语言高级特性的最佳实践,包括操作符重载、内存管理、制作模板和编写多线程代码

讨论编写跨语言和跨平台代码的技术

讲述代码重用的重要性以及编写易读c++代码的微妙之处

......(更多)

作者简介

作 者 简 介

Marc Gregoire是一名软件工程师。他毕业于比利时鲁文的天主教大学业,获得计算机科学工程硕士学位。之后,他在该大学获得人工智能的优等硕士学位。完成学业后,他开始为大型软件咨询公司Ordina Belgium工作。他曾在Siemens 和Nokia Siemens Networks为大型电信运营商提供有关在Solaris上运行关键2G和3G软件的咨询服务。这份工作要求与来自南美、美国、欧洲、中东、非洲和亚洲的国际团队合作。Marc目前在Nikon Metrology任职,负责开发3D扫描软件。他的主要技术专长是C/C++,特别是Microsoft VC++和MFC框架。除了C/C++之外,Marc还喜欢C#,并且会用PHP创建网页。除了在Windows上开发的主要兴趣之外,他还擅长在Linux平台上开发24×7运行的C++程序;例如EIB家庭自动化监控软件。2007年4月,因为在Visual C++方面的专业才能他获得了年度Microsoft MVP称号。Marc还是CodeGuru论坛的活跃分子(id为Marc G),并且为CodeGuru撰写了一些文章和FAQ条目。他还编写了一些自由软件和共享软件,并通过他的网站www.nuonsoft.com发布。他还在www.nuonsoft.com/blog/维护了一个博客。

Nicholas A. Solter是一名计算机程序员,开发的软件范围很广,包括系统软件、游戏、网络服务和其他很多类型。他在Sun Microsystem的高可用集群上所做的工作获得了3项专利,还就此在国际并行和分布式处理会议上发表了一篇技术论文。在Sun的时候,他还喜欢参与OpenSolaris,他还是OpenSolaris Bible (Wiley, 2009)的第一作者。现在重新从事Web开发,他很开心地再次和Scott一起在Context Optional工作。

Nick在斯坦福大学学习计算机科学,他在这所大学获得了本科和理科硕士学位,他的主要研究领域是计算机系统。他曾在富勒顿社区大学讲授了一年的C++课程。

Nick和他的妻子和两个孩子生活在美丽的科罗拉多,他在科罗拉多享受着雪上运动的乐趣。

Scott J. Klerper在小学就开始了他的编程生涯,那时他在Tandy TRS-80上用BASIC语言编写探险游戏。作为他所在高中的Mac迷,Scott转向了更高级的语言,并且发布了一些屡获殊荣的共享软件。

Scott加入了斯坦福大学,并且在这所大学获得了本科和计算机科学的理学硕士学位,主要研究领域是人机交互。在上大学的时候,Scott是一门涉及编程入门、面向对象设计、数据结构、GUI框架和小组项目的课程的助教。他之后在斯坦福的一门课程采用这本书作为课本。

毕业后,Scott是几家公司创始团队中的首席工程师。2006年,Scott与他人合伙创建了Context Optional, Inc.,这是一家提供社会营销技术的市场领先的供应商。

在工作之余,Scott还热衷于在线购物、阅读和弹吉他。

......(更多)

目录

《c++高级编程(第2版)》

第ⅰ部分 专业的c++简介

第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 typedef 254

9.3.2 函数指针typedef 255

9.3.3 类型别名(仅限c++11) 256

9.3.4 类型转换 257

9.4 作用域解析 261

9.5 c++11 262

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-blocks 306

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 vector 342

12.2.2 vector[bool]特化 359

12.2.3 deque 359

12.2.4 list 360

12.2.5 array(仅限c++11) 364

12.2.6 forward_list(仅限c++11) 364

12.3 容器适配器 366

12.3.1 queue 366

12.3.2 priority_queue 369

12.3.3 stack 372

12.4 关联容器 373

12.4.1 pair工具类 373

12.4.2 map 374

12.4.3 multimap 382

12.4.4 set 385

12.4.5 multiset 387

12.5 无序关联容器/哈希表(仅限c++11) 387

12.5.1 哈希函数 387

12.5.2 unordered_map 388

12.5.3 unordered_multimap 391

12.5.4 unordered_set/unordered_ multiset 391

12.6 其他容器 391

12.6.1 标准c风格数组 392

12.6.2 string 392

12.6.3 流 393

12.6.4 bitset 393

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和facet 455

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_iterator 468

14.3.6 regex_token_iterator 469

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/o 496

15.5 本章小结 497

第16章 其他库工具 499

16.1 std::function 499

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章 自定义和扩展stl 521

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 扩展stl 527

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 实现operator* 586

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 delete 595

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

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和decltype 653

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_ptr 688

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_once 723

22.4.4 互斥体的用法示例 724

22.5 条件变量 727

22.6 future 729

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

22.8 线程池 736

22.9 线程设计和最佳实践 737

22.10 本章小结 738

第ⅳ部分 c++软件工程

第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 scrum 748

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 避免bug 820

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 重现bug 835

27.5.2 调试可重复的bug 836

27.5.3 调试不可重现的bug 836

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

......(更多)

读书文摘

......(更多)

猜你喜欢

点击查看