C++从入门到精选PDF电子书下载

第一章 C＋＋的历史 1

1.1 C＋＋的起源 1

1.1.1 C的诞生 1

1.1.2 理解对C＋＋的需要 2

1.1.3 C＋＋的诞生 3

1.2 什么是面向对象的编程 4

1.2.1 封装 4

1.2.2 多态性 4

1.2.3 继承 5

1.2.4 C＋＋实现OOP 5

1.3 将需要什么 5

第二章 C＋＋概览 6

2.1 第一个C＋＋程序 6

2.1.1 一行一行地解释 6

2.2 处理错误 8

2.3 第二个举例程序 8

2.4 一个更实用的例子 9

2.5 一种新的数据类型 10

2.6 快速的复习 11

2.7 函数 11

2.7.1 一个有两个函数的程序 12

2.8 函数的参数 13

2.8.1 函数返回值 14

2.8.2 main（）函数 15

2.8.3 C＋＋函数的一般形式 15

2.9 一些输出选项 16

2.10 两个简单的命令 16

2.10.1 if语句 17

2.10.2 for循环 17

2.11 代码块 19

2.12 分号及其位置 19

2.13 缩进练习 20

2.14 C＋＋关键字 20

2.15 C＋＋的标识符 21

2.16 标准的C＋＋库 21

第三章 介绍变量、常量及运算符 22

3.1 基本数据类型 22

3.2 变量的声明 22

3.2.1 局部变量 23

3.2.2 形式参数 24

3.2.3 全局变量 24

3.3 一些类型修饰符 25

3.4 常量 27

3.4.1 十六进制和八进制常量 28

3.4.2 字符串变量 28

3.4.3 反斜线字符常量 28

3.5 变量初始化 29

3.6 运算符 30

3.6.1 算术运算符 30

3.6.2 加1和减1运算 31

3.6.3 关系和逻辑运算符 32

3.7 表达式 35

3.7.1 表达式中类型转换 35

3.7.2 类型强制转换 35

3.7.3 空格和括号 36

第四章 程序控制语句 37

4.1 if语句 37

4.1.1 条件表达式 38

4.1.2 嵌套if语句 39

4.1.3 if-else-if梯形结构 40

4.2 for循环 41

4.2.1 关于for循环的一些变化 42

4.2.2 省略循环控制部分 43

4.2.3 无限循环 44

4.2.4 延时循环 44

4.3 The switch Statement 44

4.3.1 嵌套switch语句 47

4.4 while循环 48

4.5 do-while循环 49

4.6 使用continue 50

4.7 使用break退出循环 51

4.8 嵌套循环 52

4.9 使用goto语句 52

4.10 把各部分组织在一起 53

第五章 数组和字符串 55

5.1 一维数组 55

5.1.1 无边界检查 57

5.2 字符串 58

5.2.1 从键盘读入一个字符串 59

5.3 一些字符串库函数 60

5.3.1 strcpy 60

5.3.2 strcat 61

5.3.3 strcmp 61

5.3.4 strlen 62

5.3.5 使用Null结束符 64

5.4 二维数组 65

5.5 多维数组 66

5.6 数组初始化 66

5.6.1 不定长数组的初始化 69

5.7 字符串数组 70

5.7.1 一个使用字符串数组的例子 70

第六章 指针 74

6.1 什么是指针 74

6.2 指针运算符 74

6.2.1 基本类型很重要 76

6.2.2 通过指针赋值 77

6.3 指针表达式 77

6.3.1 指针算术运算 78

6.3.2 指针比较 78

6.4 指针和数组 79

6.4.1 索引一个指针 81

6.4.2 指针和数组可直接互换吗 81

6.5 字符串常量 82

6.6 一个做比较的例子 83

6.7 指针数组 83

6.8 空指针协议 85

6.9 多重间接 86

6.10 有关指针的问题 87

6.10.1 未初始化指针 87

6.10.2 非法的指针比较 88

6.10.3 忘记重新设置指针 88

第七章 函数第一部分：基础 91

7.1 函数作用域规则 91

7.1.1 局部变量 91

7.1.2 形式参数 94

7.1.3 全局变量 95

7.2 传递指针和数组 96

7.2.1 用指针调用函数 96

7.2.2 用数组调用函数 98

7.2.3 传递字符串 100

7.3 argc和argv,main（）函数的参数 101

7.3.1 传递数字命令行参数 103

7.4 return语句 104

7.4.1 从函数返回 104

7.4.2 返回值 105

7.4.3 void函数 107

7.4.4 返回指针的函数 107

7.5 函数原型 109

7.6 头文件：进一步考察 110

7.7 递归 110

第八章 函数第二部分：引用、重载和缺省参数 113

8.1 两种参数传递方法 113

8.1.1 C＋＋如何传递参数 113

8.1.2 用指针生成引用调用 114

8.2 引用参数 115

8.2.1 返回引用 118

8.2.2 生成有界数组 120

8.2.3 独立引用 121

8.2.4 使用引用的一些限制 122

8.3 函数重载 122

8.4 缺省函数参数 125

8.4.1 缺省参数与重载的对比 127

8.4.2 正确使用缺省参数 128

8.5 函数重载及多义性 128

第九章 更多的数据类型和运算符 131

9.1 访问修饰符 131

9.1.1 const 131

9.1.2 volatile 133

9.2 存储类说明符 134

9.2.1 auto 134

9.2.2 extern 134

9.2.3 static变量 135

9.2.4 register变量 138

9.3 枚举 140

9.4 bool 142

9.5 typedef 142

9.6 更多的运算符 142

9.7 位运算符 142

9.7.1 AND,OR，XOR及NOT 143

9.7.2 移位运算符 146

9.8 ？运算符 147

9.9 C＋＋简写 148

9.10 逗号运算符 149

9.11 多次赋值 150

9.12 使用sizeof 150

9.13 使用new和delete动态分配 151

9.13.1 初始化动态分配的内存 152

9.13.2 分配数组 153

9.14 优先级小结 155

第十章 结构和联合 156

10.1 结构 156

10.1.1 访问结构成员 158

10.1.2 结构数组 158

10.1.3 一个简单的库存表例子 158

10.1.4 向函数传递结构 165

10.1.5 结构赋值 165

10.1.6 指向结构的指针和箭头运算符 167

10.1.7 引用结构 169

10.1.8 结构内的数组和结构 170

10.1.9 位段 171

10.2 联合 173

10.2.1 无名联合 177

10.2.2 使用sizeof保证移值性 178

10.3 转向讨论面向对象的编程 178

第十一章 介绍类 179

11.1 类的基础 179

11.2 进一步考查类成员的访问 182

11.3 构造函数和析构函数 184

11.3.1 参数化的构造函数 187

11.4 类和结构的关系 190

11.5 联合和类的关系 191

11.6 内联函数 193

11.6.1 在类中生成内联函数 194

11.7 对象数组 195

11.8 指向对象的指针 196

11.9 对象的引用 198

第十二章 进一步考查类 199

12.1 友元函数 199

12.2 重载构造函数 202

12.3 动态初始化 204

12.3.1 对构造函数应用动态初始化 204

12.4 给对象赋值 206

12.5 把对象传给函数 207

12.5.1 构造函数、析构函数与传递对象 208

12.5.2 传递对象时的一个潜在问题 209

12.6 返回对象 211

12.6.1 返回对象时潜在问题 212

12.7 生成并使用一个拷贝构造函数 214

12.7.1 拷贝构造函数和参数 215

12.7.2 拷贝构造函数与初始化 217

12.7.3 返回对象时使用拷贝构造函数 218

12.8 this关键字 219

第十三章 运算符重载 221

13.1 使用成员函数的运算符重载 221

13.1.1 使用成员函数重载一元运算符 223

13.2 友元运算符函数 228

13.2.1 使用友元重载一元运算符 231

13.3 进一步考查赋值运算符 234

13.4 重载new和delete 238

13.5 重载（） 241

13.6 重载其他运算符 244

13.7 另一个运算符重载的例子 244

第十四章 继承 249

14.1 介绍继承 249

14.2 基类访问控制 252

14.3 使用protected成员 253

14.3.1 对基类的继承使用protected 256

14.4 继承多个基类 258

14.5 构造函数、析构函数和继承 259

14.5.1 执行构造函数和析构函数时 259

14.5.2 给基类构造函数传递参数 262

14.6 访问的许可 265

14.7 虚基类 266

第十五章 虚函数与多态性 271

15.1 指向派生类型的指针 271

15.2 虚函数 273

15.2.1 继承虚函数 275

15.2.2 为什么使用虚函数 277

15.2.3 虚函数的一个简单应用 278

15.2.4 纯虚函数和抽象类 281

15.3 早期联编与晚期联编的对比 283

第十六章 C＋＋I/O系统 285

16.1 C＋＋流 285

16.1.1 C＋＋预定义流 286

16.2 C＋＋流类 286

16.3 重载I/O运算符 286

16.3.1 生成插入器 286

16.3.2 使用友元函数来重载插入器 288

16.3.3 重载析取器 289

16.4 格式化的I/O 290

16.4.1 用ios成员函数格式化 291

16.4.2 使用I/O操纵符 294

16.4.3 生成自己的操纵符函数 296

16.5 文件I/O 297

16.5.1 打开和关闭一个文件 297

16.5.2 读写文本文件 299

16.5.3 非格式化的二进制I/O 300

16.5.4 读写数据块 302

16.5.5 检测EOF 303

16.5.6 一个文件比较的例子 304

16.5.7 更多的二进制I/O函数 305

16.6 随机访问 306

16.7 定制的I/O和文件 308

第十七章 模板与异常处理 310

17.1 通用函数 310

17.1.1 有两个通用类型的函数 312

17.1.2 显式地重载一个通用函数 313

17.1.3 通用函数的局限 314

17.2 通用类 315

17.2.1 一个有两个通用数据类型的例子 317

17.2.2 生成通用数组类 318

17.3 异常处理 319

17.3.1 使用多个catch语句 323

17.4 异常处理的选项 324

17.4.1 捕获所有的异常 324

17.4.2 限制异常 326

17.4.3 再次找出异常 328

第十八章 C＋＋的其他方面（杂类） 329

18.1 基于数组的I/O 329

18.1.1 基于数组的类 329

18.1.2 生成一个基于数组的输出流 329

18.1.3 使用数组作为输入 331

18.1.4 输入／输出基于数组的流 333

18.2 使用的动态数组 333

18.3 指向函数的指针 334

18.3.1 查找重载的函数的地址 337

18.4 静态类成员 338

18.5 使用asm关键字 339

18.6 链接规范 340

18.7 指向成员的指针运算符.*和-＞ 340

18.8 生成转换函数 342

18.9 C＋＋关键字扩展 344

第十九章 C＋＋的预处理器 346

19.1 ＃define 346

19.2 ＃crror 349

19.3 ＃include 349

19.4 条件编译指令 350

19.4.1 ＃if,#else，#elif和＃endif 350

19.4.2 ＃ifdef和＃ifndef 352

19.4.3 ＃undef 353

19.4.4 使用defined 353

19.5 ＃line 353

19.6 ＃pragma 354

19.7 ＃和＃＃预处理器运算符 355

19.8 预定义的宏名 355

19.9 最后的想法 356

附录A 基于C的I/O 357

A.1 C的I/O使用流 357

A.2 理解printf（）和scanf（） 358

A.2.1 printf（） 358

A.2.2 scanf（） 359

A.3 C的文件系统 362

A.3.1 fopen 363

A.3.2 fputc 364

A.3.3 fgetc 364

A.3.4 feof（） 365

A.3.5 fclose（） 365

A.3.6 使用fopen（）,fgetc（）,fputc（）和fclose（） 365

A.3.7 ferror（）和rewind（） 366

A.3.8 fread（）和fwrite（） 366

A.4 fseek（）与随机存取I/O 368

A.5 fprintf（）和fscanf（） 369

A.6 删除文件 369