零基础学C++ 第2版PDF电子书下载

第一篇 C++基础 1

第1章 C++概述 1

1.1了解计算机 1

1.1.1计算机硬件 2

1.1.2计算机软件 3

1.2程序设计语言 3

1.2.1机器语言 3

1.2.2汇编语言 4

1.2.3高级语言 5

1.2.4数据结构和算法 6

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

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

1.3 C++简介 7

1.3.1 C++语言发展历程 7

1.3.2 C++语言特点 8

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

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

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

1.4.2开发步骤 10

1.5第一个C++程序 11

1.6小结 12

1.7上机实践习题 12

第2章 开始C++之旅 13

2.1 C++程序的结构 13

2.1.1注释 14

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

2.1.3主函数 14

2.1.4名称空间 16

2.1.5 C++语素 17

2.2变量与基本类型 18

2.2.1变量 18

2.2.2整型 20

2.2.3浮点型 21

2.2.4基本字符型 21

2.2.5宽字符型 22

2.2.6布尔型 22

2.3常量 22

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

2.3.2字符型常量 23

2.3.3字符串常量 25

2.3.4符号常量 26

2.3.5枚举常量 27

2.4运算符与表达式 28

2.4.1算术运算 28

2.4.2逻辑运算 30

2.4.3短路表达式 30

2.4.4关系运算 31

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

2.4.6条件运算 32

2.4.7位运算 32

2.4.8赋值运算 35

2.4.9++和-- 37

2.4.10逗号表达式 38

2.4.11 sizeof运算符与sizeof表达式 38

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

2.5类型转换 40

2.5.1赋值转换 40

2.5.2表达式中的转换 43

2.5.3强制类型转换 44

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

2.6流程控制语句 45

2.6.1 if…else…选择结构 45

2.6.2 switch结构 47

2.6.3 if…else…结构和switch结构的比较 51

2.6.4 for循环结构 51

2.6.5 for循环结构嵌套 53

2.6.6 while循环结构 54

2.6.7 do…while循环结构 54

2.6.8循环语句的效率 55

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

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

2.6.11自由转向语句goto 56

2.6.12程序中止函数exit（） 57

2.7小结 58

2.8上机实践习题 58

第二篇 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数组操作注意事项 65

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风格字符串中的某个元素 69

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

3.4多维数组 71

3.4.1声明一个多维数组 71

3.4.2初始化多维数组 72

3.4.3多维数组应用举例 72

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

3.5小结 74

3.6上机实践习题 74

第4章 指针和引用 76

4.1指针的定义与使用 76

4.1.1声明一个指针变量 76

4.1.2初始化指针变量 79

4.1.3指向指针的指针 80

4.1.4指针赋值 80

4.2指针的运算 81

4.2.1指针与整数的加减 81

4.2.2同类型指针间的比较 82

4.2.3同类型指针相减 82

4.3动态内存分配 83

4.3.1使用new动态分配内存 83

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

4.3.3使用new申请动态数组 83

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

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

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

4.4指针和const 87

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

4.4.2禁止改写间接引用 88

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

4.5指针与数组 88

4.5.1数组名指针 88

4.5.2数组元素的指针形式 90

4.5.3指向数组的指针 90

4.5.4指针数组 92

4.6引用 95

4.6.1引用的声明 95

4.6.2引用的特点 95

4.6.3引用的使用限制 96

4.6.4其他要说明的问题 97

4.7小结 97

4.8上机实践习题 98

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

5.1结构 99

5.1.1如何定义一个结构 99

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

5.1.3结构变量的初始化 102

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

5.1.5结构体变量的sizeof 103

5.2共用体 105

5.2.1共用体的定义 105

5.2.2共用体和结构的区别 105

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

5.2.4共用体使用举例 107

5.2.5共用体的sizeof 109

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

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

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

5.4指向结构的指针 111

5.4.1声明一个结构指针 111

5.4.2结构指针的初始化 112

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

5.5链表 114

5.5.1链表的结构 115

5.5.2创建链表 115

5.5.3链表与数组的区别 116

5.5.4链表的遍历和查找 116

5.5.5链表的插入和删除 118

5.6小结 121

5.7上机实践习题 122

第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.3函数声明 129

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

6.3.2如何声明一个函数 130

6.3.3分割程序文件 131

6.4函数调用 132

6.4.1形参和实参 133

6.4.2参数类型转换 133

6.4.3值传递 134

6.4.4指针传递 135

6.4.5引用传递 136

6.4.6对3种传递的补充 137

6.4.7默认参数调用 138

6.4.8 inline函数 140

6.5递归 141

6.6函数的重载 143

6.6.1何时使用函数重载 144

6.6.2如何实现函数重载 144

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

6.7 C++如何使用内存 145

6.7.1自动存储（栈存储） 145

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

6.8作用域与可见域 152

6.8.1作用域 153

6.8.2可见域 153

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

6.9小结 156

6.10上机实践习题 157

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

7.1内存使用错误剖析 158

7.1.1内存泄露 158

7.1.2野指针 159

7.1.3试图修改常量 160

7.1.4用错sizeof 161

7.1.5内存越界访问 161

7.1.6变量的初始化 162

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

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

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

7.3函数与指针 165

7.3.1指向函数的指针 165

7.3.2 typedef 167

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

7.3.4函数指针数组 169

7.3.5返回函数指针的函数 171

7.3.6带参主函数 171

7.4函数与数组 172

7.4.1数组名作为函数参数 172

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

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

7.5.1 3种参数调用 176

7.5.2 3种返回机制 177

7.6函数编写的建议 177

7.6.1合理使用const 177

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

7.6.3函数返回类型的判断 179

7.7小结 179

7.8上机实践习题 179

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

第8章 面向对象技术基础 181

8.1面向对象基本概念 181

8.1.1类的概念 182

8.1.2类是分层的 182

8.1.3类和对象的关系 183

8.2 C++类的定义 183

8.2.1类定义的基本形式 183

8.2.2类定义示例 184

8.2.3 class和struct 185

8.3 C++类的实现 185

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

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

8.4 C++类的使用 187

8.4.1声明一个对象 188

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

8.5对象的创建和撤销 189

8.5.1构造函数的作用 189

8.5.2构造函数可以有参数 190

8.5.3构造函数支持重载 191

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

8.5.5初始化表达式 192

8.5.6析构函数 194

8.5.7显式调用析构函数 195

8.6复制构造函数 196

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

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

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

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

8.7特殊数据成员 202

8.7.1 const数据成员 202

8.7.2引用成员 204

8.7.3类对象成员 206

8.7.4特别说明 210

8.7.5 static数据成员 210

8.8特殊函数成员 212

8.8.1静态成员函数 212

8.8.2 const与成员函数 214

8.9对象的组织 215

8.9.1 const对象 215

8.9.2指向对象的指针 217

8.9.3对象的大小 218

8.9.4 this指针 219

8.9.5对象数组 220

8.9.6对象链表 221

8.10为对象动态分配内存 221

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

8.10.2使用new和delete为对象数组分配/释放动态空间 222

8.10.3 malloc和free能否为对象动态申请内存 224

8.11小结 224

8.12上机实践习题 225

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

9.1类的作用域 227

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

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

9.3.1先定义，后实例化 232

9.3.2对象内存的释放与堆内存 232

9.4友元 232

9.4.1友元的非成员函数 233

9.4.2友元的成员函数 234

9.4.3友元函数的重载 236

9.4.4友元类 236

9.4.5友元是否破坏了封装性 237

9.5运算符重载 238

9.5.1运算符重载规则 238

9.5.2以成员函数形式重载运算符 239

9.5.3以友元函数形式重载运算符 242

9.5.4友元函数形式和成员函数形式的比较 245

9.5.5对运算符重载的补充说明 246

9.6运算符重载范例 247

9.6.1赋值运算符 247

9.6.2函数调用运算符 250

9.6.3下标运算符 251

9.7类型转换 253

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

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

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

9.8重载函数选择规则 257

9.8.1重载解析 258

9.8.2什么是完全匹配 258

9.9小结 259

9.10上机实践习题 259

第10章 继承 262

10.1什么是继承 262

10.1.1简单示例 262

10.1.2继承的层次性 264

10.2派生类 264

10.2.1 public派生与private派生 264

10.2.2 protected成员与protected派生 265

10.3多基派生 266

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

10.3.2二义性问题 267

10.3.3解决方案 268

10.4虚基类 268

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

10.4.2解决方案 270

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

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

10.5.1派生类的构造函数 271

10.5.2派生类的析构函数 273

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

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

10.6分清继承还是组合 278

10.6.1继承不是万金油 278

10.6.2组合 278

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

10.7.1类型适应 280

10.7.2多基继承时的情况 282

10.7.3公共基类 282

10.7.4虚基类的情况 284

10.8小结 284

10.9上机实践习题 285

第11章 多态 287

11.1多态与虚函数 287

11.1.1静态联编 287

11.1.2动态联编 287

11.1.3为什么需要虚函数 287

11.1.4虚函数的声明和定义 290

11.2虚函数的访问 290

11.2.1对象名访问 291

11.2.2指针访问 292

11.2.3引用访问 292

11.2.4类内访问 293

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

11.3纯虚函数与抽象类 295

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

11.3.2抽象类 296

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

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

11.3.5虚析构函数 302

11.4虚函数引入的二义性 305

11.4.1多基派生 305

11.4.2共同基类和虚继承 307

11.5重载、覆盖与隐藏 309

11.5.1重载 309

11.5.2覆盖 309

11.5.3隐藏 310

11.6小结 311

11.7上机实践习题 312

第四篇 泛型编程 315

第12章 模板 315

12.1为什么要定义模板 315

12.1.1类型参数化 315

12.1.2模板的定义 317

12.2函数模板 318

12.2.1函数模板的使用 318

12.2.2隐式实例化 318

12.2.3显式实例化 320

12.2.4特化 321

12.2.5重载 322

12.2.6优先级与执行顺序 322

12.3类模板 324

12.3.1定义类模板 324

12.3.2隐式实例化 326

12.3.3显式实例化 326

12.3.4显式特化 327

12.3.5部分特化 328

12.3.6重载和优先级 328

12.4模板的嵌套 329

12.4.1函数成员模板 329

12.4.2对象成员模板 330

12.5模板参数 331

12.6小结 332

12.7上机实践习题 333

第13章 标准模板库 335

13.1理解STL 335

13.1.1容器 335

13.1.2适配器 336

13.1.3迭代器 336

13.1.4算法 336

13.2使用序列式容器 336

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

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

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

13.2.4 vector容器 344

13.2.5 deque容器 344

13.2.6 list容器 344

13.3使用关联式容器 344

13.3.1 set容器 345

13.3.2 multiset容器 346

13.3.3 map容器 346

13.3.4 multimap容器 348

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

13.4.1元素的插入 349

13.4.2元素的删除 352

13.4.3元素的查找与访问 354

13.5迭代器 355

13.5.1理解迭代器本质 355

13.5.2迭代器类型 355

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

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

13.5.5流迭代器 358

13.5.6迭代器失效 360

13.6泛型算法 360

13.6.1什么是函数对象 360

13.6.2算法分类 361

13.7适配器 365

13.7.1容器适配器 366

13.7.2迭代器适配器 367

13.7.3函数适配器 369

13.8小结 371

13.9上机实践习题 371

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

第14章 输入输出和文件 373

14.1输入输出概述 373

14.1.1什么是文件 374

14.1.2流 374

14.1.3缓冲区 375

14.1.4重定向 375

14.1.5 3种输入输出机制 376

14.2高层I/O 377

14.2.1标准输出函数printf 377

14.2.2标准输入函数scanf 381

14.2.3扫描集 384

14.2.4 sprintf函数和sscanf函数 385

14.2.5 fprintf函数和fscanf函数 386

14.2.6文件访问机制 386

14.3流类库 390

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

14.3.2流类库层次 390

14.4输出流 394

14.4.1操作符＜＜ 394

14.4.2其他ostream方法 395

14.4.3格式状态字 397

14.4.4格式控制值的默认值 398

14.4.5 flag函数读取和设定格式状态字 398

14.4.6使用setf函数和unsetf函数设定格式关键字 400

14.4.7设置域宽 402

14.4.8填充字符 404

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

14.4.10控制符 406

14.5输入流 408

14.5.1 ＞＞操作符 408

14.5.2输入流与格式状态字 408

14.5.3输入流与域宽 410

14.5.4使用get函数读取单个字符 411

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

14.5.6其他istream方法 415

14.6流状态 417

14.6.1什么是流状态 417

14.6.2读取流状态 417

14.6.3管理流状态 418

14.7重载＞＞和＜＜ 420

14.7.1插入符的重载 420

14.7.2抽取符的重载 422

14.8文件操作 423

14.8.1文件操作基本过程 423

14.8.2文件的打开 423

14.8.3取消文件和流的关联 425

14.8.4文件的读写 426

14.8.5文本文件的读写 427

14.8.6二进制文件的读写 428

14.8.7文件定位指针和随机读取 429

14.9字符串流 431

14.9.1 strstream类族 431

14.9.2 sstream类族 434

14.10小结 437

14.11上机实践习题 437

第15章 名称空间 439

15.1什么是名称空间 439

15.1.1名称空间范例 439

15.1.2定义名称空间 440

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

15.2.1实体可见域 442

15.2.2可见域的扩展 442

15.2.3 using声明机制 443

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

15.2.5空间内的屏蔽 445

15.2.6先声明，后使用 446

15.3名称空间的作用域与可见性 447

15.3.1名称空间的定义策略 447

15.3.2推荐用法 450

15.3.3名称空间嵌套 451

15.3.4 using编译指令 452

15.3.5未命名的名称空间 453

15.4对名称空间的思考 454

15.5小结 454

15.6上机实践习题 454

第16章 异常和错误 456

16.1编码时的防错 456

16.1.1调用abort函数或exit函数 456

16.1.2返回错误标志 457

16.2异常机制 458

16.2.1关键字throw 460

16.2.2异常处理程序 460

16.2.3自定义异常对象 463

16.2.4有继承关系的类异常 464

16.2.5 terminate函数和set_terminate函数 466

16.2.6 unexpected函数与set_unexpected函数 467

16.2.7标准异常 468

16.2.8对unexpected函数的补充 470

16.3异常发生时的内存管理 471

16.3.1堆栈解退 471

16.3.2异常处理机制与函数的不同 472

16.3.3构造函数中抛出异常 473

16.3.4内存泄露 474

16.3.5析构函数中可否抛出异常 475

16.4 auto_ptr类 476

16.4.1使用auto_ptr类模板 477

16.4.2关于auto_ptr的若干问题 477

16.5小结 478

16.6上机实践习题 479

第17章 RTTI和类型转换操作符 481

17.1 RTTI机制 481

17.1.1 dynamic_cast操作符 482

17.1.2 typeinfo类和typeid操作符 483

17.1.3补充说明 484

17.2类型转换操作符 484

17.2.1 const_cast操作符 484

17.2.2 static_cast操作符 485

17.2.3 reinterpret_cast操作符 486

17.3小结 486

17.4上机实践习题 487

第18章 string字符串类 489

18.1为什么要使用string类 489

18.2声明一个字符串 489

18.3字符串的输入输出 491

18.4 string类功能 492

18.4.1 string字符串和C风格字符串的转换 492

18.4.2赋值和清空 492

18.4.3元素删除 493

18.4.4元素追加与相加 493

18.4.5元素插入 494

18.4.6大小和容量 494

18.4.7元素存取 494

18.4.8字符串比较 495

18.4.9提取子串 495

18.4.10搜索与查找 495

18.5小结 496

18.6上机实践习题 496

第19章 编码风格 497

19.1程序的排版 497

19.1.1注释 497

19.1.2空行的用法 498

19.1.3代码行 498

19.1.4空格 498

19.1.5缩进与对齐 499

19.1.6 &和*的位置 499

19.2命名规则 499

19.2.1 Windows风格和Unix风格 500

19.2.2如何对程序实体命名 500

19.3项目文件的组织 500

19.3.1模块划分 500

19.3.2头文件 500

19.3.3定义文件 501

19.3.4目录结构 501

19.4小结 501

19.5上机实践习题 502

第20章 程序编译 503

20.1程序的编译流程 503

20.2预处理 504

20.2.1头文件包含 505

20.2.2宏 505

20.2.3条件编译 506

20.2.4 #ifdef、#ifndef与重复包含 507

20.2.5使用const代替#define定义常量 508

20.2.6 inline与#define的比较 509

20.3 VC6调试入门 509

20.3.1断点的设置与去除 509

20.3.2条件断点 510

20.3.3数据断点 510

20.3.4消息断点 511

20.3.5观察视图 511

20.3.6内存视图 511

20.3.7变量视图 511

20.3.8寄存器视图 511

20.3.9调用堆栈视图 512

20.3.10反汇编视图 512

20.3.11进程控制 512

20.4其他调试手段 512

20.4.1 Debug模式和Release模式 512

20.4.2 assert宏 512

20.4.3输出字符串 513

20.5小结 513

20.6上机实践习题 513

第六篇 面试题精选 517

第21章 常见面试题 517

21.1常见基本知识问答题 517

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

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

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

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

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

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

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

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

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

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

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

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

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

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

面试题15：请指出const与#define相比有何优点 521

面试题16：C语言中static关键字的具体作用有哪些 521

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

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

21.2世界500强公司的智力问答题 522

面试题19：工人分金条 522

面试题20：分蛋糕 522

面试题21：过桥问题 522

面试题22：黑白帽子 523

面试题23：电梯与钻石 523

面试题24：手电筒传递 523

面试题25：烧绳问题 524

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

面试题27：选建筑师 524

面试题28：天平分盐 524

面试题29：分不开的钱 524

面试题30：小鸟追火车 525

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

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

面试题33：污染的药丸 525

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

面试题35：多彩的果冻 526

面试题36：电子游戏机 526

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

面试题38：灯的状态 526

面试题39：时针和分针 527

面试题40：3个奇数 527

面试题41：屋内的灯 527

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

面试题43：盲人分袜子 528

面试题44：烧香计时 528

面试题45：平分蜂蜜 528

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

面试题47：两个圆环 529

面试题48：喝啤酒 529

面试题49：算24点 529

面试题50：聪明人 529

面试题51：海盗分金币 529

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

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

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

21.3分析题 532

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

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

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

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

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

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

21.4编程题 536

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

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

面试题63：链表题，一个链表的节点结构 538

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

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

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

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

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