零基础学C++：12小时多媒体教学视频 第3版PDF电子书下载

第一篇 C++基础 1

第1章 C++概述 1

1.1 了解计算机 1

1.1.1 计算机硬件 1

1.1.2 计算机软件 2

1.2 程序设计语言 3

1.2.1 机器语言 3

1.2.2 汇编语言 4

1.2.3 高级语言 4

1.2.4 数据结构和算法 5

1.2.5 面向过程的程序设计（POP） 6

1.2.6 面向对象的程序设计（OOP） 6

1.3 C++概述 7

1.3.1 C++语言发展历程 7

1.3.2 C++语言特点&. 7

1.3.3 C++程序开发基本过程 8

1.4 C++开发环境的搭建 8

1.4.1 Visual C++6开发环境简介 9

1.4.2 开发步骤 9

1.5 第一个C++程序 11

1.6 C语言与C++语言的区别 12

1.6.1 程序设计思想的区别 12

1.6.2 语法规范的区别 12

1.7 小结 13

1.8 习题 13

第2章 开始C++之旅 14

2.1 C++程序的结构 14

2.1.1 C++的注释风格 15

2.1.2 编译预处理与新旧标准 15

2.1.3 主函数 15

2.1.4 名称空间 16

2.1.5 C++语素 18

2.1.6 缩进与对齐 19

2.2 变量与基本类型 21

2.2.1 变量 21

2.2.2 整型 22

2.2.3 浮点型 23

2.2.4 基本字符型 23

2.2.5 宽字符型 24

2.2.6 布尔型 24

2.3 常量 25

2.3.1 整型常量和浮点型常量 25

2.3.2 字符型常量 26

2.3.3 字符串常量 28

2.3.4 符号常量 28

2.3.5 枚举常量 29

2.4 运算符与表达式 30

2.4.1 算术运算 30

2.4.2 逻辑运算 32

2.4.3 短路表达式 32

2.4.4 关系运算 33

2.4.5 大有文章：变量是否为“0” 33

2.4.6 条件运算 34

2.4.7 位运算 34

2.4.8 赋值运算 37

2.4.9 ++和-- 38

2.4.10 逗号表达式 39

2.4.11 sizeof运算符与sizeof表达式 40

2.4.12 运算符的优先级和结合性 40

2.5 类型转换 42

2.5.1 赋值转换 42

2.5.2 表达式中的转换 44

2.5.3 强制类型转换 45

2.5.4 函数调用和传递参数时的类型转换 46

2.6 流程控制语句 46

2.6.1 if...else...选择结构 46

2.6.2 switch结构 49

2.6.3 if...else...结构和switch结构的比较 52

2.6.4 for循环结构 52

2.6.5 for循环结构嵌套 53

2.6.6 while循环结构 54

2.6.7 do...while循环结构 55

2.6.8 循环语句的效率 56

2.6.9 流程转向控制语句之break 56

2.6.10 流程转向控制语句之continue 57

2.6.11 流程转向控制语句之goto 58

2.6.12 程序终止函数exit() 58

2.7 小结 59

2.8 习题 59

第二篇 C++过程开发 61

第3章 数组和C风格字符串 61

3.1 什么是数组 61

3.2 一维数组 62

3.2.1 一维数组的声明 62

3.2.2 初始化一维数组 63

3.2.3 一维数组应用举例 64

3.2.4 数组操作注意事项 64

3.3 C风格字符串 65

3.3.1 C风格字符串的声明 65

3.3.2 字符数组的cin和cout 66

3.3.3 get()函数和getline()函数 67

3.3.4 cin与get()/getline()函数的搭配问题 68

3.3.5 访问C风格字符串中的某个元素 68

3.3.6 C风格字符串处理函数 69

3.4 二维数组及多维数组 70

3.4.1 声明一个二维数组 71

3.4.2 初始化二数组 71

3.4.3 二维数组应用举例 72

3.4.4 二维数组在内存中是如何排列元素的 73

3.4.5 三维数组在内存中是如何排列元素的 73

3.5 小结 73

3.6 习题 74

第4章 指针和引用 75

4.1 指针的定义与使用 75

4.1.1 为什么使用指针 75

4.1.2 声明一个指针变量 76

4.1.3 初始化指针变量 78

4.1.4 指向指针的指针 79

4.1.5 指针赋值 79

4.2 指针的运算 80

4.2.1 指针与整数的加减 80

4.2.2 同类型指针间的比较 81

4.2.3 同类型指针相减 81

4.3 动态内存分配 81

4.3.1 使用new动态分配内存 82

4.3.2 使用delete释放动态申请的内存 82

4.3.3 使用new申请动态数组 82

4.3.4 不要使用或释放已经释放的内存块 83

4.3.5 使用malloc和free动态申请内存 84

4.3.6 动态内存申请并不一定能成功 85

4.4 指针和const 86

4.4.1 禁止改写指针（常量指针或常指针） 86

4.4.2 禁止改写间接引用 86

4.4.3 既禁止改写指针，又禁止改写间接引用 87

4.5 指针与数组 87

4.5.1 数组名指针 87

4.5.2 数组元素的指针形式 88

4.5.3 指向数组的指针（数组指针） 89

4.5.4 指针数组 91

4.5.5 指针与多维数组 93

4.5.6 指针与字符数组 93

4.6 引用 94

4.6.1 引用的声明 94

4.6.2 引用的特点 94

4.6.3 引用的使用限制 95

4.6.4 其他要说明的问题 95

4.7 小结 96

4.8 习题 96

第5章 结构、共用体和链表 98

5.1 结构 98

5.1.1 如何定义一个结构 98

5.1.2 结构变量的声明和使用 99

5.1.3 结构变量的初始化 100

5.1.4 结构变量间是否可以相互赋值 101

5.1.5 结构体变量的sizeof 102

5.1.6 结构体的复杂形式 103

5.2 共用体 105

5.2.1 共用体的定义 105

5.2.2 共用体和结构的区别 105

5.2.3 共用体变量的声明和初始化 106

5.2.4 共用体使用举例 107

5.2.5 共用体的sizeof 108

5.3 结构数组和共用体数组 109

5.3.1 结构数组的声明和初始化 109

5.3.2 共用体数组的声明和初始化 110

5.4 指向结构的指针 111

5.4.1 声明一个结构指针 111

5.4.2 结构指针的初始化 111

5.4.3 使用指针访问结构成员 113

5.5 链表 114

5.5.1 链表的结构 114

5.5.2 创建链表 114

5.5.3 链表与数组的区别 115

5.5.4 链表的遍历和查找 116

5.5.5 链表的插入和删除 117

5.5.6 删除整个链表 120

5.6 小结 121

5.7 习题 121

第6章 用函数合理组织程序 124

6.1 模块化带来的好处 124

6.1.1 函数的调用过程 124

6.1.2 抽象和封装 125

6.1.3 实现一个函数 126

6.2 函数定义 126

6.2.1 函数头 127

6.2.2 函数体 127

6.2.3 函数定义补充说明 128

6.2.4 函数的返回值 129

6.3 函数声明 130

6.3.1 为什么要进行函数声明 130

6.3.2 如何声明一个函数 131

6.3.3 分割程序文件 132

6.4 函数调用 133

6.4.1 形参和实参 134

6.4.2 参数类型转换 135

6.4.3 值传递 135

6.4.4 指针传递 136

6.4.5 引用传递 137

6.4.6 对3种传递的补充 138

6.4.7 缺省参数调用 140

6.4.8 内联函数irline 142

6.5 递归 143

6.6 函数的重载 145

6.6.1 什么是函数重载 145

6.6.2 何时使用函数重载 145

6.6.3 如何实现函数重载 146

6.6.4 陷阱：隐式转换导致重载函数出现二义性 147

6.7 C++如何使用内存 148

6.7.1 自动存储（栈存储） 148

6.7.2 静态存储（编译器预分配） 150

6.8 作用域与可见域 155

6.8.1 作用域 155

6.8.2 可见域 155

6.8.3 函数的作用域和可见域 158

6.9 小结 158

6.10 习题 159

第7章 关于函数的高级专题 160

7.1 内存使用错误剖析 160

7.1.1 内存泄露 160

7.1.2 野指针 161

7.1.3 试图修改常量 162

7.1.4 用错sizeof 163

7.1.5 内存越界访问 163

7.1.6 变量的初始化 163

7.2 重申：函数参数传递和返回机制 164

7.2.1 参数传递时的“副本” 164

7.2.2 函数返回时的“副本” 165

7.3 函数与指针 167

7.3.1 指向函数的指针 167

7.3.2 typedef关键字 168

7.3.3 通过函数指针将函数作为另一个函数的参数 170

7.3.4 函数指针数组 171

7.3.5 返回函数指针的函数 172

7.3.6 带参主函数 173

7.4 函数与数组 174

7.4.1 数组名作函数参数 174

7.4.2 通过指针得到多于1个的回传值 176

7.5 函数与结构体、共用体及类对象 177

7.5.1 3种参数调用 177

7.5.2 3种返回机制 179

7.6 函数编写的建议 179

7.6.1 合理使用const 179

7.6.2 检查输入参数的有效性 180

7.6.3 函数返回类型的判断 180

7.7 小结 180

7.8 习题 181

第三篇 面向对象的C++ 183

第8章 面向对象编程基础 183

8.1 面向对象的基本概念 183

8.1.1 面向对象开发的优势 184

8.1.2 什么是类 186

8.1.3 类是分层的 186

8.1.4 类和对象的关系 187

8.2 C++类的定义 188

8.2.1 类定义的基本形式 188

8.2.2 类定义示例 188

8.2.3 类和结构体 189

8.3 C++类的实现 190

8.3.1 在类定义时定义成员函数 190

8.3.2 在类定义的外部定义成员函数 191

8.4 C++类的使用 192

8.4.1 声明一个对象 192

8.4.2 对象的作用域、可见域和生存期 193

8.5 对象的创建和撤销 194

8.5.1 构造函数的作用 194

8.5.2 构造函数可以有参数 195

8.5.3 构造函数支持重载 196

8.5.4 构造函数允许按参数默认方式调用 197

8.5.5 初始化表达式 197

8.5.6 析构函数 199

8.5.7 显式调用析构函数 200

8.6 复制构造函数 200

8.6.1 复制构造函数调用机制 201

8.6.2 默认复制构造函数带来的问题 202

8.6.3 解决方案——显式定义复制构造函数 204

8.6.4 关于构造函数和复制构造函数 205

8.7 特殊数据成员 206

8.7.1 const数据成员 206

8.7.2 引用成员 208

8.7.3 类对象成员 210

8.7.4 static数据成员 214

8.8 特殊函数成员 216

8.8.1 静态成员函数 216

8.8.2 const与成员函数 218

8.9 对象的组织 219

8.9.1 const对象 219

8.9.2 指向对象的指针 220

8.9.3 对象的大小 221

8.9.4 this指针 223

8.9.5 对象数组 225

8.9.6 对象链表 226

8.10 为对象动态分配内存 226

8.10.1 使用new和delete为单个对象分配／释放动态内存 226

8.10.2 使用new和delete[]为对象数组分配／释放动态空间 227

8.10.3 malloc/free与new/delete 228

8.11 小结 229

8.12 习题 230

第9章 关于对象的高级专题 232

9.1 类的作用域 232

9.2 类定义的作用域与可见域 234

9.3 对象的生存期、作用域和可见域 236

9.3.1 先定义，后实例化 236

9.3.2 对象内存释放与堆内存 237

9.4 友元 237

9.4.1 认识友元函数 237

9.4.2 友元的非成员函数 238

9.4.3 友元的成员函数 239

9.4.4 友元函数的重载 241

9.4.5 友元类 241

9.4.6 友元是否破坏了封装性 243

9.5 运算符重载 243

9.5.1 运算符重载规则 243

9.5.2 运算符重载的优点 244

9.5.3 以成员函数形式重载运算符 244

9.5.4 以友元函数形式重载运算符 248

9.5.5 友元函数形式和成员函数形式的比较 250

9.5.6 对运算符重载的补充说明 252

9.6 运算符重载范例 252

9.6.1 赋值运算符 252

9.6.2 函数调用运算符 255

9.6.3 下标运算符 256

9.7 类型转换 257

9.7.1 由其他类型向定义类的转换 258

9.7.2 由自定义类向其他类型的转换 260

9.7.3 隐式转换带来的二义性 261

9.8 小结 262

9.9 习题 262

第10章 继承 265

10.1 什么是继承 265

10.1.1 简单示例 265

10.1.2 继承的层次性 267

10.2 基类和派生类 267

10.2.1 基类 267

10.2.2 public派生与private派生 269

10.2.3 protected成员与protected派生 269

10.3 多基派生 270

10.3.1 多基派生的声明和定义 270

10.3.2 二义性问题 271

10.3.3 消除二义性的解决方案 272

10.4 虚基类 272

10.4.1 共同基类带来的二义性 272

10.4.2 解决共同基类带来的二义性 274

10.4.3 虚基派生二义性与多基派生二义性不同 275

10.5 派生类的构造函数和析构函数 275

10.5.1 派生类的构造函数 275

10.5.2 派生类的析构函数 277

10.5.3 多基派生类的构造函数和析构函数 278

10.5.4 虚基派生的构造函数和析构函数 279

10.6 分清继承还是组合 281

10.6.1 继承不是万能的 282

10.6.2 组合 282

10.7 基类与派生类对象间的相互转换 283

10.7.1 类型适应 283

10.7.2 多基继承时的情况 285

10.7.3 公共基类 286

10.7.4 虚基类的情况 287

10.8 小结 289

10.9 习题 289

第11章 多态 292

11.1 多态与虚函数 292

11.1.1 静态联编 292

11.1.2 动态联编 293

11.1.3 为什么需要虚函数 294

11.1.4 虚函数的声明和定义 296

11.2 虚函数的访问 297

11.2.1 对象名访问 298

11.2.2 基指针访问 298

11.2.3 引用访问 299

11.2.4 类内访问 299

11.2.5 在构造函数或析构函数中进行访问 301

11.3 纯虚函数与抽象类 301

11.3.1 纯虚函数的声明和定义 302

11.3.2 抽象类 303

11.3.3 另一种抽象类：类中只定义了protected型的构造函数 306

11.3.4 延伸：构造函数能否为private型 307

11.3.5 虚析构函数 308

11.4 虚函数引入的二义性 311

11.4.1 多基派生 311

11.4.2 共同基类和虚继承 314

11.5 重载、覆盖与隐藏 315

11.5.1 重载 315

11.5.2 覆盖 316

11.5.3 隐藏 317

11.6 小结 318

11.7 习题 318

第四篇 泛型编程 321

第12章 模板 321

12.1 为什么要定义模板 321

12.1.1 类型参数化 321

12.1.2 模板的定义 323

12.2 函数模板 324

12.2.1 函数模板的定义 324

12.2.2 函数模板的使用 324

12.2.3 隐式实例化 324

12.2.4 显式实例化 326

12.2.5 特化 327

12.2.6 重载 328

12.2.7 优先级与执行顺序 328

12.3 类模板 330

12.3.1 定义类模板 330

12.3.2 隐式实例化 332

12.3.3 显式实例化 332

12.3.4 .显式特化 332

12.3.5 部分特化 333

12.3.6 重载和优先级 334

12.4 模板的嵌套 334

12.4.1 函数成员模板 335

12.4.2 对象成员模板 335

12.5 模板参数 337

12.6 小结 337

12.7 习题 338

第13章 标准模板库 340

13.1 理解STL 340

13.1.1 容器 340

13.1.2 适配器 341

13.1.3 迭代器 341

13.1.4 算法 341

13.2 使用序列式容器 341

13.2.1 序列式容器的创建和元素的访问 341

13.2.2 所有容器都支持的特征 343

13.2.3 序列式容器中元素的插入和删除 344

13.2.4 vector容器、deque容器和list容器的比较 348

13.3 使用关联式容器 349

13.3.1 set容器 349

13.3.2 multiset容器 350

13.3.3 map容器 351

13.3.4 multimap容器 352

13.4 关联式容器支持的成员函数操作 353

13.4.1 元素的插入 353

13.4.2 元素的删除 356

13.4.3 元素的查找与访问 358

13.5 迭代器 358

13.5.1 理解迭代器的本质 359

13.5.2 迭代器的5种类型简介 359

13.5.3 为什么要定义这么多迭代器 360

13.5.4 容器中定义的迭代器类型与5种类型的对应 361

13.5.5 流迭代器 362

13.5.6 前向迭代器、双向迭代器和随机访问迭代器 363

13.5.7 混合迭代器函数 364

13.5.8 迭代器失效 364

13.6 泛型算法 365

13.6.1 什么是函数对象 365

13.6.2 算法分类 366

13.7 适配器 370

13.7.1 容器适配器 370

13.7.2 迭代器适配器 372

13.7.3 函数适配器 373

13.8 小结 375

13.9 上机实践习题 375

第五篇 输入输出处理和编程规范 377

第14章 输入输出和文件 377

14.1 输入／输出概述 377

14.1.1 什么是文件 377

14.1.2 流 378

14.1.3 缓冲区 379

14.1.4 重定向 379

14.1.5 3种输入／输出机制 380

14.2 高层I/O 381

14.2.1 标准输出函数printf() 381

14.2.2 标准输入函数scanf() 384

14.2.3 扫描集 387

14.2.4 sprintf()函数和sscanf()函数 388

14.2.5 fprintf()函数和fscanf()函数 390

14.2.6 文件访问机制 390

14.3 流类库 394

14.3.1 流类库更安全、更高效 394

14.3.2 流类库层次 395

14.4 输出流 398

14.4.1 操作符<< 398

14.4.2 其他ostream方法 399

14.4.3 格式状态字 401

14.4.4 格式控制值的默认值 402

14.4.5 flag()函数读取和设定格式状态字 402

14.4.6 使用setf()函数和unsetf()函数设定格式关键字 404

14.4.7 设置域宽 406

14.4.8 填充字符 408

14.4.9 浮点数输出和显示精度 408

14.4.10 控制符 409

14.5 输入流 411

14.5.1 >>操作符 411

14.5.2 输入流与格式状态字 412

14.5.3 输入流与域宽 414

14.5.4 使用get()函数读取单个字符 415

14.5.5 使用get()和getline()函数读取C风格字符串 417

14.5.6 其他istream方法 418

14.6 流状态 420

14.6.1 什么是流状态 420

14.6.2 读取流状态 420

14.6.3 管理流状态 421

14.7 重载>>和<< 423

14.7.1 插入符的重载 423

14.7.2 抽取符的重载 424

14.8 文件操作 425

14.8.1 文件操作基本过程 426

14.8.2 文件的打开 426

14.8.3 取消文件和流的关联 428

14.8.4 文件的读写 429

14.8.5 文本文件的读写 429

14.8.6 二进制文件的读写 430

14.8.7 文件的定位和随机读取 431

14.9 小结 433

14.10 习题 433

第15章 命名空间 435

15.1 什么是命名空间 435

15.1.1 命名空间范例 435

15.1.2 定义命名空间 436

15.2 实体的作用域与可见域 437

15.2.1 实体可见域 437

15.2.2 可见域的扩展 438

15.2.3 using声明机制 439

15.2.4 using声明带来的多重声明问题（二义性） 441

15.2.5 空间内的“屏蔽” 441

15.2.6 先声明，后使用 442

15.3 命名空间的作用域与可见性 442

15.3.1 命名空间的定义策略 442

15.3.2 推荐用法 445

15.3.3 命名空间嵌套 446

15.3.4 using编译指令 447

15.3.5 using编译指令与using声明的对比 448

15.3.6 未命名的命名空间 449

15.4 对命名空间的思考 449

15.5 小结 449

15.6 习题 450

第16章 string字符串类 451

16.1 为什么要使用string类 451

16.2 声明一个字符串 451

16.3 字符串的输入输出 453

16.4 string类的功能 454

16.5 小结 457

16.6 习题 457

第17章 异常和错误 459

17.1 编码时的防错 459

17.1.1 使用断言 459

17.1.2 调用abort()函数或exit()函数 461

17.1.3 返回错误标志 462

17.2 异常机制 463

17.2.1 关键字throw 464

17.2.2 异常处理程序 465

17.2.3 自定义异常对象 468

17.2.4 有继承关系的类异常 469

17.2.5 terminate()函数和set_terminate()函数 470

17.2.6 unexpected()函数与set_unexpected()函数 471

17.2.7 标准异常 472

17.2.8 对unexpected()函数的补充 474

17.3 异常发生时的内存管理 475

17.3.1 堆栈解退 475

17.3.2 异常处理机制和函数的不同 476

17.3.3 构造函数中抛出异常 477

17.3.4 内存泄露 478

17.3.5 析构函数中可否抛出异常 479

17.4 小结 480

17.5 习题 481

第18章 程序编译 483

18.1 程序的编译流程 483

18.1.1 编辑 483

18.1.2 预处理和编译 483

18.1.3 链接 484

18.2 预处理 484

18.2.1 头文件包含 485

18.2.2 宏 485

18.2.3 条件编译 486

18.2.4 #ifdef、#ifndef与重复包含 487

18.2.5 使用const代替＃define定义常量 488

18.2.6 inline与#define的比较 489

18.3 VC 6调试入门 489

18.4 小结 492

18.5 习题 492

第六篇 面试题精选 495

第19章 教学管理系统的C++实现 495

19.1 项目概述 495

19.2 自定义类 496

19.3 实现自定义类 499

19.3.1 新建C++头文件和实现文件 499

19.3.2 实现类功能 502

19.4 使用自定义类 510

19.4.1 复制自定义类文件到工程目录下 510

19.4.2 包含类的头文件 511

19.4.3 创建类实例对象 512

19.4.4 调用对象成员完成相应功能 512

19.5 制作个性化系统界面 513

19.5.1 Visual C++控件介绍 513

19.5.2 制作个性化的系统界面 514

19.6 在控件消息响应函数中使用自定义类功能 517

19.6.1 为控件添加消息响应函数 517

19.6.2 为界面中的控件关联变量名 518

19.6.3 在消息响应函数中调用类成员 518

19.7 使用文件保存数据 522

19.7.1 创建文件实例对象 522

19.7.2 打开文件 523

19.7.3 格式化读取文件 524

19.7.4 格式化写入文件 524

19.7.5 关闭文件 525

19.7.6 实例程序 526

19.8 小结 530

第20章 常见面试题 531

20.1 常见基本知识问答题 531

面试题1：简述面向对象的三个基本特征 531

面试题2：局部变量能否和全局变量重名 531

面试题3：类成员函数的重载、覆盖和隐藏的区别是什么 532

面试题4：用变量a给出下面的定义 532

面试题5：在C++中，下面的结构是合法的吗？如果合法，其作用是什么 532

面试题6：非C++内建类A和B，在哪几种情况下B能隐式转化为A 533

面试题7：C++中的空类默认产生哪些类成员函数 533

面试题8：C++有哪些性质（面向对象特点） 533

面试题9：子类析构时要调用父类的析构函数吗 533

面试题10：什么是“引用”？声明和使用“引用”要注意哪些问题？ 534

面试题11：将“引用”作为函数返回值类型的格式及优点有哪些 534

面试题12： “引用”与指针的区别是什么 534

面试题13：重载和重写（“覆盖”）的区别 534

面试题14：多态的作用是什么 534

面试题15： const与#define相比有何优点 534

面试题16：C语言中的static关键字有何作用 535

面试题17：如何判断程序是由C编译程序编译的还是由C++编译程序编译的 535

面试题18：关键字const的含义是什么 535

20.2 世界500强公司的智力问答题 536

面试题19：工人分金条 536

面试题20：分蛋糕 536

面试题21：过桥问题 536

面试题22：黑白帽子 537

面试题23：电梯与钻石 537

面试题24：手电筒传递 537

面试题25：烧绳问题 538

面试题26：圆的下水道盖子 538

面试题27：选建筑师 538

面试题28：天平分盐 538

面试题29：分不开的钱 538

面试题30：小鸟追火车 539

面试题31：给红色最大的机会 539

面试题32：镜子中的影像 539

面试题33：污染的药丸 539

面试题34：称出不是标准重量的水 539

面试题35：多彩的果冻 540

面试题36：电子游戏机 540

面试题37：监狱里的囚犯 540

面试题38：灯的状态 540

面试题39：时针和分针 541

面试题40：3个奇数 541

面试题41：屋内的灯 542

面试题42：找出最重的球 542

面试题43：盲人分袜子 542

面试题44：烧香计时 542

面试题45：平分蜂蜜 542

面试题46：猜经理女儿的年龄 543

面试题47：两个圆环 543

面试题48：喝啤酒 543

面试题49：算24点 543

面试题50：聪明人 544

面试题51：海盗分金币 544

面试题52：到底是什么牌 545

面试题53：聪明的老板娘 545

面试题54：找出不同重量的球 546

20.3 分析题 546

面试题55：分析下面的程序段，显示最后的结果 546

面试题56：分析程序最后的输出结果 547

面试题57：分析最后输出的结果 547

面试题58：求下面函数的返回值 548

面试题59：分析最后输出的结果 548

面试题60：分析最后输出的结果 549

20.4 编程题 550

面试题61：结果输出到文件 551

面试题62：String类的具体实现 552

面试题63：链表题——一个链表的结点结构 553

面试题64：写一个函数并找出在一个整数数组中第二大的数 555

面试题65：字符串的逆序输出 555

面试题66：判断操作系统的位数 556

面试题67：实现对数组的降序排序 556

面试题68：斐波那契数列1，1，2，3，5……编写程序求第10项 557