包邮闪发 高质量程序设计指南——C++/C语言(第3版)修订版 畅销书籍 高质量程序设计从入门到精通 计算机编程教程 程序设计教材书.

LT

有货

辽宁，吉林，黑龙江、甘肃、青海、新疆、内蒙古，宁夏西藏港澳台等偏远省份地区及海外地区暂不支持包邮，谢谢亲的支持和理解，以上地区拍下付款前请与卖家协商运费，再一次表示感激！ 地址偏远韵达和中通快递都不到者，要发EMS的亲，需要跟客服邮费事宜，未经擅自拍下者本店有权不发货。请顾客们看清楚再拍。谢谢谅解

目 录

第 1 章 高质量软件开发之道       1

1       1 软件质量基本概念              1

1       1       1 如何理解软件的质量       1

1       1       2 提高软件质量的基本方法                                                                                                         2

1       1       3 “零缺陷”理念                   4

1       2 细说软件质量属性              4

1       2       1 正确性                                          4

1       2       2 健壮性                                          4

1       2       3 可靠性                                          5

1       2       4 性能                                                        6

1       2       5 易用性                                          6

1       2       6 清晰性                                          7

1       2       7 安全性                                          7

1       2       8 可扩展性                            8

1       2       9 兼容性                                          8

1       2       10 可移植性                            8

1       3 人秘注的不仅仅是质量     9

1       3       1 质量、生产率和成本之间的关系                                                               9

1       3       2 软件过程改进的基本概念                                                                                                  10

1       4 高质量软件开发的基本方法                            13

1       4       1 建立软件过程规范              13

1       4       2 复用                                                 15

1       4       3 分而治之                     16

1       4       4 优化与折中       17

1       4       5 技术评审                     17

1       4       6 测试                                                 19

1       4       7 质量保证                     21

1       4       8 改错                                                 22

1       5 关于软件开发的一些常识和思考                                                                                                  23

1       5       1 有最好的编程语言吗                     23

1       5       2 编程是一门艺术吗              23

1       5       3 编程时应该多使用技巧吗                                                                                                  24

1       5       4 换更快的计算机还是换更快的算法                                          24

1       5       5 错误是否应该分等级                     24

1       5       6 一些错误的观念            25

1       6 小结                                                                                           25

第2 章 编程语言发展简史              27

2       1 编程语言大事记                     27

2       2 Ada 的故事                                                 31

2       3 C/C++发展简史                            31

2       4 Borland 与Microsoft 之争                     32

2       5 Java 阵营与Microsoft 的较量                     33

2       6 小结                                                                                           36

第3 章 程序的基本概念                            37

3       1 程序设计语言                                   37

3       2 语言实现                                                               38

3       3 程序库                                                                             40

3       4 开发环境                                                               40

3       5 程序的工作原理                     41

3       6 良好的编程习惯                     42

第4 章 C++/C 程序设计入门                          45

4       1 C++/C 程序的基本概念            45

4       1       1 启动函数main()            45

4       1       2 命令行参数       47

4       1       3 内部名称                     48

4       1       4 连接规范                     49

4       1       5 变量及其初始化            51

4       1       6 C Runtime Library      52

4       1       7 编译时和运行时的不同       52

4       1       8 编译单和独立编译技术                                                                                                  54

4       2 基本数据类型和内存映像                     54

4       3 类型转换                                                               56

4       3       1 隐式转换                     56

4       3       2 强制转换                     58

4       4 标识符                                                                             60

4       5 转义序列                                                               61

4       6 运算符                                                                             62

4       7 表达式                                                                             63

4       8 基本控制结构                                   65

4       9 选择（判断）结构       65

4       9       1 布尔变量与零值比较                     66

4       9       2 整型变量与零值比较                     67

4       9       3 浮点变量与零值比较                     67

4       9       4 指针变量与零值比较                     69

4       9       5 对if 语句的补充说明                     69

4       9       6 switch 结构       70

4       10 循环（重复）结构       71

4       10       1 for 语句的循环控制变量                                                                                                  72

4       10       2 循环语句的效率     73

4       11 结构化程序设计原理                          78

4       12 goto/continue/break 语句            79

4       13 示例                                                                                           79

第5 章 C++/C 常量                                                 85

5       1 认识常量                                                               85

5       1       1 字面常量                     85

5       1       2 符号常量                     86

5       1       3 契约性常量       87

5       1       4 枚举常量                     87

5       2 正确定义符号常量       87

5       3 const 与#define 的比较                   88

5       4 类中的常量                                                 89

5       5 实际应用中如何定义常量                     90

第6 章 C++/C 函数设计基础                          95

6       1 认识函数                                                               95

6       2 函数原型和定义                     96

6       3 函数调用方式                                   97

6       4 认识函数堆栈                                   99

6       5 函数调用规范                            100

6       6 函数连接规范                            101

6       7 参数传递规则                            102

6       8 返回值的规则                            104

6       9 函数内部实现的规则                   107

6       10 存储类型及作用域规则     109

6       10       1 存储类型       109

6       10       2 作用域规则                          110

6       10       3 连接类型        111

6       11 递归函数                                                        113

6       12 使用断言                                                        116

6       13 使用const 提高函数的健壮性              118

6       13       1 用const 修饰函数的参数                                                                                           118

6       13       2 用const 修饰函数的返回值                                                                             119

第7 章 C++/C 指针、数组和字符串                     121

7       1 指针                                                                                    121

7       1       1 指针的本质                                 121

7       1       2 指针的类型及其支持的运算                                                                             123

7       1       3 指针传递              125

7       2 数组                                                                                    126

7       2       1 数组的本质                                 126

7       2       2 二维数组              128

7       2       3 数组传递              129

7       2       4 动态创建、初始化和删除数组的方法                     131

7       3 字符数组、字符指针和字符串                                                                                                         133

7       3       1 字符数组、字符串和＇0＇的关系                                                               133

7       3       2 字符指针的误区     134

7       3       3 字符串拷贝和比较       134

7       4 函数指针                                                        134

7       5 引用和指针的比较137

第8 章 C++/C 高级数据类型                   141

8       1 结构（struct）                             141

8       1       1 关键字struct 与class 的困惑                                                                             141

8       1       2 使用struct        142

8       1       3 位域                                          145

8       1       4 成员对齐              147

8       2 联合（Union）                     159

8       3 枚举（Enum）                      161

8       4 文件                                                                                    162

第 9 章 C++/C 编译预处理165

9       1 文件包含                                                        165

9       1       1 内部包含卫哨和外部包含卫哨                                                               165

9       1       2 头文件包含的合理顺序                                                                                                         166

9       2 宏定义                                                                      166

9       3 条件编译                                                        169

9       3       1 #if、#elif 和#else                      169

9       3       2 #ifdef 和 #ifndef                      170

9       4 #error                                                                              170

9       5 #pragma                                                               171

9       6 #和##运算符                                   171

9       7 预定义符号常量              172

第10 章 C++/C 文件结构和程序版式              173

10       1 程序文件的目录结构            173

10       2 文件的结构                                   174

10       2       1 头文件的用途和结构                                                                                                         174

10       2       2 版权和版本信息       175

10       2       3 源文件结构                   176

10       3 代码的版式                                   176

10       3       1 适当的空行                   176

10       3       2 代码行及行内空格              177

10       3       3 长行拆分                                 178

10       3       4 对齐与缩进                   179

10       3       5 修饰符的位置     180

10       3       6 注释风格                                 180

10       3       7 ADT/UDT 版式              181

第11 章 C++/C 应用程序命名规则                            183

11       1 共性规则                                                 183

11       2 简单的Windows 应用程序命名                                                                                                  184

第12 章 C++面向对象程序设计方法概述                                                                                           187

12       1 漫谈面向对象                     187

12       2 对象的概念                                   188

12       3 信息隐藏与类的封装            189

12       4 类的继承特性                     193

12       5 类的组合特性                     199

12       6 动态特性                                                 200

12       6       1 虚函数              200

12       6       2 抽象基类                                 201

12       6       3 动态绑定                                 203

12       6       4 运行时多态                   206

12       6       5 多态数组                                 207

12       7 C++对象模型                            214

12       7       1 对象的内存映像       214

12       7       2 隐含成员                                 224

12       7       3 C++编译器如何处理成员函数                                                 225

12       7       4 C++编译器如何处理静态成员                                                 225

12       8 小结                                                                             226

第13 章 对象的初始化、拷贝和析构              229

13       1 构造函数与析构函数的起源              229

13       2 为什么需要构造函数和析构函数                                                                                    230

13       3 构造函数的成员初始化列表              232

13       4 对象的构造和析构次序                     234

13       5 构造函数和析构函数的调用时机                                                                                    235

13       6 构造函数和赋值函数的重载              236

13       7 示例：类String 的构造函数和析构函数                                                 238

13       8 何时应该定义拷贝构造函数和拷贝赋值函数              239

13       9 示例：类String 的拷贝构造函数和拷贝赋值函数240

13       10 用偷懒的办法处理拷贝构造函数和拷贝赋值函数                   242

13       11 如何实现派生类的基本函数              243

第14 章 C++函数的高级特性                   247

14       1 函数重载的概念       247

14       1       1 重载的起源                   247

14       1       2 重载是如何实现的              247

14       1       3 小心隐式类型转换导致重载函数产生二义性                     249

14       2 成员函数的重载、覆盖与隐藏                                                                                                  250

14       2       1 重载与覆盖                   250

14       2       2 令人迷惑的隐藏规则                                                                                                         251

14       2       3 摆脱隐藏                                 253

14       3 参数的默认值                     254

14       4 运算符重载                                   255

14       4       1 基本概念                                 255

14       4       2 运算符重载的特殊性                                                                                                         256

14       4       3 不能重载的运算符              257

14       4       4 重载++和--                    257

14       5 函数内联                                                 259

14       5       1 用函数内联取代宏              259

14       5       2 内联函数的编程风格                                                                                                         260

14       5       3 慎用内联                                 261

14       6 类型转换函数                     261

14       7 const 成员函数                     264

第15 章 C++异常处理和RTTI             267

15       1 为什么要使用异常处理                     267

15       2 C++异常处理                            268

15       2       1 异常处理的原理       268

15       2       2 异常类型和异常对象                                                                                                         269

15       2       3 异常处理的语法结构                                                                                                         270

15       2       4 异常的类型匹配规则                                                                                                         272

15       2       5 异常说明及其冲突              272

15       2       6 当异常抛出时局部对象如何释放                                   273

15       2       7 对象构造和析冠间的异常                                                               273

15       2       8 如何使用好异常处理技术                                                                             275

15       2       9 C++的标准异常              278

15       3 虚函数面临的难题                          278

15       4 RTTI 及其构成              280

15       4       1 起源                            280

15       4       2 typeid 运算符     281

15       4       3 dynamic_cast＜＞运算符                                                                                                  283

15       4       4 RTTI 的魅力与代价              285

第16 章 内存管理                                                        287

16       1 内存分配方式                     287

16       2 常见的内存错误及其对策                            288

16       3 指针参数是如何传递内存的              289

16       4 free 和delete 把指针怎么啦              291

16       5 动态内存会被自动释放吗                            292

16       6 杜绝“野指针”       292

16       7 有了malloc/free 为什么还要new/delete                                                293

16       8 malloc/free 的使用要点     295

16       9 new 有3 种使用方式            296

16       9       1 plain new/delete               296

16       9       2 nothrow new/delete                     297

16       9       3 placement new/delete       297

16       10 new/delete 的使用要点                     300

16       11 内存耗尽怎么办301

16       12 用对象模拟指针302

16       13 泛型指针auto_ptr                          305

16       14 带有引用计数的智能指针                     306

16       15 智能指针作为容器素              312

第17 章 学习和使用STL        323

17       1 STL 简介                                                 323

17       2 STL 头文件的分布                          324

17       2       1 容器类              324

17       2       2 泛型算法                                 325

17       2       3 迭代器              325

17       2       4 数学运算库                   325

17       2       5 通用工具                                 325

17       2       6 其他头文件                   326

17       3 容器设计原理                     326

17       3       1 内存映像                                 326

17       3       2 存储方式和访问方式                                                                                                         327

17       3       3 顺序容器和关联式容器的比较                                                 328

17       3       4 如何遍历容器     331

17       3       5 存储空间重分配问题                                                                                                         332

17       3       6 什么样的对象才能作为STL 容器的素                          333

17       4 迭代器                                                               334

17       4       1 迭代器的本质     334

17       4       2 迭代器失效及其危险性                                                                                           337

17       4       3 如何在遍历容器的过程中正确删除素                          346

17       5 存储分配器                                   347

17       6 适配器                                                               349

17       7 泛型算法                                                                                  352

17       8 一些特殊的容器       355

17       8       1 string 类       356

17       8       2 bitset 并非set      356

17       8       3 节省存储空间的vector＜bool＞                                                        358

17       8       4 空容器              360

17       9 STL 容器特征总结                          361

17       10 STL 使用心得              364

附录A C++/C 试题                                                 367

附录B C++/C 试题答案与评分标准                     371

附录C 大学十年                                                               377

附录D 《大学十年》后记       395

附录E 术语与缩写解释                     397

，，，，，，，，，，，，，，，，，，