21天学通C++PDF电子书下载

第一篇 2

第一章 开始 2

1.1 引言 2

1.2 C++历史简介 2

1.2.1 本书要解决的问题 2

1.2.2 过程编程、结构化编程和面向对象的编程 3

1.2.3 C++和面向对象编程 4

1.3 C++的发展历程 4

1.4 学习C++应该先学C吗 5

1.5 C++和Java及C# 5

1.6 ANSI标准 5

1.7 准备编程 5

1.8 开发环境 6

1.9 生成程序 6

1.9.1 用编译器生成对象文件 6

1.9.2 用链接器生成可执行文件 6

1.10 程序开发周期 7

1.11 HELLO.cpp——你的第一个C++程序 8

1.12 开始学习编译器 9

1.12.1 创建Hello World项目 9

1.13 编译错误 9

1.14 小结 10

1.15 问与答 10

1.16 习题 10

1.16.1 测验 11

1.16.2 练习 11

第二章 C++程序的组成部分 12

2.1 一个简单程序 12

2.2 cout简介 13

2.3 使用标准的Namespace 15

2.4 注释 17

2.4.1 注释的类型 17

2.4.2 使用注释 17

2.5 函数 18

2.4.3 对注释的忠告 18

2.5.1 函数的使用 19

2.6 小结 20

2.7 问与答 20

2.8 习题 21

2.8.1 测验 21

2.8.2 练习 21

3.1.1 将数据存储在内存中 22

3.1.2 留出内存 22

3.1 什么是变量 22

第三章 变量与常量 22

3.1.3 整型量的大小 23

3.1.4 有符号和无符号 24

3.1.5 基本变量类型 24

3.2 定义一个变量 25

3.2.1 大小写敏感性 26

3.2.2 关键字 26

3.4 给变量赋值 27

3.3 一次创建多个变量 27

3.5 typedef 28

3.6 short与long的使用 29

3.6.1 无符号整型量的回绕 29

3.6.2 有符号整型量的回绕 30

3.7 字符型变量 31

3.7.1 字符和数字 31

3.7.2 特殊打印字符 32

3.8 常量 32

3.8.2 符号常量 33

3.8.1 字面常量 33

3.9 枚举型常量 34

3.10 小结 35

3.11 问与答 36

3.12 习题 36

3.12.1 测验 36

3.12.2 练习 37

4.1.1 空白 38

4.1.2 块和复合语句 38

第四章 表达式和语句 38

4.1 语句 38

4.2 表达式 39

4.3 运算符 40

4.3.1 赋值运算符 40

4.3.2 数学运算符 40

4.3.3 整型量除法和取模 41

4.4 赋值运算符与数学运算符的组合 41

4.5.1 前置和后置 42

4.5 自加与自减 42

4.6 优先级 44

4.7 括号的嵌套 44

4.8 真值的本质 45

4.8.1 关系运算符 45

4.9 if语句 46

4.9.1 缩进样式 48

4.9.2 else 49

4.9.3 高级if语句 50

4.10 在嵌套的if语句中使用大括号 52

4.11 逻辑运算符 54

4.11.1 逻辑“与” 54

4.11.2 逻辑“或” 54

4.11.3 逻辑“非” 54

4.12 简化求值 55

4.13 关系运算符的优先级 55

4.14 有关真假关系的进一步讨论 55

4.15 条件运算符(三目运算符) 56

4.16 小结 57

4.17 问与答 57

4.18 习题 58

4.18.1 测验 58

4.18.2 练习 58

第五章 函数 60

5.1 什么是函数 60

5.3.1 函数的声明 61

5.3.2 函数原型 61

5.2 函数的返回值、参数和变元 61

5.3 声明和定义函数 61

5.3.3 定义函数 62

5.4 函数的执行 63

5.5 局部变量 63

5.5.1 作用范围 65

5.6 全局变量 65

5.7 使用全局变量的注意事项 66

5.8 有关局部变量的更多知识 66

5.10 有关函数变元的更多知识 67

5.9 函数语句 67

5.10.1 使用函数作为函数的参数 68

5.11 参数作为局部变量 68

5.12 有关返回值的更多知识 69

5.13 默认参数 71

5.14 函数重载 72

5.15 有关函数的一些专门话题 75

5.15.1 内嵌函数 75

5.15.2 递归 76

5.16.2 划分RAM 80

5.16 函数是如何工作的 80

5.16.1 抽象层次 80

5.16.3 堆栈与函数 81

5.17 小结 82

5.18 问与答 82

5.19 习题 83

5.19.1 测验 83

5.19.2 练习 83

6.2 创建新类型 85

6.1 C++是面向对象的吗 85

第六章 面向对象编程 85

6.2.1 为什么要创建新类型 86

6.3 类和成员 86

6.3.1 声明一个类 86

6.3.2 有关命名习惯的一点说明 87

6.3.3 定义一个对象 87

6.3.4 类与对象 87

6.4 访问类成员 87

6.4.2 如果你不声明它，你的类就没有它 88

6.5 私有和公有 88

6.4.1 给对象赋值而不是给类赋值 88

6.5.1 使成员数据私有 90

6.5.2 私有性与安全性 91

6.6 实现类的方法 92

6.7 构造函数和析构函数 94

6.7.1 默认的构造函数和析构函数 95

6.7.2 使用默认构造函数 95

6.8 成员函数const 97

6.9 界面与实现 98

6.10 在何处放置类声明和方法定义 100

6.11 内嵌实现 100

6.12 用其他类作为成员数据的类 102

6.13 结构体 105

6.13.1 为什么两个关键字做同一件事 106

6.14 小结 106

6.15 问与答 106

6.16.1 测验 107

6.16.2 练习 107

6.16 习题 107

第七章 程序流程 109

7.1 循环 109

7.1.1 循环语句的起源——goto语句 109

7.1.2 为什么现在不再使用goto语句 110

7.2 while循环 110

7.2.1 复杂的while语句 111

7.2.2 continue和break 112

7.2.3 while(true)循环 114

7.3 do…while循环 115

7.4 do…while 116

7.5 for循环 118

7.5.1 高级for循环 119

7.5.2 多重初始化和自增运算 120

7.5.3 在for循环中使用空语句 120

7.5.4 空for循环 122

7.5.5 嵌套循环 123

7.5.6 for循环的作用域 124

7.6 循环总结 125

7.7 switch语句 126

7.7 使用带有菜单的switch语句 129

7.8 小结 131

7.9 问与答 131

7.10 习题 132

7.10.1 测验 132

7.10.2 练习 132

第一篇内容回顾 134

8.1 什么是指针 140

第八章 指针 140

第二篇 140

8.1.1 在指针中存储地址 141

8.1.2 指针名 142

8.1.3 间接引用运算符 142

8.1.4 指针、地址和变量 143

8.1.5 使用指针操作数据 144

8.1.6 检查地址 145

8.2 为什么要使用指针 146

8.3.1 new 147

8.3 栈和自由存储区(堆) 147

8.3.2 delete 148

8.4 内存泄漏 149

8.5 在自由存储区内创建对象 150

8.6 删除对象 150

8.7 访问数据成员 151

8.8 自由存储区中的成员数据 152

8.9 this指针 155

8.10 迷途指针、失控指针或悬浮指针 156

8.11.1 const指针和const成员函数 158

8.11 const指针 158

8.11.2 const this指针 160

8.12 指针算法高级主题 160

8.13 小结 162

8.14 问与答 162

8.15 习题 163

8.15.1 测验 163

8.15.2 练习 163

9.1 什么是引用 165

第九章 引用 165

9.2 对引用使用取址运算符 166

9.2.1 引用不能被重新赋值 167

9.3 什么可以被引用 168

9.4 空指针和空引用 170

9.5 通过引用传递函数参数 170

9.5.1 用指针使swap()工作 171

9.5.2 使用引用实现swap() 172

9.7 返回多个值 174

9.6 理解函数头文件和原型 174

9.7.1 通过引用返回值 175

9.8 使用引用传递来提高效率 177

9.8.1 传递const指针 179

9.8.2 使用引用代替指针 181

9.9 何时使用引用以及何时使用指针 183

9.10 混合使用引用和指针 183

9.11 不要返回对不在作用域中的对象的引用 184

9.12 返回对一个在堆中的对象的引用 185

9.13 指针的传递 187

9.15 问与答 188

9.16 习题 188

9.16.1 测验 188

9.16.2 练习 188

9.14 小结 188

第十章 高级函数 190

10.1 重载成员函数 190

10.2 使用默认值 192

10.5 重载构造函数 194

10.3 默认值和重载函数的选择 194

10.4 默认构造函数 194

10.6 初始化对象 196

10.7 复制构造函数 196

10.8 运算符重载 200

10.8.1 写一个自加函数 200

10.8.2 重载前置运算符 201

10.8.3 重载运算符函数的返回类型 203

10.8.4 返回无名临时对象 204

10.8.5 使用this指针 205

10.8.6 重载后置运算符 206

10.8.7 前置和后置之间的区别 207

10.8.8 加法运算符 208

10.8.9 重载operator+ 210

10.8.10 运算符重载中存在的问题 211

10.8.11 运算符重载的局限性 211

10.8.12 重载什么 211

10.8.13 赋值运算符 212

10.9 处理数据类型转换 214

10.9.1 转换运算符 216

10.10 小结 217

10.11 问与答 217

10.12 习题 218

10.12.1 测验 218

10.12.2 练习 218

11.1 构造模型 220

11.2 软件设计：建模语言 220

第十一章 面向对象的分析及设计 220

11.3 软件设计：过程 221

11.4 Extreme编程 222

11.5 概览 223

11.6 需求分析 223

11.6.1 使用情况 223

11.6.2 应用分析 230

11.6.3 系统分析 230

11.6.6 人工制品 231

11.6.5 可视化 231

11.6.4 计划文档 231

11.7 设计 232

11.7.1 什么是类 232

11.7.2 变换 233

11.7.3 静态模型 234

11.7.4 动态模型 240

11.8 小结 242

11.9 问与答 242

11.10.2 练习 243

11.10 习题 243

11.10.1 测验 243

第十二章 继承 244

12.1 什么是继承 244

12.1.1 继承和派生 244

12.1.2 动物世界 245

12.1.3 派生的语法 245

12.2 私有型与保护型 247

12.3 构造函数和析构函数 248

12.3.1 向基构函数传递参数 250

12.4 覆盖函数 254

12.4.1 隐藏基类方法 255

12.4.2 调用基方法 257

12.5 虚函数 258

12.5.1 虚函数是怎样工作的 261

12.5.2 不能从基类中访问派生类中的函数 262

12.5.3 切片(slicing) 262

12.5.4 虚析构函数 264

12.5.5 虚复制构造函数 265

12.5.6 虚函数的代价 267

12.6 小结 267

12.7 问与答 268

12.8 习题 268

12.8.1 测验 268

12.8.2 练习 269

13.2 数组元素 270

13.1 什么是数组 270

第十三章 数组和链表 270

13.3 超过数组末尾写入数据 271

13.4 篱笆标志错误 274

13.5 初始化数组 274

13.6 声明数组 275

13.7 对象的数组 276

13.8 多维数组 277

13.9 初始化多维数组 278

13.11 指针数组 279

13.10 有关内存的一些话题 279

13.12 在自由存储区声明数组 281

13.13 指向数组的指针和指针数组 281

13.14 指针与数组名 281

13.15 删除自由存储区中的数组 283

13.16 char数组 283

13.17 strcpy()和stmcpy() 285

13.18 字符串类 286

13.19 链表和其他结构 291

13.20 链表案例研究 292

13.20.1 责任授权 292

13.21 组件部分 292

13.22 你学到了什么 299

13.23 数组类 299

13.24 小结 300

13.25 问与答 300

13.26 习题 300

13.26.2 练习 301

13.26.1 测验 301

第十四章 多态性 302

14.1 单一继承的问题 302

14.1.1 升迁 304

14.1.2 下降 304

14.1.3 添加到两个链表 306

14.2 多重继承 306

14.2.1 多重继承对象的构成 309

14.2.2 多重继承对象中的构造函数 309

14.2.4 从共享基类中继承 312

14.2.3 歧义解析 312

14.2.5 虚继承 315

14.2.6 多重继承中存在的问题 318

14.2.7 混合继承和功能类 319

14.3 抽象数据类型 319

14.3.1 纯虚函数 322

14.3.2 实现纯虚函数 323

14.3.3 复杂的抽象层次 326

14.5 问与答 329

14.4 小结 329

14.3.4 哪些类型是抽象的 329

14.6 习题 330

14.6.1 测验 330

14.6.2 练习 330

第二篇内容回顾 331

第三篇 340

第十五章 特殊类和函数 340

15.1 静态成员数据 340

15.2 静态成员函数 344

15.3 函数指针 346

15.3.1 为什么使用函数指针 349

15.3.2 函数指针数组 351

15.3.3 把函数指针传递给其他函数 353

15.3.4 在函数指针中使用typedef 356

15.4 成员函数指针 358

15.4.1 成员函数指针数组 360

15.5 小结 361

15.7.2 练习 362

15.7.1 测验 362

15.6 问与答 362

15.7 习题 362

第十六章 高级继承 364

16.1 包容 364

16.1.1 访问被包容类的成员 369

16.1.2 过滤对被包容成员的访问 369

16.1.3 包容的代价 370

16.1.4 按值来复制 372

16.2 按继承/包容条款实现与代理 375

16.2.1 授权 376

16.3 私有继承 383

16.4 友元类 390

16.5 友元函数 397

16.6 友元函数和运算符重载 397

16.7 重载插入运算符 401

16.10 习题 405

16.9 问与答 405

16.8 小结 405

16.10.1 测验 406

16.10.2 练习 406

第十七章 流 408

17.1 流概述 408

17.1.1 封装 408

17.1.2 缓冲 409

17.3 标准I/O对象 410

17.2 流和缓冲区 410

17.4 重定向 411

17.5 用cin输入 411

17.5.1 串 412

17.5.2 串存在的问题 413

17.5.3 运算符>>返回对一个istream对象的引用 415

17.6 cin的其他成员函数 415

17.6.1 单字符输入 415

17.6.2 不使用参数的get() 415

17.6.4 从标准输入读取字符串 417

17.6.3 使用带字符引用参数的get() 417

17.6.5 使用cin.ignore() 419

17.6.6 peek()和putback() 421

17.7 使用cout输出 421

17.7.1 清除输出 422

17.8 相关函数 422

17.9 控制符、标志和格式化指令 423

17.9.1 使用cout.width() 423

17.9.2 设置填充字符 424

17.9.3 设置标志 425

17.10 流和printf()函数 426

17.11 文件的输入和输出 429

17.12 ofstream 429

17.12.1 条件状态 429

17.12.2 打开文件进行输入和输出 429

17.12.3 在打开时改变ofstream的默认行为 430

17.13 二进制文件和文本文件 432

17.14 命令行处理 434

17.16 问与答 437

17.15 小结 437

17.17 习题 438

17.17.1 测验 438

17.17.2 练习 438

第十八章 名字空间 439

18.1 开始 439

18.2 按名字解析函数和类 439

18.3 创建名字空间 442

18.3.1 声明和定义类型 442

18.3.2 在名字空间外定义函数 443

18.3.3 添加新成员 443

18.3.4 嵌套的名字空间 444

18.4 使用名字空间 444

18.5 关键字using 446

18.5.1 using命令 446

18.5.2 using声明 447

18.7 未命名的名字空间 449

18.6 名字空间别名 449

18.8 标准名字空间std 450

18.9 小结 451

18.10 问与答 451

18.11 习题 452

18.11.1 测验 452

18.11.2 练习 452

19.2.1 实例化一个模板的实现 453

19.2 参数化类型 453

19.1 什么是模板 453

第十九章 模板 453

19.3 模板定义 454

19.3.1 使用名字 455

19.3.2 模板的实现 455

19.4 模板函数 458

19.5 模板和友元 459

19.5.1 非模板友元类和函数 459

19.5.2 通用模板友元类或函数 462

19.6 使用模板项 465

19.6.1 特殊化函数 469

19.6.2 静态成员和模板 473

19.7 标准模板库 477

19.8 容器 477

19.9 了解顺序容器 477

19.9.1 向量容器 477

19.9.2 列表容器 482

19.9.3 Deque容器 483

19.10 堆栈 483

19.12.1 映射容器 484

19.11 了解队列 484

19.12 了解关联容器 484

19.12.2 其他关联容器 487

19.13 算法类 487

19.13.1 不变序列运算 488

19.13.2 改变序列算法 488

19.14 小结 489

19.15 问与答 489

19.16.2 练习 490

19.16.1 测验 490

19.16 习题 490

第二十章 异常和错误处理 492

20.1 程序中的各种错误(bugs、errors、mistakes和code rot) 492

20.1.1 异常 492

20.2 异常 493

20.2.1 如何使用异常 493

20.3 使用try块和catch块 497

20.3.1 捕捉异常 497

20.3.2 设置多条catch语句 498

20.3.3 异常等级 500

20.4 异常中的数据和命名异常对象 502

20.5 异常和模板 508

20.6 没有错误的异常 511

20.7 关于代码腐烂 511

20.8 错误和调试 511

20.10 问与答 512

20.9 小结 512

20.8.4 汇编 512

20.8.3 检查内存 512

20.8.1 断点 512

20.8.2 观察点 512

20.11 习题 513

20.11.1 测验 513

20.11.2 练习 513

21.2 查看中间结果 515

21.3 使用#define 515

21.1 预处理器和编译器 515

第二十一章 进一步掌握的内容 515

21.3.1 用#define替换常量 516

21.3.2 用#define进行测试 516

21.3.3 预编译命令#else 516

21.4 包含和包含警卫 517

21.5 宏函数 518

21.5.1 为什么总要用括号 519

21.5.2 宏与函数和模板 520

21.6 内联函数 520

21.7.2 连结字符串 522

21.7 字符串操作 522

21.7.1 字符串化 522

21.8 预定义宏 523

21.9 assert() 523

21.9.1 用assert()调试 524

21.9.2 assert()与异常 524

21.9.3 副作用 525

21.9.4 类不变量 525

21.9.5 打印中间值 529

21.9.6 调试级别 530

21.10 位操作 535

21.10.1 “与”运算符 536

21.10.2 “或”运算符 536

21.10.3 “异或”运算符 536

21.10.4 求补运算符 536

21.10.5 设置位 536

21.10.6 清除位 536

21.10.8 位字段 537

21.10.7 反转位 537

21.11 风格 539

21.11.1 缩进 540

21.11.2 大括号 540

21.11.3 长代码行 540

21.11.4 switch语句 540

21.11.5 程序文本 540

21.11.6 标识符名称 541

21.11.7 名字的拼写和大写 541

21.11.8 注释 542

21.11.9 访问 542

21.11.10 类定义 542

21.11.11 包含文件 542

21.12.1 从何处获得帮助和建议 543

21.12.2 学习C# 543

21.12.3 保持联系 543

21.12 下一步 543

21.11.13 const 543

21.11.12 assert() 543

21.13 小结 544

21.14 问与答 544

21.15 习题 545

21.15.1 测验 545

21.15.2 练习 545

第三篇内容回顾 546

A.1 其他进制 557

附录A 二进制和十六进制 557

A.2 进制的转换 558

A.2.1 二进制 559

A.2.2 为什么用二进制 559

A.2.3 位、字节和半字节 560

A.2.4 什么是kB(千字节) 560

A.2.5 二进制数 560

A.3 十六进制 560

附录B C++关键字 564

附录C 运算符的优先级 565

附录D 答案 566