C++轻松入门【2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载】

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 World29

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 当型循环while65

6.3.2 当型循环的兄弟do-while66

6.3.3 循环语句for67

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 多样的选择—switch70

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 退出-break75

6.6.2 跳过-continue76

6.7 控制语句综合示例77

6.7.1 四则运算深入学习while和switch78

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 特殊的值—NULL133

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