C++入门经典PDF电子书下载

1.1　编程语言 1

1.1.1　解释性的程序和编译性的程序的执行过程 1

第1章　基本概念 1

1.1.2　库 2

1.2　为什么C++是一种强大的语言 2

1.3 一个简单的C++程序 3

1.4 名称 4

1.5 关键字 6

1.6　C++语句和语句块 6

1.7　程序结构 7

1.8　从源文件中创建可执行文件 8

1.8.2　链接 9

1.8.1 编译 9

1.9　字符和字符集 10

1.9.1　字符编码 11

1.9.2　转义序列 11

1.9.3　空白 13

1.10　程序的注释 14

1.11 标准库 15

1.12 用C++编程 16

1.13 本章小结…………………………………………………………………………………？1.14　练习……………………………………………………………………………………………？第2章　基本数据类型和计算 19

2.1　数据和数据类型 19

2.2　进行简单的计算 19

2.2.1　整型字面量 20

2.2.2　二进制数 21

2.2.3　十六进制数 22

2.2.4　负的二进制数 23

2.2.5　十六进制的整型字面量 24

2.2.6　八进制的整型字面量 25

2.2.7　整数的算术运算 25

2.3 使用变量 30

2.4　整型变量 31

2.4.1　整型变量类型 33

2.4.2 内存中的整型变量 35

2.5　赋值运算符 36

2.5.1　多次赋值 37

2.5.2　修改变量的值 37

2.6　整数的递增和递减 39

2.7　const关键字 40

2.8　浮点数 42

2.8.1 浮点数的数据类型 43

2.8.2　使用浮点数值 45

2.9　使用字符 48

2.10　初始值的函数表示法 51

2.11 本章小结 51

2.12　练习 52

第3章　处理基本数据类型 53

3.1　混合的表达式 53

3.1.1 赋值和不同的类型 54

3.1.2　显式强制转换 55

3.2　确定类型 58

3.1.3 老式的强制转换 58

3.3　按位运算符 62

3.3.1 移位运算符 62

3.3.2　位模式下的逻辑运算 64

3.4　枚举数据类型 73

3.4.1 匿名枚举 74

3.4.2　在整型和枚举类型之间强制转换 75

3.5　数据类型的同义词 77

3.6　变量的生存期 78

3.6.1 自动变量 78

3.6.2　定位变量的声明 81

3.6.3 全局变量 81

3.8 声明外部变量 84

3.6.4　静态变量 84

3.7　特殊的类型修饰符 84

3.9　优先级和相关性 85

3.10　本章小结 86

3.11 练习 86

第4章　选择和决策 87

4.1 比较数据值 87

4.1.1　应用比较运算符 88

4.1.2　比较浮点数值 90

4.2 if语句 90

4.3 if-else语句 97

4.4　逻辑运算符 102

4.4.2 逻辑或运算符 103

4.4.1　逻辑与运算符 103

4.4.3　逻辑非运算符 104

4.5　条件运算符 107

4.6　switch语句 109

4.7　无条件分支 114

4.8　决策语句块和变量作用域 114

4.9　本章小结 116

4.10　练习 116

第5章　循环 117

5.1 理解循环 117

5.2　while循环 118

5.3　do-while循环 120

5.4　for循环 123

5.4.1　循环和变量作用域 126

5.4.2　用浮点数值控制for循环 128

5.4.3　使用更复杂的循环控制表达式 131

5.5　嵌套的循环 135

5.6　跳过循环迭代 139

5.7　循环的中断 141

5.8　本章小结 147

5.9　练习 148

第6章　数组和字符串 149

6.1 数据数组 149

6.1.1　使用数组 149

6.1.2　初始化数组 154

6.1.3　字符数组 158

6.2 多维数组 161

6.2.1　初始化多维数组 163

6.2.2　多维字符数组 166

6.3　string类型 168

6.3.1 声明string对象 169

6.3.2　使用string对象 170

6.3.3　访问字符串中的字符 173

6.3.4　访问子字符串 175

6.3.5　比较字符串 175

6.3.6　搜索字符串 181

6.3.7　修改字符串 189

6.4　string类型的数组 194

6.5　本章小结 195

6.6　练习 196

7.1　什么是指针 197

第7章　指针 197

7.2　指针的声明 198

7.3　指针的初始化 203

7.4　常量指针和指向常量的指针 214

7.5　指针和数组 216

7.5.1　指针的算术运算 216

7.5.2　使用数组名的指针表示法 218

7.5.3　对多维数组使用指针 222

7.5.4　C样式字符串的操作 225

7.6　动态内存分配 226

7.6.1　自由存储区 227

7.6.2　运算符new和delete 227

7.6.3　数组的动态内存分配 228

7.6.4　动态内存分配的危险 231

7.6.5　转换指针 237

7.7 本章小结 237

7.8 练习 238

第8章　使用函数编程 239

8.1　程序的分解 239

8.2　理解函数 240

8.2.1　定义函数 241

8.2.2　函数的声明 245

8.3　给函数传送参数 247

8.3.1 按值传送机制 247

8.3.2　按引用传送机制 256

8.3.3 main()的参数 260

8.4　默认的参数值 261

8.5　从函数中返回值 265

8.5.1　返回一个指针 265

8.5.2　返回一个引用 270

8.5.3 从函数中返回新变量 270

8.6 内联函数 270

8.7　静态变量 271

8.8　本章小结 274

8.9　练习 274

第9章　函数 276

9.1　函数的重载 276

9.1.1 函数的签名 276

9.1.3　重载和引用参数 279

9.1.2　重载和指针参数 279

9.1.4　重载和const参数 281

9.1.5　重载和默认参数值 282

9.2 函数模板 283

9.2.1 显式指定模板参数 286

9.2.2　模板的说明 287

9.2.3 函数模板和重载 290

9.2.4　带有多个参数的模板 291

9.3 函数指针 292

9.3.1 声明函数指针 293

9.3.2　把函数作为参数传送 296

9.3.3 函数指针的数组 298

9.4　递归 299

9.5 本章小结 307

9.6 练习 308

第10章　程序文件和预处理器 309

10.1 使用程序文件 309

10.2　命名空间 315

10.2.1　全局命名空间 316

10.2.2　声明命名空间 317

10.2.3　隐式地限定名称 320

10.2.4　函数和命名空间 322

10.2.5 函数模板和命名空间 326

10.2.6　扩展命名空间 328

10.2.7　未指定名称的命名空间 332

10.2.8　命名空间的别名 332

10.2.9　嵌套的命名空间 333

10.3 预处理器 334

10.3.1 在程序中包含头文件 335

10.3.2　程序中的置换 336

10.3.3　宏置换 338

10.3.4　放在多行代码中的预处理器指令 340

10.3.5　把字符串作为宏参数 340

10.3.6　在宏表达式中连接参数 342

10.4　逻辑预处理器指令 342

10.4.1　逻辑#if指令 342

10.4.2　测试特定值的指令 345

10.4.3　多个代码选择块 345

10.4.4　标准的预处理器宏 346

10.4.5　#error和#pragma指令 347

10.5 调试方法 348

10.5.1　集成调试器 348

10.5.2　调试中的预处理器 349

10.5.3　使用assert宏 355

10.6 本章小结 357

10.7　练习 358

第1 1章 创建自己的数据类型 359

11.1 对象的概念 359

11.2 C++中的结构 360

11.2.1　理解结构 360

11.2.2　定义结构类型 361

11.2.3　初始化结构变量 363

11.2.4　访问结构变量的成员 364

11.2.5　对结构使用指针 370

11.3 联合 373

11.3.1　声明联合 374

11.3.2　匿名联合 376

11.4　更复杂的结构 377

11.5　本章小结 384

11.6 练习 384

第12章　类 385

12.1　类和面向对象编程 385

12.1.1 封装 386

12.1.2　继承 387

12.1.3 多态性 388

12.1.4　术语 389

12.2 定义类 390

12.3　构造函数 393

12.3.1 把构造函数的定义放在类的外部 395

12.3.2　默认的构造函数 397

12.3.3 默认的初始化值 401

12.3.4　在构造函数中使用初始化列表 402

12.3.5　使用explicit关键字 402

12.4　类的私有成员 404

12.4.1 访问私有类成员 408

12.4.2　默认的副本构造函数 410

12.5 友元 411

12.5.1　类的友元函数 412

12.6　this指针 415

12.5.2　友元类 415

12.7　const对象和const成员函数 419

12.7.1　类中的mutable数据成员 421

12.7.2　常量的强制转换 422

12.8　类的对象数组 422

12.9　类对象的大小 425

12.10　类的静态成员 427

12.10.1 类的静态数据成员 428

12.10.2　类的静态成员函数 433

12.11 本章小结 435

12.12　练习 435

13.1 类对象的指针和引用 437

13.2　指针作为数据成员 437

第13章　类的操作 437

13.2.1　定义Package类 439

13.2.2　定义TruckLoad类 442

13.2.3 实现TruckLoad类 443

13.3　控制对类的访问 452

13.4　副本构造函数的重要性 455

13.5　对象内部的动态内存分配 461

13.5.1 析构函数 462

13.5.2　默认的析构函数 462

13.5.3　实现析构函数 465

13.6　类的引用 466

13.7　本章小结 469

13.8　练习 469

14.1.1　运算符重载 471

14.1 为自己的类实现运算符 471

第14章　运算符重载 471

14.1.2　可以重载的运算符 472

14.1.3 实现重载运算符 472

14.1.4　全局运算符函数 476

14.1.5　提供对运算符的全部支持 477

14.1.6　运算符函数术语 481

14.1.7　重载赋值运算符 481

14.1.8　重载算术运算符 489

14.1.9　重载下标运算符 494

14.1.10　重载类型转换 502

14.1.11 重载递增和递减运算符 504

14.1.12　智能指针 504

14.1.13　重载运算符new和delete 511

14.2 本章小结 512

14.3　练习 512

第15章　继承 514

15.1　类和面向对象编程 514

15.2　类的继承 516

15.2.1　继承和聚合 516

15.2.2　从基类中派生新类 517

15.3　继承下的访问控制 521

15.4　把类的成员声明为protected 524

15.5 派生类成员的访问级别 526

15.6　派生类中的构造函数操作 530

15.7　继承中的析构函数 538

15.8　重复的成员名 540

15.9 多重继承 542

15.9.1 多个基类 542

15.9.2　继承成员的模糊性 543

15.9.3　重复的继承 550

15.9.4　虚基类 551

15.10　在相关的类类型之间转换 552

15.11 本章小结 553

15.12　练习 553

第16章　虚函数和多态性 555

16.1　理解多态性 555

16.1.1　使用基类指针 555

16.1.2　调用继承的函数 557

16.1.3　虚函数 561

16.1.4　虚函数中的默认参数值 569

16.1.5　通过引用来调用虚函数 570

16.1.6　调用虚函数的基类版本 572

16.1.7　在指针和类对象之间转换 572

16.1.8　动态强制转换 574

16.2　多态性的成本 576

16.3 纯虚函数 577

16.3.1 抽象类 578

16.3.2　间接的抽象基类 581

16.4　通过指针释放对象 585

16.5　在运行期间标识类型 587

16.6　类成员的指针 589

16.6.1　数据成员指针 589

16.6.2　成员函数指针 593

16.7　本章小结 597

16.8　练习 598

第17章　程序错误和异常处理 599

17.1 处理错误 599

17.2 理解异常 600

17.2.1 抛出异常 600

17.2.2　导致抛出异常的代码 606

17.2.3　嵌套的try块 607

17.3　用类对象作为异常 611

17.3.1 匹配Catch处理程序和异常 613

17.3.2　用基类处理程序捕获派生类异常 616

17.3.3　重新抛出异常 619

17.3.4　捕获所有的异常 623

17.4 抛出异常的函数 625

17.4.1 函数try块 625

17.4.2　在构造函数中抛出异常 628

17.4.3　异常和析构函数 629

17.5　标准库异常 629

17.5.1　标准库异常类 630

17.5.2　使用标准异常 631

17.6 本章小结 632

17.7 练习 632

第18章　类模板 634

18.1 理解类模板 634

18.2　定义类模板 635

18.2.2　简单的类模板 636

18.2.1 模板参数 636

18.2.3　创建类模板的实例 641

18.2.4　类模板的静态成员 649

18.2.5　非类型的类模板参数 650

18.2.6　非类型参数示例 651

18.2.7　默认的模板参数值 662

18.3 模板的显式实例化 662

18.4　类模板的友元 663

18.5 特殊情形 664

18.6　带有嵌套类的类模板 666

18.7　更高级的类模板 676

18.8 本章小结 676

18.9　练习 677

第19章　输入输出操作 678

19.1 C++中的输入输出 678

19.2　流类 680

19.2.1 标准流 681

19.2.2　流的插入和提取操作 681

19.2.3　流操纵程序 683

19.3 文件流 686

19.3.1 写入文件 686

19.3.2　读取文件 689

19.3.3 设置文件打开模式 691

19.4　未格式化的流操作 701

19.4.1 未格式化的流输入函数 701

19.5 流输入输出中的错误 703

19.4.2　未格式化的流输出函数 703

19.6　使用二进制模式流操作 705

19.7　流上的读写操作 714

19.8　字符串流 723

19.9　对象和流 724

19.9.1 重载类对象的插入运算符 724

19.9.2　重载类对象的提取运算符 727

19.9.3　流中更复杂的对象 730

19.10　本章小结 742

19.11 练习 743

第20章　标准模板库 744

20.1 STL架构简介 744

20.2　使用vector容器 746

20.2.1 vector容器的基本操作 748

20.2.2　使用vector容器进行数组操作 754

20.2.3　istream iterator迭代器 759

20.3　理解迭代器 762

20.3.1　给算法传送迭代器 764

20.3.2　模拟istream_operator和ostream_operator 766

20.3.3　迭代器的要求 767

20.3.4　修订后的Integer迭代器 769

20.3.5　输入和输出迭代器 776

20.4　存储空间管理一瞥 777

20.4.1　Account帮助类 778

20.4.2　STL元素需求和理想的Bean 780

20.4.3 确定vector的大小和vector存储空间的管理 783

20.5 list容器 789

20.6　关联map容器 795

20.7　性能和规范 801

20.8　本章小结 803

20.9　练习 804

附录A　ASCII马 805

附录B　C++关键字 808

附录C　标准库头文件 810

C.1　语言支持 810

C.2　输入／输出 811

C.3　诊断 811

C.4　一般工具 811

C.7　迭代器支持 812

C.6　容器 812

C.5　字符串 812

C.8　一般用途的算法 813

C.9　数值操作 813

C.10　本地化 813

附录D　运算符的优先级和相关性 814

附录E　项目示例 817

E.1 提纲 817

E.2　开发人员应注意的问题 819

E.2.1　Person类 819

E.2.2 Student和Teacher派生类 819

E.2.3　容器 819

E.2.4　保存和恢复数据 820

E.3 小结 820