C++入门经典

第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.1  编译  9
1.8.2  链接  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  本章小结  17
1.14  练习  18
第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.1.3  老式的强制转换  58
3.2  确定类型  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.6.4  静态变量  84
3.7  特殊的类型修饰符  84
3.8  声明外部变量  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.1  逻辑与运算符  103
4.4.2  逻辑或运算符  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章  指针  197
7.1  什么是指针  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.2  重载和指针参数  279
9.1.3  重载和引用参数  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
第11章  创建自己的数据类型  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.5.2  友元类  415
12.6  this指针  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章  类的操作  437
13.1  类对象的指针和引用  437
13.2  指针作为数据成员  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章  运算符重载  471
14.1  为自己的类实现运算符  471
14.1.1  运算符重载  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.1  模板参数  636
18.2.2  简单的类模板  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.4.2  未格式化的流输出函数  703
19.5  流输入输出中的错误  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.5  字符串  812
C.6  容器  812
C.7  迭代器支持  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