C++沉思录PDF|Epub|txt|kindle电子书版本网盘下载

C++沉思录PDF格式电子书版下载

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

第0章 序幕1

0.1 第一次尝试1

0.1.1 改进2

0.1.2 另一种改进3

0.2 不用类来实现4

0.3 为什么用 C++更简单5

0.4 一个更大的例子6

0.5 结论6

第一篇 动机11

第1章 为什么我用 C++11

1.1 问题11

1.2 历史背景12

1.3 自动软件发布12

1.3.1 可靠性与通用性13

1.3.2 为什么用 C14

1.3.3 应付快速增长15

1.4 进入 C++15

1.5 重复利用的软件20

1.6 后记21

第2章 为什么用 C++工作23

2.1 小项目的成功23

2.1.1 开销24

2.1.2 质疑软件工厂24

2.2 抽象25

2.2.1 有些抽象不是语言的一部分26

2.2.2 抽象和规范26

2.2.3 抽象和内存管理27

2.3 机器应该为人服务28

第3章 生活在现实世界中29

第4章 类设计者的核查表37

第二篇 类和继承37

第5章 代理类47

5.1 问题47

5.2 经典解决方案48

5.3 虚复制函数49

5.4 定义代理类50

5.5 小结53

第6章 句柄：第一部分55

6.1 问题55

6.2 一个简单的类56

6.3 绑定到句柄58

6.4 获取对象58

6.5 简单的实现59

6.6 引用计数型句柄60

6.7 写时复制62

6.8 讨论63

第7章 句柄：第二部分67

7.1 回顾68

7.2 分离引用计数69

7.3 对引用计数的抽象70

7.4 存取函数和写时复制73

7.5 讨论73

第8章 一个面向对象程序范例75

8.1 问题描述75

8.2 面向对象的解决方案76

8.3 句柄类79

8.4 扩展1：新操作82

8.5 扩展2：增加新的节点类型85

8.6 反思86

第9章 一个课堂练习的分析(上)89

9.1 问题描述89

9.2 接口设计91

9.3 补遗93

9.4 测试接口94

9.5 策略95

9.6 方案96

9.7 图像的组合99

9.8 结论102

第10章 一个课堂练习的分析(下)103

10.1 策略103

10.1.1 方案104

10.1.2 内存分配105

10.1.3 结构构造107

10.1.4 显示图像110

10.2 体验设计的灵活性116

10.3 结论119

11.1 适用的情况121

第11章 什么时候不应当使用虚函数121

11.2 不适用的情况122

11.2.1 效率122

11.2.2 你想要什么样的行为125

11.2.3 不是所有的类都是通用的127

11.3 析构函数很特殊127

11.4 小结129

第三篇 模板133

第12章 设计容器类133

12.1 包含什么133

12.2 复制容器意味着什么134

12.3 怎样获取容器的元素137

12.4 怎样区分读和写138

12.5 怎样处理容器的增长139

12.6 容器支持哪些操作141

12.7 怎样设想容器元素的类型141

12.8 容器和继承143

12.9 设计一个类似数组的类144

第13章 访问容器中的元素151

13.1 模拟指针151

13.2 获取数据153

13.3 遗留问题155

13.4 指向 const Array 的 Pointer159

13.5 有用的增强操作161

第14章 迭代器167

14.1 完成 Pointer 类167

14.2 什么是迭代器170

14.3 删除元素171

14.4 删除容器172

14.5 其他设计考虑173

14.6 讨论174

15.1 技术状况175

第15章 序列175

15.2 基本的传统观点176

15.3 增加一些额外操作181

15.4 使用范例184

15.5 再增加一些188

15.6 请你思考190

第16章 作为接口的模板191

16.1 问题191

16.2 第一个例子192

16.3 分离迭代方式192

16.4 遍历任意类型195

16.5 增加其他类型196

16.6 将存储技术抽象化196

16.7 实证199

16.8 小结200

第17章 模板和泛型算法203

17.1 一个特例204

17.2 泛型化元素类型205

17.3 推迟计数205

17.4 地址独立性207

17.5 查找非数组208

17.6 讨论210

第18章 泛型迭代器213

18.1 一个不同的算法213

18.2 需求的分类215

18.3 输入迭代器216

18.4 输出迭代器216

18.5 前向迭代器217

18.6 双向迭代器218

18.7 随机存取迭代器218

18.9 性能220

18.8 是继承吗220

18.10 小结221

第19章 使用泛型迭代器223

19.1 迭代器类型224

19.2 虚拟序列224

19.3 输出流迭代器227

19.4 输入流迭代器229

19.5 讨论232

第20章 迭代器配接器233

20.1 一个例子233

20.2 方向不对称性235

20.3 一致性和不对称性236

20.4 自动反向237

20.5 讨论240

第21章 函数对象241

21.1 一个例子241

21.2 函数指针244

21.3 函数对象246

21.4 函数对象模板248

21.5 隐藏中间类型249

21.6 一种类型包罗万象250

21.7 实现251

21.8 讨论253

第22章 函数配接器255

22.1 为什么是函数对象255

22.2 用于内建操作符的函数对象256

22.3 绑定者(Binders)257

22.4 更深入地探讨258

22.5 接口继承259

22.6 使用这些类260

22.7 讨论261

23.1 问题265

第23章 日常使用的库265

第四篇 库265

23.2 理解问题：第1部分267

23.3 实现：第1部分267

23.4 理解问题：第2部分270

23.5 实现：第2部分270

23.6 讨论272

第24章 一个库接口设计实例275

24.1 复杂问题276

24.2 优化接口277

24.3 温故知新279

24.4 编写代码280

24.5 结论282

第25章 库设计就是语言设计283

25.1 字符串283

25.2 内存耗尽284

25.3 复制287

25.4 隐藏实现290

25.5 缺省构造函数292

25.6 其他操作293

25.7 子字符串295

25.8 结论296

第26章 语言设计就是库设计297

26.1 抽象数据类型297

26.1.1 构造函数与析构函数297

26.1.2 成员函数及可见度控制299

26.2 库和抽象数据类型299

26.2.1 类型安全的链接(linkage)299

26.2.2 命名空间300

26.3 内存分配302

26.4 按成员赋值(memberwise assignment)和初始化303

26.5 异常处理305

26.6 小结306

第五篇 技术309

第27章 自己跟踪自己的类309

27.1 设计一个跟踪类309

27.2 创建死代码312

27.3 生成对象的审计跟踪313

27.4 验证容器行为315

27.5 小结320

第28章 在簇中分配对象321

28.1 问题321

28.2 设计方案321

28.3 实现324

28.4 加入继承326

28.5 小结327

第29章 应用器、操纵器和函数对象329

29.1 问题329

29.3 另一种不同的解决方案332

29.2 一种解决方案332

29.4 多个参数334

29.5 一个例子335

29.6 简化337

29.7 思考338

29.8 历史记录、参考资料和致谢339

第30章 将应用程序库从输入输出中分离出来341

30.1 问题341

30.2 解决方案1：技巧加蛮力342

30.3 解决方案2：抽象输出343

30.4 解决方案3：技巧，但无蛮力345

30.5 评论348

第六篇 总结351

第31章 通过复杂性获取简单性351

31.1 世界是复杂的351

31.2 复杂性变得隐蔽352

31.3 计算机也是一样353

31.4 计算机解决实际问题354

31.5 类库和语言语义355

31.6 很难使事情变得容易357

31.7 抽象和接口357

31.8 复杂度的守恒358

第32章 说了 Hello world 后再做什么361

32.1 找当地的专家361

32.2 选一种工具包并适应它362

32.3 C 的某些部分是必需的362

32.4 C 的其他部分不是必需的364

32.5 给自己设一些问题366

32.6 结论368

附录 Koenig 和 Moo 夫妇访谈371

索引377