C++从零开始学 视频教学版PDF电子书下载

第1章 为什么要学习C＋＋——认识C＋＋ 1

1.1 C/C＋＋的起源 1

1.2 C＋＋的特色 2

1.3 关于ANSI/ISO C＋＋标准 3

1.4 语言的翻译过程 4

1.5 编写代码前的准备——安装开发环境 5

1.6 小试身手——新建一个C＋＋项目 8

1.7 疑难解惑 11

疑问1 C＋＋与C的区别？ 11

疑问2 C＋＋编译过程如何？ 11

疑问3 C＋＋都有什么版本？ 11

1.8 自我评估 12

第2章 C＋＋程序结构 13

2.1 简单程序 13

2.2 C＋＋程序分析 14

2.2.1 ＃include指令及头文件 14

2.2.2 main函数 15

2.2.3 变量声明和定义 16

2.2.4 函数的声明 18

2.2.5 关于注释 19

2.3 输入输出对象 21

2.3.1 cout输出数据 21

2.3.2 cin读取输入数据 24

2.4 标识符 25

2.4.1 保留字 26

2.4.2 标识符命名 26

2.5 预处理 26

2.6 命名空间 29

2.6.1 命名空间的定义 29

2.6.2 using关键字 30

2.6.3 命名空间std 32

2.7 小试身手——入门经典程序 32

2.8 疑难解惑 34

疑难1 下列标识符哪些是合法的？ 34

疑难2 下面一段程序的含义是什么？ 34

疑难3 注释有什么作用？C＋＋中有哪几种注释的方法？它们之间有什么区别？ 35

2.9 自我评估 35

第3章 基本数据类型 36

3.1 变量与常量 36

3.1.1 变量 36

3.1.2 常量 39

3.2 基本变量类型 42

3.2.1 整数类型 42

3.2.2 字符类型 43

3.2.3 浮点数类型 45

3.2.4 布尔类型 47

3.3 typedef 48

3.4 小试身手——测试基本数据类型的字节长度 51

3.5 疑难解惑 52

疑问1 C＋＋在代码移植中，使用整型时注意什么？ 52

疑问2 C＋＋中，0所扮演的不同角色是什么？ 53

疑问3 typedef和define的区别是什么？ 53

3.6 自我评估 53

第4章 运算符和表达式 54

4.1 运算符概述 54

4.1.1 赋值运算符 54

4.1.2 算术运算符 55

4.1.3 关系运算符 57

4.1.4 逻辑运算符 58

4.1.5 自增和自减运算符 60

4.1.6 位逻辑运算符 61

4.1.7 移位运算符 63

4.1.8 三元运算符 64

4.1.9 逗号运算符 65

4.1.10 类型转换运算符 66

4.2 运算符优先级和结合性 67

4.2.1 运算符优先级 67

4.2.2 运算符结合性 68

4.3 小试身手——综合运用运算符 70

4.4 疑难解惑 71

疑问1 C＋＋位逻辑运算符的作用？ 71

疑问2 加、减、乘、除结果的数据类型和什么有关系？ 72

疑问3 使用条件运算符需要注意什么？ 72

4.5 自我评估 72

第5章 程序流程控制 73

5.1 顺序语句 73

5.2 条件判断语句 74

5.2.1 if条件 74

5.2.2 if-else条件 76

5.2.3 条件运算符 77

5.3 循环语句 78

5.3.1 for循环 78

5.3.2 while循环 79

5.3.3 do-while循环 81

5.4 跳出循环 82

5.4.1 continue 82

5.4.2 break 83

5.5 多重选择语句 84

5.6 小试身手——流程控制综合案例 86

5.7 疑难解惑 89

疑问1 do-while和while有什么区别？ 89

疑问2 条件语句如何嵌套？如何匹配else子句？ 89

疑问3 switch语句的执行顺序是什么？ 90

5.8 自我评估 90

第6章 函数 91

6.1 函数的基本结构 91

6.1.1 函数的声明、定义和调用 91

6.1.2 参数的传递方式 93

6.1.3 函数的默认参数 95

6.1.4 函数的返回值 97

6.2 变量的作用域 97

6.2.1 局部变量 97

6.2.2 静态局部变量 98

6.2.3 外部变量 99

6.2.4 寄存器变量 100

6.3 特殊函数调用方式——递归调用 101

6.4 内联函数 102

6.5 预处理器 103

6.5.1 ＃define预处理器 103

6.5.2 ＃define的作用 104

6.5.3 const修饰符 105

6.6 函数的重载 106

6.7 小试身手——汉诺塔问题函数 108

6.8 疑难解惑 109

疑问1 const和＃define的区别？ 109

疑问2 使用内联函数，应该注意什么问题？ 109

疑问3 C＋＋中，形参与实参有什么区别？ 109

6.9 自我评估 110

第7章 数组与字符串 111

7.1 一维数组 111

7.1.1 一维数组的声明 111

7.1.2 数组初始化 112

7.1.3 数组的操作 113

7.2 二维数组和多维数组 115

7.2.1 二维数组的声明 115

7.2.2 二维数组的使用和存取 115

7.2.3 多维数组 117

7.3 数组与函数 119

7.3.1 一维数组作为函数的参数 119

7.3.2 传送多维数组到函数 120

7.4 字符串类 121

7.4.1 字符串的声明 121

7.4.2 字符串的输入和输出 122

7.4.3 字符串处理 123

7.5 小试身手——判断字符串回文 126

7.6 疑难解惑 128

疑问1 使用数组时，如何清0数组？ 128

疑问2 如何将int类型转化为字符串？ 128

疑问3 C＋＋中，两个字符串怎么连接？ 129

7.7 自我评估 129

第8章 指针 130

8.1 指针概述 130

8.1.1 什么是指针 130

8.1.2 为什么要用指针 131

8.1.3 指针的地址 131

8.2 指针变量 132

8.2.1 指针变量的声明 132

8.2.2 指针变量的使用 133

8.3 指针与函数 134

8.3.1 指针传送到函数中 134

8.3.2 返回值为指针的函数 135

8.3.3 函数指针 137

8.4 指针与数组 138

8.4.1 指针的算术运算 138

8.4.2 利用指针存储一维数组的元素 139

8.4.3 利用指针传输一维数组到函数中 140

8.5 指针与字符串 141

8.6 void指针 142

8.7 指向指针的指针 142

8.8 动态内存配置 143

8.8.1 使用基本数据类型做动态配置 144

8.8.2 使用数组做动态配置 145

8.9 小试身手——判断字符串中有多少个整数 146

8.10 疑难解惑 148

疑问1 数组指针与指针数组的区别？ 148

疑问2 指针函数和函数指针的区别？ 148

疑问3 C＋＋中，动态内存分配应注意什么问题？ 148

8.11 自我评估 149

第9章 struct和其他复合类型 150

9.1 struct 150

9.1.1 struct的声明 150

9.1.2 struct变量的初始化与使用 152

9.1.3 struct数组初始化 153

9.2 将结构体变量作为函数参数 155

9.2.1 将整个结构体传送到函数 155

9.2.2 传送结构体的地址到函数 156

9.3 union 157

9.3.1 union的定义和声明 157

9.3.2 union类型的初始化和使用 158

9.3.3 struct和union的差异 159

9.4 enum 160

9.4.1 enum的定义和声明 160

9.4.2 enum的初始化和使用 161

9.5 小试身手——判断字符串中有多少个整数 163

9.6 疑难解惑 165

疑问1 C和C＋＋中的struct有什么不同？ 165

疑问2 定义结构体类型变量要注意什么问题？ 165

疑问3 C＋＋中共用体有什么特点？ 165

9.7 自我评估 166

第10章 类 167

10.1 认识类 167

10.1.1 类的基本概念 167

10.1.2 类的定义 167

10.1.3 类对象的生成 169

10.1.4 类对象指针 170

10.2 成员函数 172

10.3 嵌套类 174

10.4 const成员函数 174

10.5 类成员的访问控制 176

10.5.1 私有成员 176

10.5.2 公有成员 177

10.5.3 保护成员 179

10.6 静态成员 179

10.6.1 静态数据成员 179

10.6.2 静态成员函数 181

10.7 友元 182

10.8 小试身手——栈类的实现 184

10.9 疑难解惑 186

疑问1 定义类要注意哪些事项？ 186

疑问2 如何选择使用类和结构？ 186

疑问3 C＋＋中，const成员和const对象的区别？ 186

10.10 自我评估 186

第11章 构造函数和析构函数 188

11.1 构造函数初始化类对象 188

11.1.1 什么是构造函数 188

11.1.2 使用构造函数 189

11.2 析构函数清除类对象 190

11.2.1 析构函数的概念 191

11.2.2 析构函数的调用 191

11.3 默认构造函数 193

11.4 重载构造函数 194

11.4.1 重载构造函数的作用 194

11.4.2 重载构造函数的调用 194

11.5 类对象数组的初始化 195

11.5.1 类对象数组调用 196

11.5.2 类对象数组和默认构造函数 197

11.5.3 类对象数组和析构函数 199

11.6 拷贝构造函数 200

11.6.1 拷贝构造函数的概念 200

11.6.2 深拷贝和浅拷贝 201

11.7 小试身手——构造函数和析构函数的应用 203

11.8 疑难解惑 205

疑问1 派生类如何初始化基类继承的成员？ 205

疑问2 基类和派生类构造函数的执行顺序是什么？ 205

疑问3 基类和派生类的析构函数的执行顺序是什么？ 206

11.9 自我评估 206

第12章 运算符的重载 207

12.1 什么是运算符重载 207

12.1.1 运算符重载的形式 208

12.1.2 可重载的运算符 210

12.2 重载前置运算符和后置运算符 210

12.2.1 重载前置运算符 211

12.2.2 重载后置运算符 212

12.3 插入运算符和析取运算符的重载 214

12.3.1 插入运算符的重载 214

12.3.2 析取运算符的重载 215

12.4 常用运算符的重载 217

12.4.1 “＜”运算符的重载 217

12.4.2 “＋”运算符的重载 218

12.4.3 “＝”赋值运算符的重载 220

12.5 小试身手——运算符重载实例 222

12.6 疑难解惑 224

疑问1 在什么情况下使用运算符重载？ 224

疑问2 重载一元运算符时，应该用友元函数重载吗？ 224

疑问3 是否可以用一个重载的运算符，重载另一个运算符？ 224

12.7 自我评估 224

第13章 类的继承 225

13.1 面向对象编程概述 225

13.1.1 面向对象编程的几个概念 225

13.1.2 面向对象编程与面向过程编程的区别 226

13.2 继承的基本概念 226

13.2.1 基类和继承类 227

13.2.2 简单的基础实例 228

13.2.3 调用父类中的构造函数 233

13.3 子类存取父类成员 236

13.3.1 私有成员的存取 236

13.3.2 继承与静态成员 238

13.3.3 多继承 239

13.4 小试身手——继承的应用 242

13.5 疑难解惑 243

疑问1 在类继承中，构造函数的执行顺序是什么？ 243

疑问2 在多继承中，如果两个基类有同名的变量，如何消除二义性？ 243

疑问3 类不能继承基类的哪些特征？ 243

13.6 自我评估 244

第14章 虚函数和抽象类 245

14.1 什么是虚函数 245

14.1.1 虚函数的作用 245

14.1.2 动态绑定和静态绑定 247

14.2 抽象类与纯虚函数 249

14.2.1 定义纯虚函数 249

14.2.2 抽象类的作用 250

14.2.3 虚析构函数 252

14.3 抽象类的多重继承 253

14.4 虚函数表 254

14.4.1 什么是虚函数表 255

14.4.2 继承关系的虚函数表 256

14.5 小试身手——抽象类的应用 258

14.6 疑难解惑 260

疑问1 虚函数在编程过程中的使用技巧？ 260

疑问2 含有纯虚函数的类是否可以被实例化？ 261

疑问3 为什么在虚函数和纯函数中不能有static标识符？ 261

14.7 自我评估 261

第15章 C＋＋中文件处理 262

15.1 文件的基本概念 262

15.1.1 文件I/O 262

15.1.2 文件顺序读写 266

15.1.3 随机文件读写 266

15.2 文件的打开与关闭 268

15.2.1 文件的打开 268

15.2.2 文件的关闭 270

15.3 文本文件的处理 271

15.3.1 将变量写入到文件 271

15.3.2 将变量写入文件尾部 272

15.3.3 从文本文件中读入变量 272

15.3.4 使用get（）、getline（）和put（）函数 273

15.4 二进制文件的处理 276

15.5 小试身手——文件操作 278

15.6 疑难解惑 280

疑问1 get（）和getline（）的区别？ 280

疑问2 缓存同步如何实现？ 280

疑问3 文件中，插入器和析取器如何定义使用？ 280

15.7 自我评估 281

第16章 异常处理 282

16.1 异常的基本概念 282

16.2 异常处理机制 282

16.3 抛出异常 284

16.4 重新抛出异常 286

16.5 捕获所有异常 287

16.6 不是错误的异常 288

16.7 未捕捉到的异常 289

16.8 标准异常 289

16.9 异常规范 290

16.10 异常与继承 290

16.11 异常处理的应用 292

16.11.1 自定义异常类 292

16.11.2 捕获多个异常 293

16.12 小试身手——异常处理 295

16.13 疑难解惑 297

疑问1 抛出异常而没有捕获会如何？ 297

疑问2 异常处理通过什么来匹配？ 297

疑问3 异常抛出后资源如何释放？ 297

16.14 自我评估 298

第17章 模板与类型转换 299

17.1 模板 299

17.1.1 函数模板 300

17.1.2 类模板 301

17.1.3 模板参数 303

17.1.4 模板的特殊化 304

17.1.5 重载和函数模板 305

17.2 类型识别和强制转换运算符 307

17.2.1 运行时类型识别 307

17.2.2 强制类型转换运算符 311

17.3 小试身手——模板应用 313

17.4 疑难解惑 315

疑问1 模板类实现有什么方法？ 315

疑问2 模板类可以继承吗？ 315

疑问3 4种强制类型转换有什么异同？ 316

17.5 自我评估 316

第18章 容器和迭代器 317

18.1 STL 317

18.2 迭代器 317

18.3 顺序容器 319

18.3.1 向量 319

18.3.2 双端队列 320

18.3.3 列表 322

18.4 关联容器 323

18.4.1 集合和多集 323

18.4.2 映射（map）和多重映射（multimap） 325

18.5 容器适配器 326

18.5.1 栈 326

18.5.2 队列 327

18.5.3 优先级队列 329

18.6 小试身手——容器操作实例 330

18.7 疑难解惑 335

疑问1 顺序容器和关联容器有什么区别？ 335

疑问2 什么是迭代器的范围？ 335

疑问3 STL有哪7种主要容器？ 335

疑问4 deque和vector的不同之处？ 335

18.8 自我评估 335