C++程序设计语言 特别版PDF电子书下载

第1章 致读者 3

1.1 本书的结构 3

导论 3

1.1.1 例子和参考 4

1.1.3 有关实现的注记 5

1.1.2 练习 5

1.2 学习C++ 6

1.3 C++的设计 7

1.3.1 效率和结构 8

1.4 历史注记 9

1.3.2 哲学注记 9

1.5 C++的使用 11

1.6 C和C++ 12

1.6.2 给C++程序员的建议 13

1.6.1 给C程序员的建议 13

1.7 有关在C++里编程的思考 14

1.8 忠告 15

1.9 参考文献 16

2.2 程序设计范型 19

2.1 为什么是C++ 19

第2章 C++概览 19

2.3 过程式程序设计 20

2.3.1 变量和算术 21

2.3.2 检测和循环 22

2.4 模块程序设计 23

2.3.3 指针和数组 23

2.4.1 分别编译 24

2.4.2 异常处理 25

2.5 数据抽象 26

2.5.1 定义类型的模块 27

2.5.2 用户定义类型 28

2.5.3 具体类型 29

2.5.4 抽象类型 31

2.6.1 具体类型的问题 33

2.6 面向对象的程序设计 33

2.5.5 虚函数 33

2.6.2 类层次结构 34

2.7.1 容器 36

2.7 通用型程序设计 36

2.7.2 通用型算法 37

2.8 附言 38

2.9 忠告 39

3.2 Hello.world! 40

3.1 引言 40

第3章 标准库概览 40

3.4 输出 41

3.3 标准库名字空间 41

3.5 字符串 42

3.6 输入 44

3.5.1 C风格的字符串 44

3.7.1 向量——vector 46

3.7 容器 46

3.7.2 范围检查 47

3.7.3 表——list 48

3.7.5 标准容器 49

3.7.4 映射——map 49

3.8 算法 50

3.8.1 迭代器的使用 51

3.8.2 迭代器类型 52

3.8.3 迭代器和I/O 53

3.8.4 遍历和谓词 54

3.8.6 标准库算法 56

3.8.5 使用成员函数的算法 56

3.9.2 向量算术 57

3.9.1 复数 57

3.9 数学 57

3.11 忠告 58

3.10 标准库功能 58

3.9.3 基本数值支持 58

4.1 类型 63

第4章 类型和声明 63

第一部分 基本功能 63

4.2 布尔量 64

4.1.1 基本类型 64

4.3 字符类型 65

4.4.1 整数文字量 66

4.4 整数类型 66

4.3.1 字符文字量 66

4.5.1 浮点文字量 67

4.5 浮点类型 67

4.6 大小 68

4.8 枚举 69

4.7 void 69

4.9 声明 71

4.9.1 声明的结构 72

4.9.3 名字 73

4.9.2 声明多个名字 73

4.9.4 作用域 74

4.9.5 初始化 75

4.9.7 typedef 76

4.9.6 对象和左值 76

4.11 练习 77

4.10 忠告 77

5.1 指针 79

第5章 指针、数组和结构 79

5.2.1 数组初始化 80

5.2 数组 80

5.1.1 零 80

5.2.2 字符串文字量 81

5.3.1 在数组里漫游 83

5.3 到数组的指针 83

5.4 常量 85

5.4.1 指针和常量 87

5.5 引用 88

5.6 指向void的指针 90

5.7 结构 91

5.9 练习 94

5.8 忠告 94

5.7.1 类型等价 94

6.1.1 分析器 96

6.1 一个桌面计算器 96

第6章 表达式和语句 96

6.1.2 输入函数 100

6.1.3 低级输入 102

6.1.4 错误处理 103

6.1.6 头文件 104

6.1.5 驱动程序 104

6.1.7 命令行参数 105

6.1.8 有关风格的注记 106

6.2 运算符概览 107

6.2.1 结果 109

6.2.3 运算符优先级 110

6.2.2 求值顺序 110

6.2.4 按位逻辑运算符 111

6.2.5 增量和减量 112

6.2.6 自由存储 113

6.2.7 显式类型转换 116

6.2.8 构造函数 117

6.3 语句概览 118

6.3.2 选择语句 119

6.3.1 声明作为语句 119

6.3.3 迭代语句 122

6.4 注释和缩进编排 123

6.3.4 goto 123

6.6 练习 125

6.5 忠告 125

7.1.1 函数定义 128

7.1 函数声明 128

第7章 函数 128

7.1.2 静态变量 129

7.2 参数传递 130

7.2.1 数组参数 131

7.3 返回值 132

7.4 重载函数名 133

7.4.3 手工的歧义性解析 135

7.4.2 重载与作用域 135

7.4.1 重载和返回类型 135

7.4.4 多参数的解析 136

7.5 默认参数 137

7.6 未确定数目的参数 138

7.7 指向函数的指针 139

7.8 宏 143

7.9 忠告 145

7.8.1 条件编译 145

7.10 练习 146

8.1 模块化和界面 148

第8章 名字空间和异常 148

8.2 名字空间 150

8.2.1 带限定词的名字 151

8.2.2 使用声明 152

8.2.3 使用指令 153

8.2.4 多重界面 154

8.2.5 避免名字冲突 157

8.2.7 名字空间别名 159

8.2.6 名字查找 159

8.2.8 名字空间组合 160

8.2.9 名字空间和老代码 163

8.3 异常 166

8.3.1 抛出和捕捉 167

8.3.2 异常的辨识 168

8.3.3 在计算器中的异常 169

8.5 练习 173

8.4 忠告 173

9.1 分别编译 175

第9章 源文件和程序 175

9.2 连接 176

9.2.1 头文件 178

9.2.2 标准库头文件 179

9.2.3 单一定义规则 180

9.2.4 与非C++代码的连接 182

9.3.1 单一头文件 184

9.3 使用头文件 184

9.2.5 连接与指向函数的指针 184

9.3.2 多个头文件 187

9.3.3 包含保护符 191

9.4.1 非局部变量的初始化 192

9.4 程序 192

9.6 练习 194

9.5 忠告 194

10.2 类 199

10.1 引言 199

第二部分 抽象机制 199

第10章 类 199

10.2.1 成员函数 200

10.2.2 访问控制 201

10.2.3 构造函数 202

10.2.4 静态成员 203

10.2.5 类对象的复制 204

10.2.7 自引用 205

10.2.6 常量成员函数 205

10.2.8 结构和类 208

10.3 高效的用户定义类型 210

10.2.9 在类内部的函数定义 210

10.3.1 成员函数 212

10.3.2 协助函数 214

10.3.4 具体类型的意义 215

10.3.3 重载的运算符 215

10.4.1 析构函数 216

10.4 对象 216

10.4.2 默认构造函数 217

10.4.4 局部变量 218

10.4.3 构造和析构 218

10.4.5 自由存储 220

10.4.6 类对象作为成员 221

10.4.7 数组 223

10.4.8 局部静态存储 224

10.4.9 非局部存储 225

10.4.10 临时对象 226

10.4.11 对象的放置 228

10.4.12 联合 229

10.6 练习 230

10.5 忠告 230

11.1 引言 233

第11章 运算符重载 233

11.2 运算符函数 234

11.2.1 二元和一元运算符 235

11.2.3 运算符和用户定义类型 236

11.2.2 运算符的预定义意义 236

11.2.4 名字空间里的运算符 237

11.3.1 成员运算符和非成员运算符 238

11.3 一个复数类型 238

11.3.2 混合模式算术 239

11.3.3 初始化 240

11.3.4 复制 241

11.3.5 构造函数和转换 242

11.3.7 另一些成员函数 243

11.3.6 文字量 243

11.3.8 协助函数 244

11.4 转换运算符 245

11.4.1 歧义性 246

11.5 友元 248

11.5.1 友元的寻找 249

11.5.2 友元和成员 250

11.6 大型对象 251

11.7.1 显式构造函数 253

11.7 基本运算符 253

11.8 下标 255

11.9 函数调用 256

11.10 间接 257

11.11 增量和减量 259

11.12 一个字符串类 260

11.14 练习 265

11.13 忠告 265

12.1 引言 268

第12章 派生类 268

12.2 派生类 269

12.2. 1成员函数 271

12.2. 2构造函数和析构函数 272

12.2.4 类层次结构 273

12.2.3 复制 273

12.2.5 类型域 274

12.2.6 虚函数 276

12.3 抽象类 278

12.4.1 一个传统的层次结构 280

12.4 类层次结构的设计 280

12.4.2 抽象类 283

12.4.3 其他实现方式 285

12.4.4 对象创建的局部化 287

12.7 练习 289

12.6 忠告 289

12.5 类层次结构和抽象类 289

13.1 引言 292

第13章 模板 292

13.2 一个简单的String模板 293

13.2.1 定义一个模板 294

13.2.2 模板实例化 295

13.2.4 类型等价 296

13.2.3 模板参数 296

13.2.5 类型检查 297

13.3 函数模板 298

13.3.1 函数模板的参数 299

13.3.2 函数模板的重载 300

13.4 用模板参数描述策略 302

13.4.1 默认模板参数 303

13.5 专门化 304

13.5.1 专门化的顺序 306

13.5.2 模板函数的专门化 307

13.6 派生和模板 308

13.6.1 参数化和继承 309

13.6.2 成员模板 310

13.6.3 继承关系 311

13.7 源代码组织 312

13.9 练习 314

13.8 忠告 314

14.1 错误处理 316

第14章 异常处理 316

14.2 异常的结组 318

14.1.1 关于异常的其他观点 318

14.2.1 派生的异常 319

14.3 捕捉异常 321

14.2.2 多个异常的组合 321

14.3.2 捕捉所有异常 322

14.3.1 重新抛出 322

14.4 资源管理 324

14.4.1 构造函数和析构函数的使用 325

14.4.2 auto_ptr 326

14.4.4 异常和new 328

14.4.3 告诫 328

14.4.5 资源耗尽 329

14.4.6 构造函数里的异常 331

14.4.7 析构函数里的异常 332

14.5 不是错误的异常 333

14.6 异常的描述 334

14.6.1 对异常描述的检查 335

14.6.3 异常的映射 336

14.6.2 未预期的异常 336

14.7 未捕捉的异常 338

14.8 异常和效率 339

14.9 处理错误的其他方式 340

14.10 标准异常 342

14.12 练习 344

14.11 忠告 344

15.2 多重继承 346

15.1 引言和概述 346

第15章 类层次结构 346

15.2.1 歧义性解析 348

15.2.2 继承和使用声明 349

15.2.3 重复的基类 350

15.2.4 虚基类 352

15.2.5 使用多重继承 354

15.3 访问控制 357

15.3.1 保护成员 359

15.3.2 对基类的访问 360

15.4 运行时类型信息 361

15.4.1 dynamic_cast 363

15.4.2 在类层次结构中漫游 365

15.4.3 类对象的构造与析构 367

15.4.4 typeid和扩展的类型信息 368

15.4.5 RTTI的使用和误用 370

15.5 指向成员的指针 371

15.5.1 基类和派生类 373

15.6 自由存储 374

15.6.1 数组分配 375

15.6.2 虚构造函数 376

15.8 练习 377

15.7 忠告 377

16.1 标准库的设计 381

第16章 库组织和容器 381

第三部分 标准库 381

16.1.1 设计约束 382

16.1.2 标准库组织 383

16.1.3 语言支持 385

16.2.1 专门化的容器和迭代器 386

16.2 容器设计 386

16.2.2 有基类的容器 388

16.2.3 STL容器 391

16.3 向量 392

16.3.1 类型 393

16.3.2 迭代器 394

16.3.3 元素访问 395

16.3.4 构造函数 396

16.3.5 堆栈操作 399

16.3.6 表操作 401

16.3.7 元素定位 403

16.3.8 大小和容量 404

16.3.10 协助函数 406

16.3.9 其他成员函数 406

16.4 忠告 407

16.3.11 vector＜bool＞ 407

16.5 练习 408

17.1.1 操作综述 409

17.1 标准容器 409

第17章 标准容器 409

17.1.2 容器综述 412

17.1.4 对元素的要求 413

17.1.3 表示 413

17.2.2 表——list 416

17.2.1 向量——vector 416

17.2 序列 416

17.2.3 双端队列——deque 420

17.3.1 堆栈——stack 421

17.3 序列适配器 421

17.3.2 队列——queue 422

17.3.3 优先队列——priority_queue 423

17.4.1 映射——map 425

17.4 关联容器 425

17.4.2 多重映射——multimap 433

17.4.3 集合——set 434

17.5.3 位集合——bitset 435

17.5.2 值向量——valarray 435

17.4.4 多重集合——multiset 435

17.5 拟容器 435

17.5.1 串——string 435

17.6 定义新容器 439

17.5.4 内部数组 439

17.6.1 散列映射——hash_map 440

17.6.2 表示和构造 441

17.8 练习 446

17.7 忠告 446

17.6.3 其他散列关联容器 446

18.2 标准库算法综述 449

18.1 引言 449

第18章 算法和函数对象 449

18.3.1 输入序列 453

18.3 序列和容器 453

18.4 函数对象 454

18.4.2 谓词 456

18.4.1 函数对象的基类 456

18.4.4 约束器、适配器和否定器 458

18.4.3 算术函数对象 458

18.5.1 对每个做——for each 463

18.5 非修改性序列算法 463

18.5.2 查找族函数 464

18.5.3 计数 465

18.5.4 相等和不匹配 466

18.6 修改性序列算法 467

18.5.5 搜索 467

18.6.1 复制 468

18.6.2 变换 469

18.6.3 惟一化 471

18.6.4 取代 473

18.6.6 填充和生成 474

18.6.5 删除 474

18.6.7 反转和旋转 475

18.7.1 排序 476

18.7 排序的序列 476

18.6.8 交换 476

18.7.2 二分检索 477

18.7.3 归并 478

18.7.5 序列上的集合运算 479

18.7.4 划分 479

18.8 堆 480

18.9 最小和最大 481

18.11 C风格算法 482

18.10 排列 482

18.13 练习 483

18.12 忠告 483

19.2 迭代器和序列 485

19.1 引言 485

第19章 迭代器和分配器 485

19.2.1 迭代器的操作 486

19.2.2 迭代器特征类——iterator_traits 487

19.2.3 迭代器类别 488

19.2.4 插入器 490

19.2.5 反向迭代器 491

19.2.6 流迭代器 492

19.3 带检查迭代器 495

19.3.1 异常、容器和算法 499

19.4.1 标准分配器 500

19.4 分配器 500

19.4.2 一个用户定义分配器 503

19.4.3 广义的分配器 505

19.4.4 未初始化的存储 506

19.4.5 动态存储 508

19.4.6 C风格的分配 509

19.6 练习 510

19.5 忠告 510

20.2 字符 511

20.1 引言 511

第20章 串 511

20.2.1 字符特征类——char_traits 512

20.3 基础串类——basic_string 513

20.3.1 类型 514

20.3.2 迭代器 515

20.3.4 构造函数 516

20.3.3 元素访问 516

20.3.5 错误 517

20.3.6 赋值 518

20.3.7 到C风格字符串的转换 519

20.3.8 比较 521

20.3.9 插入 522

20.3.10 拼接 523

20.3.11 查找 524

20.3.12 替换 525

20.3.13 子串 526

20.3.15 I/O操作 527

20.3.14 大小和容量 527

20.4.1 C风格字符串 528

20.4 C标准库 528

20.3.16 交换 528

20.5 忠告 530

20.4.2 字符分类 530

20.6 练习 531

21.1 引言 533

第21章 流 533

21.2 输出 534

21.2.1 输出流 535

21.2.2 内部类型的输出 536

21.2.3 用户定义类型的输出 538

21.3.2 内部类型的输入 540

21.3.1 输入流 540

21.3 输入 540

21.3.3 流状态 542

21.3.4 字符的输入 544

21.3.5 用户定义类型的输入 546

21.3.6 异常 547

21.3.7 流的联结 548

21.3.8 哨位 549

21.4.1 格式状态 550

21.4 格式化 550

21.4.3 浮点数输出 552

21.4.2 整数输出 552

21.4.4 输出域 553

21.4.6 操控符 555

21.4.5 域的调整 555

21.5 文件流与字符串流 560

21.5.1 文件流 561

21.5.2 流的关闭 562

21.5.3 字符串流 563

21.6 缓冲 564

21.6.1 输出流和缓冲区 565

21.6.2 输入流和缓冲区 566

21.6.4 流缓冲区 567

21.6.3 流和缓冲区 567

21.7 现场 571

21.7.1 流回调 572

21.8 C输入／输出 573

21.9 忠告 575

21.10 练习 576

22.2 数值的限制 578

22.1 引言 578

第22章 数值 578

22.3 标准数学函数 580

22.2.1 表示限制的宏 580

22.4.1 valarray的构造 582

22.4 向量算术 582

22.4.2 valarray的下标和赋值 583

22.4.3 成员操作 584

22.4.4 非成员函数 586

22.4.5 切割 587

22.4.6 切割数组——slice_array 589

22.4.7 临时量、复制和循环 593

22.4.8 广义切割 595

22.4.10 间接数组——indirect_array 596

22.4.9 屏蔽 596

22.5 复数算术 597

22.6.1 累积——accumulate 599

22.6 通用数值算法 599

22.6.3 增量变化 600

22.6.2 内积——inner_product 600

22.7 随机数 602

22.9 练习 603

22.8 忠告 603

23.2 引言 607

23.1 概述 607

第四部分 用C++做设计 607

第23章 开发和设计 607

23.3 目的与手段 609

23.4 开发过程 611

23.4.1 开发循环 613

23.4.2 设计目标 615

23.4.3 设计步骤 616

23.4.4 试验和分析 623

23.4.6 软件维护 625

23.4.5 测试 625

23.5 管理 626

23.4.7 效率 626

23.5.1 重用 627

23.5.2 规模 628

23.5.3 个人 629

23.5.4 混成设计 630

23.6 带标注的参考文献 631

23.7 忠告 633

24.2 设计和程序设计语言 635

24.1 概述 635

第24章 设计和编程 635

24.2.1 忽视类 637

24.2.3 忽视静态类型检查 638

24.2.2 忽视继承 638

24.2.4 忽视程序设计 641

24.2.5 排他性地使用类层次结构 642

24.3.1 类表示什么 643

24.3 类 643

24.3.2 类层次结构 644

24.3.3 包容关系 648

24.3.4 包容和继承 649

24.3.5 使用关系 653

24.3.6 编入程序里的关系 654

24.3.7 类内的关系 656

24.4 组件 661

24.4.1 模板 663

24.4.2 界面和实现 665

24.4.3 肥大的界面 667

24.5 忠告 668

25.1 类的种类 670

第25章 类的作用 670

25.2.1 具体类型的重用 672

25.2 具体类型 672

25.3 抽象类型 674

25.4 结点 676

25.4.1 修改界面 677

25.5 动作 680

25.6 界面类 681

25.6.1 调整界面 683

25.7 句柄类 684

25.7.1 句柄上的操作 687

25.8 应用框架 688

25.9 忠告 689

25.10 练习 690

附录A 语法 695

附录和索引 695

附录B 兼容性 713

附录C 技术细节 724

附录D 现场 759

附录E 标准库的异常时安全性 815

索引 845