C++入门经典

第1章  基本概念    1
1.1  编程语言    1
1.1.1  编程语言简史    1
1.1.2  解释性程序和编译性程序的
执行过程    2
1.1.3  库    3
1.2  C++是一种强大的语言    3
1.3  一个简单的C++程序    4
1.3.1  名称    6
1.3.2  命名空间    7
1.4  关键字    9
1.5  C++语句和语句块    9
1.6  程序结构    10
1.7  从源文件中创建可执行文件    12
1.7.1  编译    12
1.7.2  链接    13
1.8  C++源字符    14
1.8.1  通用字符集    15
1.8.2  三字符序列    15
1.8.3  转义序列    16
1.8.4  语句中的空白    18
1.9  程序的注释    19
1.10  标准库    20
1.11  用C++编程    21
1.12  本章小结    22
1.13  练习    23
第2章  基本数据类型和计算    24
2.1  数据和数据类型    24
2.2  进行简单的计算    24
2.2.1  字面量    25
2.2.2  整型字面量    25
2.2.3  整数的算术运算    27
2.2.4  运算符的优先级和相关性    30
2.3  使用变量    32
2.4  整型变量    33
2.4.1  整型变量类型    35
2.4.2  整数的取值范围    37
2.4.3  整型字面量的类型    38
2.5  赋值运算符    39
2.5.1  多次赋值    40
2.5.2  修改变量的值    40
2.6  整数的递增和递减    42
2.7  const关键字    44
2.8  整数的数字函数    45
2.9  浮点数    49
2.9.1  浮点数的数据类型    49
2.9.2  浮点数的操作    51
2.9.3  使用浮点数值    53
2.9.4  数值函数    55
2.10  使用字符    57
2.10.1  字符字面量    57
2.10.2  初始化char变量    58
2.10.3  使用扩展字符集    60
2.11  初始值的函数表示法    62
2.12  本章小结    62
2.13  练习    63
第3章  处理基本数据类型    64
3.1  混合的表达式    64
3.1.1  赋值和不同的类型    65
3.1.2  显式强制转换    66
3.1.3  老式的强制转换    68
3.2  确定类型    70
3.3  按位运算符    73
3.3.1  移位运算符    74
3.3.2  位模式下的逻辑运算    76
3.4  枚举数据类型    85
3.4.1  匿名枚举    86
3.4.2  在整型和枚举类型之间
强制转换    87
3.5  数据类型的同义词    89
3.6  变量的生存期    90
3.6.1  自动变量    90
3.6.2  定位变量的声明    92
3.6.3  全局变量    92
3.6.4  静态变量    95
3.7  特殊的类型修饰符    96
3.8  声明外部变量    96
3.9  优先级和相关性    96
3.10  本章小结    97
3.11  练习    98
第4章  选择和决策    99
4.1  比较数据值    99
4.1.1  应用比较运算符    100
4.1.2  比较浮点数值    102
4.2  if语句    102
4.3  if-else语句    110
4.4  逻辑运算符    114
4.4.1  逻辑与运算符    115
4.4.2  逻辑或运算符    115
4.4.3  逻辑非运算符    115
4.5  条件运算符    118
4.6  switch语句    120
4.7  无条件分支    124
4.8  决策语句块和变量作用域    125
4.9  本章小结    126
4.10  练习    126
第5章  循环    127
5.1  理解循环    127
5.2  while循环    128
5.3  do-while循环    130
5.4  for循环    133
5.4.1  循环和变量作用域    135
5.4.2  用浮点数值控制for循环    137
5.4.3  使用更复杂的循环控制表达式    140
5.5  嵌套的循环    143
5.6  跳过循环迭代    147
5.7  循环的中断    150
5.8  本章小结    155
5.9  练习    155
第6章  数组和字符串    156
6.1  数据数组    156
6.1.1  使用数组    156
6.1.2  初始化数组    161
6.1.3  字符数组    164
6.2  多维数组    168
6.2.1  初始化多维数组    170
6.2.2  多维字符数组    172
6.3  string类型    174
6.3.1  声明string对象    175
6.3.2  使用string对象    177
6.3.3  访问字符串中的字符    179
6.3.4  访问子字符串    182
6.3.5  比较字符串    182
6.3.6  搜索字符串    188
6.3.7  修改字符串    196
6.4  string类型的数组    201
6.5  宽字符的字符串    202
6.6  本章小结    202
6.7  练习    203
第7章  指针    204
7.1  什么是指针    204
7.2  指针的声明    205
7.3  指针的初始化    210
7.4  常量指针和指向常量的指针    220
7.5  指针和数组    221
7.5.1  指针的算术运算    221
7.5.2  使用数组名的指针表示法    224
7.5.3  对多维数组使用指针    227
7.5.4  C样式字符串的操作    229
7.6  动态内存分配    231
7.6.1  自由存储区    232
7.6.2  运算符new和delete    232
7.6.3  数组的动态内存分配    233
7.6.4  动态内存分配的危险    235
7.6.5  转换指针    241
7.7  本章小结    241
7.8  练习    242
第8章  使用函数编程    243
8.1  程序的分解    243
8.2  理解函数    245
8.2.1  定义函数    245
8.2.2  函数的声明    249
8.3  给函数传送参数    251
8.3.1  按值传送机制    251
8.3.2  按引用传送机制    260
8.3.3  main()的参数    264
8.4  默认的参数值    265
8.5  从函数中返回值    268
8.5.1  返回一个指针    268
8.5.2  返回一个引用    272
8.5.3  从函数中返回新变量    273
8.6  内联函数    273
8.7  静态变量    273
8.8  本章小结    276
8.9  练习    276
第9章  函数    278
9.1  函数的重载    278
9.1.1  函数的签名    278
9.1.2  重载和指针参数    281
9.1.3  重载和引用参数    281
9.1.4  重载和const参数    283
9.1.5  重载和默认参数值    284
9.2  函数模板    285
9.2.1  创建函数模板的实例    286
9.2.2  显式指定模板参数    288
9.2.3  模板的说明    289
9.2.4  函数模板和重载    291
9.2.5  带有多个参数的模板    292
9.3  函数指针    293
9.3.1  声明函数指针    294
9.3.2  把函数作为参数传送    297
9.3.3  函数指针的数组    299
9.4  递归    299
9.5  本章小结    307
9.6  练习    307
第10章  程序文件和预处理器指令    309
10.1  使用程序文件    309
10.1.1  名称的作用域    310
10.1.2  “一个定义”规则    312
10.1.3  程序文件和链接    313
10.1.4  外部名称    314
10.2  命名空间    318
10.2.1  全局命名空间    319
10.2.2  定义命名空间    319
10.2.3  使用using声明    322
10.2.4  函数和命名空间    322
10.2.5  函数模板和命名空间    326
10.2.6  扩展命名空间    327
10.2.7  未指定名称的命名空间    330
10.2.8  命名空间的别名    331
10.2.9  嵌套的命名空间    331
10.3  预处理器    332
10.3.1  在程序中包含头文件    333
10.3.2  程序中的置换    334
10.3.3  宏置换    336
10.3.4  放在多行代码中的预
处理器指令    338
10.3.5  把字符串作为宏参数    339
10.3.6  在宏表达式中连接参数    340
10.4  逻辑预处理器指令    340
10.4.1  逻辑#if指令    341
10.4.2  测试特定值的指令    343
10.4.3  多个代码选择块    343
10.4.4  标准的预处理器宏    344
10.4.5  #error和#pragma指令    345
10.5  调试方法    346
10.5.1  集成调试器    346
10.5.2  调试中的预处理器指令    347
10.5.3  使用assert宏    353
10.6  本章小结    354
10.7  练习    355
第11章  创建自己的数据类型    356
11.1  对象的概念    356
11.2  C++中的结构    357
11.2.1  理解结构    357
11.2.2  定义结构类型    358
11.2.3  创建结构类型的对象    360
11.2.4  访问结构对象的成员    360
11.2.5  对结构使用指针    366
11.3  联合    370
11.3.1  声明联合    371
11.3.2  匿名联合    372
11.4  更复杂的结构    373
11.5  本章小结    379
11.6  练习    380
第12章  类    381
12.1  类和面向对象编程    381
12.1.1  封装    382
12.1.2  继承    383
12.1.3  多态性    384
12.1.4  术语    385
12.2  定义类    385
12.3  构造函数    388
12.3.1  把构造函数的定义放在
类的外部    390
12.3.2  默认的构造函数    392
12.3.3  默认的初始化值    395
12.3.4  在构造函数中使用初始化
列表    396
12.3.5  使用explicit关键字    397
12.4  类的私有成员    398
12.4.1  访问私有类成员    402
12.4.2  默认的副本构造函数    404
12.5  友元    405
12.5.1  类的友元函数    405
12.5.2  友元类    408
12.6  this指针    409
12.7  const对象和const成员函数    413
12.7.1  类中的mutable数据成员    415
12.7.2  常量的强制转换    416
12.8  类的对象数组    416
12.9  类对象的大小    419
12.10  类的静态成员    421
12.10.1  类的静态数据成员    421
12.10.2  类的静态成员函数    426
12.11  本章小结    427
12.12  练习    428
第13章  类的操作    429
13.1  类对象的指针和引用    429
13.2  指针作为数据成员    430
13.2.1  定义Package类    431
13.2.2  定义TruckLoad类    434
13.2.3  实现TruckLoad类    435
13.3  控制对类的访问    443
13.4  副本构造函数的重要性    445
13.5  对象内部的动态内存分配    453
13.5.1  析构函数    453
13.5.2  定义析构函数    453
13.5.3  默认的析构函数    454
13.5.4  实现析构函数    456
13.6  类的引用    457
13.7  本章小结    459
13.8  练习    460
第14章  运算符重载    461
14.1  为自己的类实现运算符    461
14.1.1  运算符重载    461
14.1.2  可以重载的运算符    462
14.1.3  实现重载运算符    462
14.1.4  全局运算符函数    466
14.1.5  提供对运算符的全部支持    466
14.1.6  运算符函数术语    470
14.1.7  重载赋值运算符    470
14.1.8  重载算术运算符    477
14.1.9  重载下标运算符    482
14.1.10  重载类型转换    489
14.1.11  重载递增和递减运算符    490
14.1.12  智能指针    491
14.1.13  重载运算符new和delete    497
14.2  本章小结    497
14.3  练习    498
第15章  继承    499
15.1  类和面向对象编程    499
15.2  类的继承    500
15.2.1  继承和聚合    501
15.2.2  从基类中派生新类    502
15.3  继承下的访问控制    505
15.4  把类的成员声明为protected    508
15.5  派生类成员的访问级别    510
15.5.1  在类层次结构中使用
访问指定符    511
15.5.2  改变继承成员的访问
指定符    512
15.6  派生类中的构造函数操作    514
15.7  继承中的析构函数    520
15.8  重复的成员名    522
15.9  多重继承    524
15.9.1  多个基类    524
15.9.2  继承成员的模糊性    526
15.9.3  重复的继承    531
15.9.4  虚基类    532
15.10  在相关的类类型之间转换    533
15.11  本章小结    534
15.12  练习    534
第16章  虚函数和多态性    536
16.1  理解多态性    536
16.1.1  使用基类指针    536
16.1.2  调用继承的函数    538
16.1.3  虚函数    542
16.1.4  虚函数中的默认参数值    549
16.1.5  通过引用来调用虚函数    553
16.1.6  调用虚函数的基类版本    554
16.1.7  在指针和类对象之间转换    555
16.1.8  动态强制转换    557
16.2  多态性的成本    559
16.3  纯虚函数    560
16.3.1  抽象类    560
16.3.2  间接的抽象基类    563
16.4  通过指针释放对象    566
16.5  在运行期间标识类型    569
16.6  类成员的指针    570
16.6.1  数据成员指针    570
16.6.2  成员函数指针    574
16.7  本章小结    578
16.8  练习    578
第17章  程序错误和异常处理    580
17.1  处理错误    580
17.2  理解异常    581
17.2.1  抛出异常    581
17.2.2  导致抛出异常的代码    586
17.2.3  嵌套的try块    588
17.3  用类对象作为异常    591
17.3.1  匹配Catch处理程序
和异常    592
17.3.2  用基类处理程序捕获
派生类异常    596
17.3.3  重新抛出异常    598
17.3.4  捕获所有的异常    601
17.4  抛出异常的函数    603
17.4.1  函数try块    603
17.4.2  在构造函数中抛出异常    605
17.4.3  异常和析构函数    606
17.5  标准库异常    606
17.5.1  标准库异常类    607
17.5.2  使用标准异常    608
17.6  本章小结    609
17.7  练习    610
第18章  类模板    611
18.1  理解类模板    611
18.2  定义类模板    612
18.2.1  模板参数    613
18.2.2  简单的类模板    613
18.2.3  创建类模板的实例    617
18.2.4  类模板的静态成员    625
18.2.5  非类型的类模板参数    625
18.2.6  非类型参数示例    626
18.2.7  默认的模板参数值    636
18.3  模板的显式实例化    636
18.4  类模板的友元    637
18.5  特殊情形    638
18.6  带有嵌套类的类模板    640
18.7  更高级的类模板    648
18.8  本章小结    649
18.9  练习    649
第19章  输入输出操作    651
19.1  C++中的输入输出    651
19.1.1  理解流    651
19.1.2  使用流的优点    652
19.2  流类    653
19.2.1  标准流    654
19.2.2  流的插入和提取操作    655
19.2.3  流操纵程序    657
19.3  文件流    659
19.3.1  写入文件    659
19.3.2  读取文件    662
19.3.3  设置文件打开模式    664
19.4  未格式化的流操作    672
19.4.1  未格式化的流输入函数    673
19.4.2  未格式化的流输出函数    674
19.5  流输入输出中的错误    675
19.6  使用二进制模式流操作    677
19.7  对流的读写操作    685
19.8  字符串流    692
19.9  对象和流    693
19.9.1  重载类对象的插入运算符    693
19.9.2  重载类对象的提取运算符    696
19.9.3  流中更复杂的对象    698
19.10  本章小结    710
19.11  练习    710
第20章  标准模板库    711
20.1  STL架构简介    711
20.1.1  STL组件    711
20.1.2  STL头文件    716
20.2  使用vector容器    717
20.2.1  创建vector容器    717
20.2.2  访问vector容器中的元素    720
20.2.3  vector容器的基本操作    722
20.2.4  使用vector容器进行数组
操作    726
20.2.5  使用输入流迭代器    730
20.3  创建自己的迭代器    734
20.3.1  给算法传送迭代器    736
20.3.2  STL迭代器类型的要求    738
20.3.3  STL迭代器成员函数的
要求    740
20.3.4  插入迭代器    744
20.4  list容器    745
20.4.1  创建list容器    746
20.4.2  访问list容器中的元素    747
20.4.3  list容器上的操作    747
20.5  关联map容器    753
20.6  性能和规范    761
20.7  本章小结    763
20.8  练习    763
附录A  ASCII码    764
附录B  C++关键字    768
附录C  标准库头文件    769
附录D  运算符的优先级和相关性    774
附录E  理解二进制和十六进制数    777
附录F  项目示例    783