C++面向对象开发 原书第2版PDF格式文档图书下载

第1章 信息管理的困境 1

1.1 问题的提出 1

1.2 什么是客户想要的 3

1.3 为什么面向对象对开发者是重要的 4

1.4 小结 5

第2章 管理复杂性：分析和设计 6

2.1 抽象机制 7

2.1.1 函数 7

2.1.2 模块 8

2.1.3 抽象数据类型 9

2.2 类／对象 9

2.2.1 消息传递 9

2.2.2 泛化／特化和多态 10

2.3 其他的关系 10

2.3.1 关联 10

2.3.2 聚合 12

2.4 行为 12

2.4.1 静态行为 13

2.4.2 动态行为 13

2.5 规则 15

2.6 复杂系统 16

2.7 小结 16

第3章 面向对象的编程 18

3.1 什么是面向对象的编程 18

3.1.1 不是银弹 18

3.1.2 一种高级的范型 18

3.2 基本的面向对象编程概念 19

3.3 面向对象编程语言 22

3.3.1 基于对象的编程 22

3.3.2 基于类的编程 22

3.3.3 面向对象的编程 23

3.3.4 高级面向对象的编程 23

3.3.5 前沿面向对象的编程 23

3.4 为什么选C++ 23

3.5 组织现实的方式 24

3.6 计算的模拟模型 25

3.7 组织现实的面向对象方式 26

3.8 小结 30

第4章 限定问题域 32

4.1 用况介绍 32

4.1.1 系统 33

4.1.2 参与者 33

4.1.3 用况 34

4.1.4 用况包 38

4.2 建立用况文档 39

4.2.1 用况图 39

4.2.2 顺序图：建立细节文档 41

4.2.3 文本描述 41

4.3 开发用况的准则 42

4.3.1 避免分析瘫痪 42

4.3.2 识别参与者 43

4.3.3 识别高层用况和本质用况 44

4.3.4 建立用况包 45

4.3.5 开发用况细节 46

4.3.6 识别支持用况 47

4.3.7 开发边界用况 48

4.4 契约 48

4.5 推荐的方法 49

4.6 小结 56

第5章 寻找对象 57

5.1 面向对象的分析：应用域的模型 57

5.2 构造面向对象模型 58

5.3 识别对象 58

5.4 目前的技术 60

5.4.1 使用将被建模的事物 60

5.4.2 使用对象和类的定义 60

5.4.3 使用对象分解 61

5.4.4 使用概括 61

5.4.5 使用子类 61

5.4.6 使用面向对象的领域分析 62

5.4.7 复用应用框架 62

5.4.8 复用类层次 62

5.4.9 复用个体对象和类 63

5.4.10 使用子部件 63

5.4.11 使用个人经验 63

5.5 传统的技术 64

5.5.1 使用名词 64

5.5.2 使用传统的数据流图 65

5.5.3 使用类－责任－协作（CRC）卡片 66

5.6 推荐的方法 67

5.7 小结 69

第6章 识别责任 71

6.1 什么是对象 71

6.2 什么是属性 72

6.2.1 描述性属性 72

6.2.2 命名属性 72

6.3 什么是服务 73

6.4 什么是方法 73

6.5 识别属性 73

6.6 描述属性 75

6.7 识别服务 76

6.8 描述服务 77

6.9 推荐的方法 77

6.10 小结 80

第7章 描述静态行为 81

7.1 什么是行为 81

7.2 描述静态行为的技术 82

7.3 描述控制的技术 83

7.4 建立控制文档的技术 84

7.4.1 活动图 84

7.4.2 协作图 85

7.4.3 顺序图 86

7.5 建立静态行为文档的技术 86

7.5.1 前置条件和后置条件 86

7.5.2 流程图 86

7.5.3 数据流图 87

7.5.4 结构化英语 87

7.6 推荐的方法 88

7.7 小结 92

第8章 动态行为 93

8.1 介绍 93

8.2 识别动态行为的技术 94

8.2.1 一般的生存周期形式 95

8.2.2 捕获生存周期的模型 96

8.3 识别事件和描述事件 97

8.3.1 用况和场景 97

8.3.2 顺序图 98

8.3.3 例子 98

8.4 描述动态行为 102

8.4.1 事件列表 102

8.4.2 状态转换表 103

8.5 建立动态行为的文档 106

8.6 推荐的方法 111

8.7 小结 111

第9章 识别关系 112

9.1 访问另一个对象的服务 112

9.2 关系 112

9.3 泛化 113

9.4 识别并描述泛化／特化 115

9.5 对象聚合 116

9.6 聚合的分类 117

9.6.1 组装－部分（整体－成分组合） 118

9.6.2 材料－对象组合 118

9.6.3 划分－对象组合 119

9.6.4 位置－区域组合 119

9.6.5 集合－成员组合 120

9.6.6 容器－容物（成员－束组合） 120

9.6.7 成员－合作组合 121

9.6.8 对象和聚合关系 121

9.7 对象之间的链 121

9.8 识别并描述链和聚合 123

9.9 管理关系 124

9.10 建立关系的文档 125

9.11 推荐的方法 126

9.12 小结 128

第10章 规则 129

10.1 介绍 129

10.2 规则 130

10.3 识别说明性描述 130

10.4 描述规则和建立规则文档 131

10.5 将规则映射为正确的OO概念 133

10.6 使用UML建立规则的文档 133

10.7 实现规则 134

10.8 推荐的方法 135

10.9 小结 135

第11章 模型 137

11.1 概念 137

11.2 概念和面向对象模型 138

11.2.1 类 138

11.2.2 关联 139

11.2.3 类聚合 139

11.2.4 泛化／特化 139

11.2.5 多态 140

11.2.6 实例化 141

11.3 使用UML建立概念的文档 141

11.3.1 类概念 141

11.3.2 关联 142

11.3.3 类聚合 143

11.3.4 泛化／特化 143

11.3.5 多态 144

11.3.6 实例化 144

11.4 精化模型 144

11.5 子系统 144

11.5.1 问题域 145

11.5.2 桥 145

11.6 组织子系统 146

11.6.1 横向分层 146

11.6.2 纵向划分 146

11.6.3 组合 146

11.7 识别子系统 147

11.8 建立子系统文档 147

11.9 推荐的方法 147

11.9.1 例子 148

11.9.2 精化 148

11.9.3 子系统 153

11.10 小结 154

第12章 设计 155

12.1 介绍 155

12.2 系统设计 156

12.2.1 子系统 156

12.2.2 体系结构框架 157

12.2.3 建立系统设计文档 158

12.3 详细设计 160

12.3.1 设计类 160

12.3.2 设计关联 161

12.3.3 泛化和继承 162

12.3.4 委托 163

12.3.5 Orlando条约 163

12.3.6 多继承 164

12.3.7 建立详细设计文档 166

12.4 小结 166

第13章 C++基础 167

13.1 历史 167

13.2 编程元素 168

13.2.1 关键字 168

13.2.2 标识符 169

13.2.3 字面值 169

13.2.4 运算符 169

13.2.5 标点 170

13.3 固有数据类型 170

13.3.1 基本数据类型 171

13.3.2 常量值 171

13.3.3 符号变量 172

13.3.4 指针类型 172

13.3.5 常量类型 173

13.3.6 引用类型 173

13.3.7 枚举类型 174

13.3.8 数组类型 174

13.3.9 typedef定义的类型名 174

13.4 什么是语句 175

13.4.1 表达式 175

13.4.2 复合语句 175

13.5 语句流控制 176

13.5.1 if语句 176

13.5.2 for语句 176

13.6 什么是函数 177

13.7 函数调用 178

13.7.1 函数定义 178

13.7.2 函数原型 179

13.7.3 内联 179

13.8 存储类 179

13.8.1 auto 180

13.8.2 extern 180

13.8.3 register 180

13.8.4 static 180

13.8.5 volatile 181

13.9 类型转换 181

13.9.1 static_cast 181

13.9.2 const_cast 182

13.9.3 dynamic_cast 182

13.9.4 reinterpret_cast 182

13.10 名字空间 183

13.11 推荐的方法 183

13.12 小结 184

第14章 类的实现 185

14.1 类的组成部分 185

14.2 类定义 185

14.3 类的体 186

14.3.1 可见性 186

14.3.2 数据成员 186

14.3.3 成员函数 187

14.4 使用继承的泛化 188

14.5 推荐的方法 189

14.6 小结 191

第15章 C++库 192

15.1 C标准库 192

15.1.1 <cassert> 193

15.1.2 <cctype> 193

15.1.3 <cerrno> 193

15.1.4 <cfloat> 193

15.1.5 <ciso646> 193

15.1.6 <climits> 193

15.1.7 <clocale> 193

15.1.8 <cmath> 193

15.1.9 <csetjmp> 193

15.1.10 <csignal> 193

15.1.11 <cstdarg> 194

15.1.12 <cstddef> 194

15.1.13 <cstdio> 194

15.1.14 <cstdlib> 194

15.1.15 <cstring> 194

15.1.16 <ctime> 195

15.1.17 <cwchar> 195

15.1.18 <cwctype> 195

15.2 C++类库 195

15.2.1 <bits> 195

15.2.2 <bitstring> 195

15.2.3 <complex> 195

15.2.4 <defineS> 196

15.2.5 <dynarray> 196

15.2.6 <exceptions> 196

15.2.7 <fstream> 196

15.2.8 <iomanip> 196

15.2.9 <ios> 196

15.2.10 <iostream> 196

15.2.11 <istream> 198

15.2.12 <new> 198

15.2.13 <ostream> 198

15.2.14 <ptrdynarry> 198

15.2.15 <sstream> 198

15.2.16 <streambuf> 198

15.2.17 <string> 198

15.2.18 <strstream> 199

15.2.19 <typeinfo> 199

15.2.20 <wstring> 199

15.3 标准模板库 199

15.3.1 <algorithm> 200

15.3.2 <bitset> 200

15.3.3 <complex> 200

15.3.4 <deque> 200

15.3.5 <functional> 200

15.3.6 <iterator> 200

15.3.7 <list> 201

15.3.8 <map> 201

15.3.9 <memory> 205

15.3.10 <numerics> 205

15.3.11 <queue> 205

15.3.12 <set> 205

15.3.13 <stack> 207

15.3.14 <utility> 207

15.3.15 <valarray> 207

15.3.16 <vector> 207

15.4 推荐的方法 207

15.5 小结 207

第16章 实现静态行为 208

16.1 函数定义 208

16.1.1 返回类型 209

16.1.2 返回语句 209

16.1.3 函数参数表 210

16.2 传递参数 211

16.2.1 按值传递 211

16.2.2 引用或指针参数 212

16.3 返回类型为引用或指针 214

16.4 类型转换 215

16.5 常量和缺省 215

16.5.1 常量 215

16.5.2 缺省初始化程序 217

16.6 标识符作用域 217

16.7 推荐的方法 218

16.7.1 在h文件中定义 218

16.7.2 在C文件中定义 219

16.8 小结 220

第17章 实现动态行为 221

17.1 动态行为的元素 221

17.1.1 简单状态图 222

17.1.2 嵌套状态图 227

17.1.3 并发状态图 231

17.2 推荐的方法 232

17.3 小结 232

第18章 实例化和删除对象 233

18.1 介绍 233

18.2 构造器 233

18.3 析构器 235

18.4 正确地使用构造器和析构器 238

18.5 泛化和构造器 239

18.6 推荐的方法 239

18.6.1 创建对象 239

18.6.2 销毁对象 240

18.7 编码准则 241

18.7.1 构造器编码准则 241

18.7.2 析构器编码准则 242

18.8 小结 242

第19章 实现泛化／特化 243

19.1 继承 243

19.1.1 说明派生类 243

19.1.2 从派生类中继承和实现关联 245

19.1.3 增加多态 246

19.1.4 抽象类 248

19.2 多继承 250

19.3 虚析构器 255

19.4 派生类的可见性 256

19.5 小结 256

第20章 实现更多的关系 258

20.1 介绍 258

20.1.1 实现关联 258

20.1.2 实现关联的属性 259

20.1.3 实现聚合 259

20.2 指针 259

20.3 数组 260

20.4 友元 262

20.5 静态成员 262

20.6 实现关联 263

20.6.1 二元关联 263

20.6.2 多对一关联 264

20.6.3 多对多关联 266

20.7 实现友元 267

20.7.1 类作为友元 267

20.7.2 函数作为友元 267

20.7.3 用友元实现一对多关联 268

20.8 实现聚合 269

20.8.1 埋入指针 269

20.8.2 嵌入对象 270

20.9 实现静态成员 270

20.10 推荐的方法 272

20.11 小结 272

第21章 案例分析介绍 274

21.1 案例分析1：突围 274

21.1.1 需求 274

21.1.2 获取领域知识 275

21.1.3 专家的知识 276

21.1.4 所提供的技术服务 277

21.2 案例分析2：微波炉 280

21.2.1 问题定义 280

21.2.2 一般描述 280

第22章 案例分析：突围游戏 281

22.1 步骤1：发现对象 281

22.2 步骤2：识别责任 282

22.2.1 寻找形容词 282

22.2.2 问题1 282

22.2.3 问题2 287

22.2.4 问题3 290

22.2.5 寻找服务 292

22.3 步骤3：描述行为 294

22.4 步骤4：描述关系 302

22.5 步骤5：精化 307

22.6 步骤6：设计 322

22.7 步骤7：实现 329

22.7.1 实现类 329

22.7.2 实现静态行为 340

22.7.3 对象实例化 342

22.7.4 实现继承 345

22.7.5 实现关系 362

第23章 案例分析：微波炉 370

23.1 用况 370

23.1.1 用况1：无中断的烹饪 371

23.1.2 用况2：取消烹饪 372

23.1.3 用况3：中断烹饪 373

23.2 解决方案1：设计控制器类 374

23.2.1 步骤1：发现对象 374

23.2.2 步骤2：识别责任 375

23.2.3 步骤3：描述行为 377

23.2.4 步骤4：描述关系 379

23.2.5 步骤5：精化 381

23.2.6 讨论 381

23.3 解决方案2：具有高耦合的责任分配 381

23.3.1 步骤1：识别对象 381

23.3.2 步骤2：识别责任 382

23.3.3 步骤3：描述行为 383

23.3.4 步骤4：描述关系 385

23.3.5 步骤5：精化 385

23.3.6 讨论 387

23.4 解决方案3：使用观察者机制分配责任 387

23.4.1 步骤5：精化 388

23.4.2 论讨 397

附录A 统一建模语言 398

参考文献 420

致谢 423

索引 427

查看更多关于C++面向对象开发 原书第2版的内容