易学C++(第2版)电子书

内容提要

第1版前言

本书的特点

本书约定

特别鸣谢

第2版前言

前篇 过程化的程序设计

第1章 C++从这里开始

1.1 软件与程序

1.2 程序设计要做什么

1.3 选好一种语言

1.4 C++能够做些什么

1.5 C语言、C++语言和Visual C++

1.6 学习程序设计总体建议

1.7 C++学习的常见问题

1.8 缩略语和术语表

1.9 方法指导

1.10 习题

第2章 Hello，World！

2.1 Visual Studio 2012的安装和启动

2.2 如何创建一个程序

2.3 输出与输入

2.4 Visual C++ 6.0的使用

2.5 小巧的Dev-C++

2.5.1 Dev-C++的安装

2.5.2 Dev-C++的配置

2.5.3 Dev-C++的使用

2.6 缩略语和术语表

2.7 方法指导

2.8 习题

第3章 各种各样的箱子——变量

3.1 会变的箱子

3.1.1 数据类型

3.1.2 变量名

3.1.3 变量的初始化

3.2 常用的基本数据类型

3.2.1 整型（Integer）

3.2.2 浮点型（Floating Point）

3.2.3 字符型（Character）

3.2.4 布尔型（Boolean）

3.3 不会变的箱子

3.4 算术表达式

3.4.1 操作符和表达式

3.4.2 算术操作符

3.5 箱子的转换

3.5.1 隐式转换

3.5.2 显式转换

3.6 缩略语和术语表

3.7 方法指导

3.8 习题

第4章 要走哪条路——分支结构

4.1 如果……

4.1.1 条件——关系操作符

4.1.2 条件——逻辑操作符

4.1.3 &&和||的妙用

4.2 否则……

4.2.1 如果与否则

4.2.2 如果里的如果……

4.2.3 找朋友

4.3 爱判断的问号

4.4 切换的开关

4.4.1 多路开关——switch

4.4.2 巧用switch

4.5 缩略语和术语表

4.6 方法指导

4.7 习题

第5章 有个圈儿的程序——循环结构

5.1 程序赛车

5.1.1 循环语句for

5.1.2 加加和减减

5.1.3 巧用for

5.2 退出比赛和进维修站

5.2.1 退出比赛——break

5.2.2 进维修站——continue

5.3 圈圈里的圈圈

5.3.1 循环的嵌套

5.3.2 怎么让输出的东西更好看

5.4 当……

5.4.1 当型循环

5.4.2 导火索——do

5.5 缩略语和术语表

5.6 方法指导

5.7 习题

第6章 好用的工具——函数

6.1 简单的工具

6.1.1 工具的说明书

6.1.2 如何使用系统造好的工具

6.2 打造自己的工具

6.2.1 函数的声明

6.2.2 函数的定义

6.2.3 函数是如何运行的

6.2.4 返回语句——return

6.2.5 关于主函数

6.2.6 同名同姓

6.2.7 函数存在的意义

6.3 多功能开瓶器——函数重载

6.4 自动的“工具”

6.4.1 默认参数

6.4.2 定义默认参数的顺序

6.4.3 默认参数和重载函数的混淆

6.5 给变量和参数起个“绰号”——引用

6.5.1 引用的声明

6.5.2 用引用传递参数

6.6* 函数里的函数——递归

6.7 缩略语和术语表

6.8 方法指导

6.9 习题

第7章 好大的“仓库”——数组

7.1 让计算机处理更多数据——使用数组

7.1.1 数组的声明

7.1.2 数组的操作

7.1.3 数组的初始化

7.1.4 省略数组大小

7.2 仓库是怎样造成的

7.2.1 内存和地址

7.2.2 数组在内存中的存储情况

7.2.3 字符的存储情况

7.2.4 字符数组在内存中的存储情况

7.3 向函数传递数组

7.4 二维数组

7.4.1 线与面

7.4.2 二维数组的声明和初始化

7.4.3 省略第一维的大小

7.4.4 二维数组在内存中的存储情况

7.4.5 向函数传递二维数组

7.4.6 二维数组转化成一维数组

7.5 缩略语和术语表

7.6 方法指导

7.7 习题

第8章 内存里的快捷方式——指针

8.1 什么是指针

8.2 指针变量的声明和使用

8.2.1 指针的类型

8.2.2 指针变量的声明

8.2.3 获取地址和指针变量初始化

8.2.4 特殊的值——NULL

8.2.5 指针的使用——间接引用

8.3 指针的操作

8.3.1 指针的加减运算

8.3.2 指针的关系运算

8.4 指针与保护

8.4.1 对内存只读的指针

8.4.2 指针型常量

8.5 指针与数组

8.5.1 数组名的实质

8.5.2 指针数组

8.6 指针与函数

8.6.1 指针作为参数

8.6.2 指针作为返回值

8.7 更灵活的存储

8.7.1 如何获得堆内存空间

8.7.2 有借有还，再借不难

8.8 缩略语和术语表

8.9 方法指导

8.10 习题

第9章 自己设计的箱子——枚举和结构

9.1 我的类型我做主——枚举类型

9.2 设计一个收纳箱——结构类型

9.3 结构与函数

9.3.1 结构作为参数

9.3.2 结构作为返回值

9.4 结构数组与结构指针

9.4.1 结构数组

9.4.2 结构指针

9.5 自行车的链条——链表

9.6 链表的实现

9.6.1 链表的创建和遍历

9.6.2 链表的查询

9.6.3 插入结点

9.6.4 删除结点

9.6.5 清除链表

9.7 缩略语和术语表

9.8 方法指导

9.9 习题

中篇 实战程序设计

第10章 如何阅读程序代码

10.1 整体把握法

10.1.1 阅读代码的顺序

10.1.2 整体把握语意

10.2 经验法

10.3 模拟法

10.4 方法指导

10.5 习题

第11章 如何调试程序代码

11.1 再谈变量

11.1.1 标识符

11.1.2 全局变量和局部变量

11.1.3 静态局部变量

11.1.4 变量的作用域

11.1.5 变量的可见性

11.2 头文件的奥秘

11.2.1 如何创建一个头文件

11.2.2 头文件里有什么

11.2.3 头文件和源文件

11.2.4 细说#include

11.2.5 尖括号和双引号的区别

11.2.6 外部依赖项

11.3 更快更好地完成程序调试

11.3.1 如何检查语法错误

11.3.2 常见语法错误及解决方法

11.4 最麻烦的问题

11.4.1 见识运行时错误

11.4.2 查找错误点

11.5 在VS2012里调试程序

11.5.1 如何设置和移除断点

11.5.2 走起

11.5.3 调试工具栏

11.5.4 监视和自动窗口

11.5.5 如何通过调试找到错误

11.6 缩略语和术语表

11.7 方法指导

11.8 习题

第12章 如何编写程序代码

12.1 程序设计的基本步骤

12.2 三类问题

12.2.1 算

12.2.2 找

12.2.3 实现功能

12.3 函数的递归

12.3.1 什么是栈

12.3.2 函数的调用机制

12.3.3 小试牛刀——用递归模拟栈

12.3.4* 递归的精髓

12.4 缩略语和术语表

12.5 方法指导

12.6 习题

第13章 异常的处理

13.1 亡羊也要补牢

13.2 处理异常

13.2.1 尽力尝试

13.2.2 抓住异常

13.3 抛出异常

13.4 缩略语和术语表

13.5 方法指导

13.6 习题

后篇 面向对象的程序设计

第14章 初识对象

14.1 对象就是物体

14.2 一个字符串也是对象

14.2.1 奇妙的点

14.2.2 对字符串的操作

14.3 面向对象特点一：封装性

14.4 缩略语和术语表

14.5 方法指导

14.6 习题

第15章 再识对象

15.1 类是一种数据类型

15.1.1 类与结构

15.1.2 类的声明与定义

15.2 公有和私有

15.3 成员函数

15.3.1 成员函数的声明

15.3.2 常成员函数

15.3.3 成员函数的重载

15.3.4 成员函数的定义

15.4 如何方便地查看类

15.5 对象、引用和指针

15.5.1 对象的引用

15.5.2 对象指针

15.6 缩略语和术语表

15.7 方法指导

15.8 习题

第16章 造物者与毁灭者——对象生灭

16.1 麻烦的初始化

16.2 造物者——构造函数

16.2.1 构造函数的声明与定义

16.2.2 带参数的构造函数

16.3 先有结点，还是先有链表

16.4 克隆技术——拷贝构造函数

16.4.1 拷贝构造函数

16.4.2 默认拷贝构造函数

16.4.3 拷贝构造函数存在的意义

16.5 毁灭者——析构函数

16.6 缩略语和术语表

16.7 方法指导

16.8 习题

第17章 共有财产·好朋友·操作符

17.1 有多少个结点

17.1.1 静态成员数据

17.1.2 静态成员数据的初始化

17.1.3 静态成员函数

17.2 类的好朋友

17.2.1 友元类

17.2.2 友元函数

17.2.3 友元的利与弊

17.3 多功能的操作符——操作符的重载

17.3.1 操作符作为成员函数

17.3.2 操作符作为友元函数

17.3.3 又见加加和减减

17.4 缩略语和术语表

17.5 方法指导

17.6 习题

第18章 父与子——类的继承

18.1 剑士·弓箭手·法师的困惑

18.2 面向对象特点二：继承性

18.3 继承的实现

18.3.1 私有和保护

18.3.2 一个简单的例子

18.3.3 继承的方式

18.4 子类对象的生灭

18.4.1 子类对象的构造

18.4.2 子类对象的析构

18.5 继承与对象指针

18.5.1 父类指针与子类对象

18.5.2 猜猜它是谁

18.6 面向对象特点三：多态性

18.7 多态与虚函数

18.7.1 多态的实现

18.7.2 无法实现多态的虚函数

18.8 虚析构函数

18.9 抽象类与纯虚函数

18.10 多重继承

18.11 缩略语和术语表

18.12 方法指导

18.13 习题

第19章 再谈输入与输出

19.1 cout和cin是什么

19.2 输入/输出的重定向

19.2.1 输入重定向

19.2.2 输出重定向

19.2.3 无法被重定向的cerr

19.3 文件的输入与输出

19.4 更巧妙地输入和输出

19.4.1 能整行输入的getline

19.4.2 能读取判断末尾的eof

19.4.3 能计数的gcount

19.4.4 能设置域宽的width

19.5 插入操作符的重载

19.5.1 插入操作符

19.5.2 插入操作符的常用重载方式

19.6 缩略语和术语表

19.7 方法指导

19.8 习题

第20章 万用的模板

20.1 函数模板

20.1.1 从为什么需要模板说起

20.1.2 声明与定义函数模板

20.1.3 函数模板与重载

20.2 类模板

20.2.1 类模板的声明和定义

20.2.2 链表类模板实例

20.3 从数组到向量

20.3.1 向量的性能

20.3.2 对向量的操作

20.4 缩略语和术语表

20.5 方法技巧

20.6 习题

第21章 博大精深的STL

21.1 STL里有什么

21.2 超级指针——迭代器

21.3 有了算法，何必还需自己写

21.4 从箱子到容器

21.4.1 链表，再见！

21.4.2 交集和并集

21.5 函数也能是对象

21.6 空间分配好管家

21.7 缩略语和术语表

21.8 方法指导

21.9 习题

附录A 常用保留字列表

附录B 常见编译错误和解决方法

附录C 参考文献

附录D 推荐书目

欢迎来到异步社区！

异步社区的来历

社区里都有什么？

购买图书

下载资源

与作译者互动

灵活优惠的购书

纸电图书组合购买

社区里还可以做什么？

提交勘误

写作

会议活动早知道

加入异步