C++轻松入门PDF格式文档图书下载

第1篇 初识C++ 3

第1章 面向对象的设计 3

1.1 接近自然的思维方式—面向对象的思想 3

1.1.1 无处不在的对象 3

1.1.2 对象的组织类 3

1.1.3 类与对象的关系 3

1.1.4 自然的思维方式面向对象 4

1.1.5 “基于”与“面向”的差别 4

1.2 传统设计与面向对象设计的比较 4

1.2.1 从“北京烤鸭”到面向对象 4

1.2.2 传统设计方法的缺点 5

1.2.3 面向对象设计方法的优点 5

1.3 面向对象的核心思想—抽象 6

1.3.1 核心思想—抽象 6

1.3.2 抽象的方法 6

1.4 面向对象的分析与设计 7

1.4.1 面向对象的分析方法 7

1.4.2 面向对象的设计 8

1.4.3 “小试牛刀”的结论 9

1.5 小结 9

1.6 小测试 9

第2章 认识C++开发利器—Visual C++ 11

2.1 C++的开发利器—Visual C++ 11

2.2 Visual C++的集成开发环境 12

2.2.1 启动Visual C++ 12

2.2.2 简单的主窗口 12

2.3 一目了然的菜单栏 13

2.3.1 File（文件）菜单 13

2.3.2 Edit（编辑）菜单 16

2.3.3 View（视图）菜单 18

2.3.4 Insert（插入）菜单 19

2.3.5 Proigect（项目）菜单 20

2.3.6 Build（生成）菜单 20

2.3.7 Tools（工具）菜单 21

2.3.8 Window（窗口）菜单 21

2.3.9 Help（帮助）菜单 22

2.3.10 Debug（调试）菜单 22

2.4 快捷方便的工具栏 22

2.4.1 Standard工具栏 23

2.4.2 Build工具栏 23

2.4.3 Debug工具栏 24

2.5 小结 24

2.6 小测试 24

第3章 开始C++之旅 26

3.1 神奇的“向导”—创建控制台程序 26

3.2 Hello World示例 27

3.3 解释这个C++程序 28

3.4 创建自己的Hello World 29

3.5 小结 30

3.6 小测试 30

第4章 C++基本功 32

4.1 数据与程序的区别 32

4.1.1 烹饪的菜谱—程序 32

4.1.2 烹饪的菜品—数据 32

4.2 标识符与关键字 33

4.2.1 什么是标识符 33

4.2.2 需要注意的关键字 33

4.3 分隔符与注释符 33

4.3.1 划分语句的分隔符 34

4.3.2 使语句无效的注释符 34

4.4 各式各样的“口袋”—变量 34

4.4.1 程序中的会变的“口袋”—定义变量 34

4.4.2 变量的数据类型 35

4.4.3 变量名 35

4.4.4 变量的初始化 35

4.5 常用的基本数据类型 35

4.5.1 整数型 36

4.5.2 实数型 37

4.5.3 字符型与字符串 38

4.5.4 布尔型 40

4.6 程序中的不会变的“口袋”—常量 41

4.6.1 创造不会变的口袋—定义常量 41

4.6.2 各种进制的常量 42

4.7 给变量起个“绰号”—引用 42

4.8 综合应用—用程序来计算圆的面积 43

4.9 小结 43

4.10 小测试 43

第5章 C++的基本招式 46

5.1 C++中的运算符与表达式 46

5.1.1 运算符与表达式 46

5.1.2 算术运算符 47

5.1.3 赋值运算符 48

5.1.4 “加加”和“减减” 48

5.1.5 复合运算符 49

5.1.6 位运算符 49

5.1.7 关系运算符 52

5.1.8 不像运算符的运算符 53

5.2 运算符的优先级和结合性 53

5.3 各种“口袋”之间的转换 55

5.3.1 隐式转换 55

5.3.2 显式转换 56

5.4 小结 56

5.5 小测试 57

第6章 让C++程序听话—控制语句 58

6.1 构成C++程序的基本—语句 58

6.1.1 表达式语句与空语句 58

6.1.2 复合语句 59

6.2 让程序选择自己的路—条件选择语句 59

6.2.1 如果与否则 59

6.2.2 逻辑运算符的使用—＆＆和|| 62

6.2.3 爱判断的问号 64

6.3 不怕重复的工作者—循环语句 65

6.3.1 当型循环while 65

6.3.2 当型循环的兄弟do-while 66

6.3.3 循环语句for 67

6.3.4 省略表达式1的for语句 68

6.3.5 省略表达式2的for语句 68

6.3.6 省略表达式3的for语句 68

6.3.7 省略表达式1和3的for语句 69

6.3.8 3个表达式全部省略的for语句 69

6.3.9 与循环变量无关的for语句 69

6.4 多样的选择—switch 70

6.4.1 用switch对学生成绩进行分类 70

6.4.2 多个执行结果共用1个条件 72

6.5 循环的嵌套 73

6.5.1 while语句的自身嵌套 73

6.5.2 for语句的自身嵌套 73

6.5.3 do-while语句的自身嵌套 73

6.5.4 for语句循环内嵌套while循环 73

6.5.5 while语句循环内嵌套多重for循环 74

6.5.6 do-while语句内嵌套其他类型的多重循环 74

6.6 退出与跳过 75

6.6.1 退出-break 75

6.6.2 跳过-continue 76

6.7 控制语句综合示例 77

6.7.1 四则运算深入学习while和switch 78

6.7.2 判断用户输入的数是否是素数—深入学习循环和条件判断 78

6.8 小结 79

6.9 小测试 80

第7章 C++程序中的“经理”—函数 82

7.1 明白什么是“经理”—函数的概念 82

7.1.1 什么是函数 82

7.1.2 使用函数的好处 83

7.1.3 程序中的“总经理”-Main函数 83

7.2 如何培养自己的“经理” 83

7.2.1 函数的定义 83

7.2.2 C++中函数的声明 85

7.3 给你的“经理”更多的资源—函数的参数 87

7.3.1 形式参数与实际参数 87

7.3.2 函数的计算的结果—函数的返回值 89

7.3.3 函数参数的求值顺序 90

7.3.4 可以包含默认的初始化参数 91

7.3.5 参数的修饰符 92

7.4 使用程序中的“经理”—函数的调用 93

7.4.1 函数调用表达式 93

7.4.2 函数调用的方式 94

7.4.3 函数的传值调用 94

7.4.4 函数的引用调用 95

7.5 如何让一个“经理”有更多的能力—函数的重载 96

7.5.1 参数类型上不同的重载函数 96

7.5.2 参数个数上不同的重载函数 97

7.6 “经理”间的协助—函数的嵌套调用 97

7.7 特殊的“经理”—内联和递归函数 98

7.7.1 内联函数 98

7.7.2 递归函数 100

7.8 “挖墙角”—使用C++的系统函数 102

7.8.1 系统函数的使用 102

7.8.2 字符串处理函数 103

7.9 小结 106

7.10 小测试 106

第8章 决定生存的权力—存储分类符 108

8.1 存储分类符和作用域 108

8.1.1 存储分类符的意义 108

8.1.2 什么是作用域 108

8.2 各种各样分类符的作用域及其生存期 109

8.2.1 自动变量 109

8.2.2 寄存器变量 110

8.2.3 静态变量 111

8.2.4 外部变量 113

8.3 内部函数和外部函数 115

8.3.1 内部函数 115

8.3.2 外部函数 117

8.4 小结 118

8.5 小测试 118

第9章 C++中的“大口袋”——数组 120

9.1 编了号的“大口袋” 120

9.1.1 内存中的大口袋—数组的概念 120

9.1.2 如何创造一个“大口袋”—数组的声明和定义 120

9.2 搞明白数组在内存中如何存储 121

9.3 “大口袋”的特性 122

9.3.1 在声明时初始化数组 122

9.3.2 数组元素的访问 123

9.3.3 数组可以传递给函数 124

9.4 二维数组 125

9.4.1 二维数组的声明和初始化 125

9.4.2 省略第一维的大小 126

9.4.3 二维数组在内存中的存储方式 126

9.4.4 二维数组元素的访问 127

9.4.5 二维数组转换为一维数组 127

9.5 只装“字符”的数组 128

9.5.1 创造字符数组及其初始化 128

9.5.2 字符数组元素的访问 128

9.5.3 特殊的字符串结束符 129

9.6 小结 129

9.7 小测试 130

第10章 让人迷惑的指针 131

10.1 变量的“向导”—指针 131

10.2 指针变量的声明和使用 132

10.2.1 指针变量的类型 132

10.2.2 指针变量的声明 132

10.2.3 获得地址并对指针变量进行初始化 133

10.2.4 特殊的值—NULL 133

10.2.5 指针的使用 133

10.2.6 指向指针变量的指针 134

10.3 指针变量的操作 135

10.3.1 指针变量的加减运算 135

10.3.2 指针变量的关系运算 136

10.4 数组、字符串和指针 136

10.4.1 数组和指针 136

10.4.2 一维数组中元素的指针表示法 137

10.4.3 二维数组的指针表示法 138

10.4.4 字符串和指针 138

10.5 常量指针与指针常量 139

10.5.1 常量指针 139

10.5.2 指针常量 140

10.6 指针与函数 141

10.6.1 指针作为参数 141

10.6.2 指针作为返回值 142

10.7 c++中灵活的空间—堆内存 143

10.7.1 如何获得堆内存并使用 143

10.7.2 如何释放堆内存 144

10.8 小结 145

10.9 小测试 146

第11章 自己设计的数据类型—结构 148

11.1 自定义的数据类型—结构的概念 148

11.2 如何制作自定义数据类型—结构类型的声明 149

11.3 结构类型变量的定义 149

11.3.1 结构类型变量的定义 149

11.3.2 typedef的使用 150

11.4 对结构变量的赋值 151

11.5 结构成员的访问 151

11.6 特殊的自定义类型—枚举类型 152

11.6.1 有限的可能性——枚举 157

11.6.2 枚举变量的声明和赋值 153

11.7 结构类型的数组和指针 153

11.7.1 结构数组 153

11.7.2 结构指针 155

11.8 结构与函数 155

11.8.1 结构作为参数 155

11.8.2 结构作为返回值 157

11.9 结构中的结构 158

11.9.1 指针变量作为结构成员 158

11.9.2 结构变量作为结构成员 159

11.10 小结 159

11.11 小测试 160

第12章 C++的预处理程序指令 162

12.1 C++的预处理功能 162

12.2 INCLUDE命令 163

12.3 简单的字符串替换 164

12.3.1 宏定义 164

12.3.2 取消宏定义 165

12.4 定义宏函数 166

12.5 条件编译 167

12.5.1 ifdef-else-endif格式 167

12.5.2 ifndef-else-endif格式 167

12.5.3 if-else-endif格式 167

12.6 头文件的编写 168

12.7 小结 169

12.8 小测试 170

第2篇 C++的新特性 173

第13章 类 173

13.1 面向对象设计中的类机制 173

13.2 从结构到类的转变 173

13.2.1 成为过去的结构 173

13.2.2 面向对象的类 175

13.3 类的实例—对象 175

13.3.1 类与对象关系 176

13.3.2 对象的声明 176

13.3.3 对象成员的访问 176

13.4 类的数据成员 179

13.5 类的成员函数 179

13.5.1 成员函数的声明 179

13.5.2 成员函数的实现 180

13.5.3 成员函数的重载 181

13.5.4 给成员函数的参数设置默认值 182

13.6 类对成员的访问控制 183

13.6.1 成员控制的优点 183

13.6.2 各种控制关键字 183

13.6.3 public关键字 184

13.6.4 private关键字 184

13.7 小结 185

13.8 小测试 186

第14章 类中特殊的函数与常类型 187

14.1 对象的创造者—构造函数 187

14.1.1 默认的构造函数 187

14.1.2 带参数的构造函数 188

14.1.3 带默认参数的构造函数 189

14.1.4 对象“克隆”—拷贝构造函数 190

14.2 对象的毁灭者—析构函数 191

14.3 类中的常类型 192

14.3.1 常对象 192

14.3.2 常成员函数 192

14.3.3 常数据成员 193

14.4 小结 194

14.5 小测试 195

第15章 类与对象的各种指针和引用 196

15.1 对象与函数 196

15.1.1 对象指针作为函数的参数 196

15.2.2 对象引用作为函数的参数 197

15.3 一串连续的对象—对象数组 198

15.4 子对象与堆对象 200

15.4.1 子对象 200

15.4.2 堆对象 201

15.4.3 学习删除堆对象并综合练习堆对象的创建、删除 202

15.5 小结 204

15.6 小测试 204

第16章 共有结点、友元与操作符 205

16.1 类中的共有结点 205

16.1.1 静态数据成员 205

16.1.2 静态成员函数 207

16.2 This指针 208

16.3 友元函数与友元类 209

16.3.1 友元函数 210

16.3.2 友元类 211

16.4 多功能的操作符 212

16.5 文件输入输出对象的使用 216

16.5.1 文件的打开与关闭 216

16.5.2 写入数据到文件 217

16.5.3 读取文件数据 217

16.6 小结 218

16.7 小测试 218

第17章 父子关系——继承 220

17.1 父与子—继承 220

17.1.1 子承父业—继承的概念 220

17.1.2 继承的意义 220

17.2 单继承的实现 221

17.2.1 子类的声明 221

17.2.2 子类的继承方式和存取权限 222

17.3 子类的构造与析构函数及类型适应 224

17.3.1 子类的构造函数 224

17.3.2 子类的析构函数 226

17.3.3 子类的类型适应 227

17.4 多继承 228

17.4.1 海纳百川—多继承的概念 228

17.4.2 多继承的构造函数 229

17.4.3 多继承的问题 231

17.5 虚基类 234

17.5.1 虚基类的声明 234

17.5.2 虚基类的构造函数 235

17.6 小结 236

17.7 小测试 237

第18章 虚函数与多态 239

18.1 多态的概念与实现 239

18.1.1 多态的概念 239

18.1.2 多态的C++实现 239

18.2 多态性中的“静”与“动” 240

18.2.1 静态联编 240

18.2.2 动态联编 241

18.3 什么是虚函数 241

18.3.1 虚函数 241

18.3.2 虚析构函数 245

18.4 抽象类与纯虚函数 247

18.4.1 虚函数中的特例—纯虚函数 247

18.4.2 抽象类 249

18.5 小结 251

18.6 小测试 251

第19章 C++的单链表 255

19.1 链表的概念与创建 55

19.1.1 链表的概念 255

19.1.2 链表的创建 256

19.2 结点的操作 257

19.2.1 结点的增加 257

19.2.2 结点的删除 257

19.3 链表的操作 258

19.3.1 链表结点的遍历 258

19.3.2 链表结点的查找 259

19.3.3 链表的清除 259

19.4 单链表的应用 259

19.5 小结 261

第20章 C++向量容器的使用 262

20.1 向量容器的概念及创建 262

20.1.1 向量容器的概念 262

20.1.2 向量容器的创建 262

20.2 对向量容器的操作 263

20.2.1 向量元素的增加 263

20.2.2 向量元素的访问 263

20.2.3 向量元素的删除 264

20.3 向量容器的应用 265

20.4 小结 266

第21章 Visual C++的程序调试 267

21.1 启动调试模式 267

21.2 使用监视窗口 269

21.3 使用变量查看窗口 269

21.4 单步执行 270

21.5 小结 270

附录 Visual C++菜单中文注释 271

查看更多关于C++轻松入门的内容