24学时攻克C++ 原书第4版PDF电子书下载

目录 1

前言 1

第一部分　C＋＋概述 1

第1学　时开始 1

1.1　准备编程 1

1.2　澄清对C＋＋、ANSI C＋＋、ISO C＋＋和Windows的一些观点 1

1.3　安装和设置编译器 2

1.3.1　从光盘进行安装 2

1.3.2　配置Borland C＋＋BuilderX编译器 3

1.3.3　使用Borland C＋＋BuilderX编译器进行编译 4

1.3.4　编译器和编辑器 5

1.4　编译和连接源代码 5

1.5　开发周期 6

1.4.2　连接程序 6

1.4.1　在集成开发环境中进行编译 6

1.6　HELLO.CPP——第一个C＋＋程序 7

1.7　编译错误 8

1.8　问与答 9

1.9　课外作业 10

1.9.1　测验 10

1.9.2　练习 10

1.9.3　测验答案 10

第2学　时C＋＋程序的组成 11

2.1　为什么C＋＋是正确的选择 11

2.1.1　过程化、结构化和面向对象程序设计 11

2.1.2　C＋＋和面向对象程序设计 12

2.2　简单程序的组成 13

2.2.2　逐行分析 14

2.2.1　逐字符地查看＃include 14

2.3.1　注释的类型 15

2.3　注释 15

2.3.2　在简单的范例程序中使用注释 16

2.4　函数 16

2.4.1　调用函数 16

2.4.2　使用函数 17

2.4.3　使用带有参数的函数 18

2.5　问与答 18

2.6　课外作业 19

2.6.1　测验 19

2.6.2　练习 19

2.6.3　测验答案 19

3.1.1　设置内存 20

第3学时 变量和常量 20

3.1　变量是什么 20

3.1.2　整数的长度 21

3.1.3　带符号和无符号 22

3.1.4　基本变量类型 22

3.2　定义变量 23

3.2.1　区分大小写 23

3.2.2　关键字 24

3.3　一次创建多个变量 24

3.4　为变量赋值 24

3.5　typedef 25

3.6　何时使用短型，何时使用长型 26

3.6.1　无符号整数的回绕 26

3.6.2　带符号整数的回绕 27

3.7　常量 28

3.7.1　文字常量 28

3.7.2　符号常量 28

3.8　枚举常量 29

3.9　问与答 29

3.10　课外作业 30

3.10.1　测验 30

3.10.2　练习 30

3.10.3　测验答案 30

第4学　时表达式和语句 31

4.1　语句 31

4.1.1　空白字符 31

4.1.2　复合语句 31

4.2　表达式 32

4.3　操作符 33

4.3.1　赋值操作符 33

4.3.2　数学操作符 33

4.3.3　组合赋值和数学操作符 34

4.3.4　自增和自减操作符 34

4.3.5　放在前缀和后缀位置的操作符 35

4.3.6　优先级：操作符的顺序 36

4.4　复杂表达式的嵌套括号 37

4.5　if语句 39

4.5.1　else子句 39

4.5.2　高级if语句 40

4.5.3　在嵌套的if语句中使用花括号 42

4.6　关于逻辑操作符的更多讲解 43

4.6.4　关系优先级 44

4.6.3　逻辑非 44

4.6.1　逻辑与 44

4.6.2　逻辑或 44

4.7　关于真和假的更多讲解 45

4.8　问与答 45

4.9　课外作业 46

4.9.1　测验 46

4.9.2　练习 46

4.9.3　测验答案 46

第5学时　函数 47

5.1　函数是什么 47

5.2　声明和定义函数 47

5.2.1　声明函数 48

5.2.2　定义函数 49

5.3.1　局部变量 50

5.2.3　函数定义的说明 50

5.3　在函数内使用变量 50

5.3.2　全局变量 52

5.4　函数参数 52

5.4.1　以函数调用作为参数 53

5.4.2　参数也是局部变量 53

5.5　从函数返回值 54

5.6　函数中的默认参数 57

5.7　重载函数 58

5.7.1　内联函数 58

5.7.2　堆栈和函数 60

5.9.3　测验答案 62

5.9.2　练习 62

5.9.1　测验 62

5.9　课外作业 62

5.8　问与答 62

第6学时　程序流 64

6.1　循环 64

6.1.1　循环的根源goto 64

6.1.2　为什么不使用goto 64

6.2　while循环 64

6.2.1　更复杂的while语句 65

6.2.2　continue和break 66

6.2.3　while(1)循环 68

6.3　do…while循环 69

6.4　for循环 70

6.4.1　初始化、测试和自增 71

6.4.2　高级for循环 72

6.4.3　空for循环 74

6.4.4　嵌套的循环 75

6.5　switch语句 76

6.6　问与答 77

6.7　课外作业 78

6.7.1　测验 78

6.7.2　练习 78

6.7.3　测验答案 78

第二部分　类 79

第7学时　基本的类 79

7.1　类型是什么 79

7.2　创建新的类型 79

7.3.1　声明类 80

7.3　类和成员 80

7.3.2　类的命名惯例 81

7.3.3　定义对象 81

7.3.4　类和对象 81

7.4　访问类成员 81

7.5　私有访问和公共访问 82

7.6　实现类方法 83

7.7　构造器和析构器，即创建和删除对象 85

7.7.1　默认构造器 85

7.7.2　编译器提供的构造器 86

7.9.1　测验 88

7.9.2　练习 88

7.9.3　测验答案 88

7.9　课外作业 88

7.8　问与答 88

第8学时 关于类的更多讲解 89

8.1　const成员函数 89

8.2　接口和实现 89

8.3　把类声明和方法定义放在哪里 90

8.4　内联实现 91

8.5　使用其他类作为成员数据的类 92

8.6　问与答 96

8.7　课外作业 97

8.7.1　测验 97

8.7.2　练习 97

8.7.3　测验答案 97

第三部分　内存管理 99

第9学时　指针 99

9.1　了解指针及其用途 99

9.1.1　在指针内存储地址 101

9.1.3　间接操作符，即间接使用指针 102

9.1.2　指针名称 102

9.1.4　指针、地址和变量 103

9.1.5　使用指针操作数据 104

9.1.6　检查指针内存储的地址 104

9.2　为什么要使用指针 106

9.3　堆栈和堆 106

9.3.1　使用new关键字 107

9.3.2　使用delete关键字 108

9.3.3　避免内存泄漏 109

9.4　问与答 110

9.5　课外作业 110

9.5.1　测验 110

9.5.3　测验答案 111

9.5.2　练习 111

第10学时　高级指针 112

10.1　在堆中创建对象 112

10.2　删除对象 112

10.3　使用指针访问数据成员 113

10.4　堆中的成员数据 114

10.5　this指针 115

10.6　迷失或者悬挂指针 117

10.7　const指针 117

10.7.1　const指针和const成员函数 118

10.7.2　const this指针 119

10.8　问与答 119

10.9.3　测验答案 120

10.9.2　练习 120

10.9.1　测验 120

10.9　课外作业 120

第11学时　引用 121

11.1　什么是引用 121

11.2　创建引用 121

11.3　对引用使用取地址操作符 122

11.4　什么能够引用 125

11.5　空指针和空引用 125

11.6　按引用传递函数参数 125

11.6.1　使用指针实现swap() 126

11.6.2　使用引用实现swap() 127

11.7　理解函数头和原型 128

11.8　返回多个值 129

11.10.1　测验 131

11.10　课外作业 131

11.9　问与答 131

11.10.2　练习 132

11.10.3　测验答案 132

第12学时 高级引用和指针 133

12.1　按引用进行传递以提高效率 133

12.2　传递const指针 135

12.3　引用作为指针的另一种方式 137

12.4　何时使用引用和指针 139

12.5　不要返回不在范围内的对象的引用 139

12.6　返回堆中的对象的引用 140

12.7　谁拥有指针 142

12.8　问与答 142

12.9.3　测验答案 143

12.9.2　练习 143

12.9　课外作业 143

12.9.1　测验 143

第四部分　强大的工具 145

第13学时 高级函数 145

13.1　重载的成员函数 145

13.2　使用默认值 147

13.3　在默认值和重载的函数之间进行选择 148

13.4　重载构造器 148

13.5　初始化对象 149

13.6　拷贝构造器 149

13.8.1　测验 153

13.8.3　测验答案 153

13.8.2　练习 153

13.8　课外作业 153

13.7　问与答 153

第14学时 操作符重载 154

14.1　如何重载操作符 154

14.1.1　编写自增函数 155

14.1.2　重载后缀操作符 156

14.1.3　前缀和后缀之间的区别 156

14.1.4　operator+ 158

14.1.5　重载operator+ 159

14.1.6　操作符重载的局限性 160

14.1.7　何时需要重载 160

14.1.8　operator 160

14.2　转换操作符 162

14.4　课外作业 165

14.3　问与答 165

14.4.1　测验 166

14.4.2　练习 166

14.4.3　测验答案 166

第15学时　数组 167

15.1　数组是什么 167

15.2　数组元素 167

15.3　写入超出数组的结尾 168

15.4　栅栏错误 169

15.5　初始化数组 169

15.6　对象数组 169

15.7　多维数组 171

15.9　指针数组 173

15.8　关于内存的讲解 173

15.10　在堆中声明数组 174

15.11　指向数组的指针和指针数组 175

15.12　指针和数组名称 175

15.13　在堆中删除数组 177

15.14　char数组 177

15.15　strcpy()和strncpy() 179

15.16　字符串类 180

15.17　问与答 181

15.18　课外作业 181

15.18.1　测验 181

15.18.2　练习 181

15.18.3　测验答案 181

16.1　继承是什么 183

16.1.1　继承和派生 183

第五部分　继承和多态性 183

第16学时　继承 183

16.1.2　使用动物王国解释继承 184

16.1.3　派生的语法 185

16.2　私有的和保护的 186

16.3　构造器和析构器 188

16.4　把参数传递给基类构造器 190

16.5　覆盖函数 193

16.5.1　重载和覆盖 195

16.5.2　隐藏基类方法 195

16.5.3　调用基类方法 196

16.6　问与答 197

16.7.2　练习 198

16.7.3　测验答案 198

16.7.1　测验 198

16.7　课外作业 198

第17学时 多态性和派生类 199

17.1　使用虚方法实现多态性 199

17.1.1　虚成员函数如何工作 202

17.1.2　不能用父类指针调用子类的方法 203

17.1.3　限制 203

17.1.4　虚析构器 205

17.1.5　虚拷贝构造器 205

17.1.6　虚方法的代价 208

17.2　问与答 208

17.3　课外作业 208

17.3.1　测验 208

17.3.2　练习 208

17.3.3　测验答案 209

第18学时　高级多态性 210

18.1　单一继承的问题 210

18.2　抽象数据类型 213

18.2.1　纯虚函数 216

18.2.2　实现纯虚函数 219

18.2.3　抽象的复杂层次结构 222

18.2.4　什么类型是抽象的 225

18.3　问与答 225

18.4　课外作业 226

18.4.1　测验 226

18.4.2　练习 226

18.4.3　测验答案 226

19.2.1　责任的委托 227

19.2　使用链表的实例研究 227

19.1　链表和其他结构 227

第19学时　链表 227

19.2.2　组件组成 228

19.3　关于链表 235

19.4　问与答 236

19.5　课外作业 236

19.5.1　测验 236

19.5.2　练习 236

19.5.3　测验答案 236

第六部分　特殊主题 237

第20学时 特殊的类、函数和指针 237

20.1　静态成员数据 237

20.2　静态成员函数 239

20.3　类的包含 240

20.3.2　过滤对被包含成员的访问 245

20.3.1　访问被包含类的成员 245

20.3.4　按值拷贝和按引用拷贝 246

20.4　友元类 246

20.3.3　包含的代价 246

20.5　友元函数 247

20.6　指向函数的指针 247

20.6.1　简写调用 249

20.6.2　指向函数的指针数组 249

20.6.3　把指向函数的指针传递给其他函数 252

20.6.4　对指向函数的指针使用typedef 254

20.6.5　指向成员函数的指针 256

20.6.6　指向成员函数的指针数组 258

20.8.1　测验 260

20.8.2　练习 260

20.8　课外作业 260

20.7　问与答 260

20.8.3　测验答案 261

第21学时　预处理器 262

21.1　预处理器和编译器 262

21.2　查看中间形式 262

21.3　使用＃define指令 262

21.3.1　对常量使用＃define 262

21.3.2　使用＃define和＃ifdef进行测试 262

21.3.3　＃else预处理器命令 263

21.4　包含和包含防护 264

21.4.3　条件编译 265

21.5　宏函数 265

21.4.2　反定义 265

21.4.1　在命令行上进行定义 265

21.5.1　为什么总需要括号 266

21.5.2　宏与函数和模板 267

21.6　字符串操作 267

21.6.1　字符串化操作符 267

21.6.2　串联操作符 268

21.7　预定义宏 268

21.8　问与答 281

21.9　课外作业 282

21.9.1　测验 282

21.9.2　练习 282

21.9.3　测验答案 282

22.2　模拟一个警报系统 283

22.1　开发周期 283

第22学时 面向对象分析和设计 283

22.2.1　概念化 284

22.2.2　分析和需求 284

22.2.3　高层和底层设计 284

22.2.4　其他对象 285

22.2.5　类是什么 285

22.2.6　如何报告警报 286

22.2.7　事件循环 286

22.3　PostMaster：案例研究 288

22.3.1　两次衡量，一次分隔 288

22.3.2　分治 289

22.3.3　消息格式 289

22.3.4　初始类设计 289

22.3.5　有根的层次结构和无根的层次结构 290

22.3.6　设计接口 292

22.3.8　80/80原则 293

22.3.9　设计PostMasterMessage类 293

22.3.7　构建原型 293

22.3.10　应用程序编程接口 294

22.3.11　大型团队中的编程 295

22.3.12　开发中的设计考虑 295

22.3.13　使用驱动程序 296

22.4　问与答 301

22.5　课外作业 302

22.5.1　测验 302

22.5.2　练习 302

22.5.3　测验答案 302

23.2　模板实例 303

23.3　模板定义 303

23.1　模板是什么 303

第23学时　模板 303

23.4　使用模板项 310

23.5　标准模板库 316

23.6　问与答 316

23.7　课外作业 316

23.7.1　测验 316

23.7.2　练习 317

23.7.3　测验答案 317

第24学时 异常、错误处理及其他 318

24.1　缺陷、错误、事故和代码失败 318

24.2　处理没想到的情况 319

24.3　异常 319

24.4.1　捕获异常 323

24.4　使用try和catch块 323

24.4.3　按引用捕获和多态性 324

24.4.2　多个catch规范 324

24.5　编写专业品质的代码 327

24.5.1　花括号 328

24.5.2　长行 328

24.5.3　switch语句 329

24.5.4　程序文本 329

24.5.5　标识符名称 329

24.5.6　名称的拼写和大写字母开头 330

24.5.7　注释 330

24.5.8　访问 330

24.6　其他资源 331

24.6.2　推荐书籍 331

24.6.1　在哪里获得帮助和建议 331

24.5.10　include文件 331

24.5.12　const 331

24.5.11　assert() 331

24.5.9　类定义 331

24.7　问与答 332

24.8　课外作业 333

24.8.1　测验 333

24.8.2　练习 333

24.8.3　测验答案 333

第七部分　附录 335

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

附录B　术语表 341