零基础学C语言 第2版PDF电子书下载

第一篇C语言基础 1

第1章 踏上征程前的思想动员 1

1.1为什么选择C语言 1

1.2如何学好C语言 2

1.3语言概述 3

1.3.1什么是语言 3

1.3.2什么是机器语言 3

1.3.3什么是汇编语言 4

1.3.4面向过程的语言 4

1.3.5什么是C语言 4

1.4深刻认识程序如何开发出来——程序开发周期 5

1.4.1编辑C源代码 6

1.4.2编译C源代码 6

1.4.3连接目标文件 7

1.4.4编译连接过程示例 7

1.4.5运行程序 9

1.5 VC++、C++、C和TC——认识开发环境和语言的区别 9

1.6小结 11

1.7上机实践 11

第2章 跟我写Hello World 12

2.1自己动手创建程序 12

2.2认识LCC-Win32开发环境 12

2.2.1为什么选择LCC-Win32 13

2.2.2启动LCC-Win32 13

2.2.3新建Hello World工程 13

2.2.4定义新工程 13

2.2.5添加源代码到工程 14

2.2.6编译器设置 15

2.2.7连接器设置 15

2.2.8调试器设置 15

2.2.9开始编辑代码 16

2.3编译运行——欣赏你的杰作 17

2.4查看代码如何一步一步被执行——调试排错（debug） 18

2.4.1 debug一词的由来 18

2.4.2设置断点 19

2.4.3调试运行 19

2.5小结 20

2.6上机实践 20

第3章 分解HelloWorld——最简单C程序的组成 22

3.1 C程序概貌 22

3.2为何有必要在代码里留下程序员的解释——注释 23

3.3从哪里开始，到哪里结束——main函数 24

3.4如何在屏幕上显示文字——函数调用 25

3.5编译器如何认识printf 函数——#include预处理器指示符 26

3.5.1函数声明及其作用 26

3.5.2试验寻找#include的作用 27

3.5.3 #include的作用 28

3.6计算1+1——有些小作为的程序 29

3.7数据从哪里来，又到哪里去——变量 30

3.7.1变量在内存中的表现形式 30

3.7.2编译器使用变量符号表 30

3.7.3变量及其使用 31

3.8自己设计C函数 32

3.8.1在main函数中计算3个整数的平均数 33

3.8.2在main函数中分3次计算3个整数的平均数 33

3.8.3自编函数实现计算3个整数的平均数 34

3.8.4如何自编写函数 35

3.8.5试验观察总结函数声明和函数定义的意义 36

3.9语句构成程序 37

3.10向好程序员看齐——代码风格 38

3.11小结 38

3.12上机实践 38

第4章 如何存储和获取数据——变量及数据类型 40

4.1二进制、八进制、十六进制 40

4.2计算机中如何表示数据——字节和位 41

4.3内存是存储数据的“房间”——认识计算机内存 43

4.4数据类型 43

4.4.1整数类型 44

4.4.2整数的正负——有符号和无符号 46

4.4.3实数类型 47

4.4.4字符类型 48

4.4.5数据类型总结 48

4.5常量 49

4.5.1直接常量（字面常量）和符号常量 49

4.5.2符号常量的优点 51

4.5.3字面常量的书写格式 52

4.5.4转义字符 53

4.5.5字符串 55

4.6变量 55

4.6.1变量的声明 56

4.6.2变量声明的意义 56

4.6.3标识符和关键字 57

4.6.4变量在内存中占据的空间和变量的值 60

4.6.5变量赋初值 62

4.7几个与变量相关的经典算法 63

4.7.1累加和累乘 63

4.7.2交换两个变量的值 65

4.8小结 66

4.9上机实践 66

第5章 用屏幕和键盘交互——简单的输出和输入 68

5.1输入—处理—输出：这就是程序 68

5.2向屏幕输出——printf函数详解 68

5.2.1 printf函数的一般形式 69

5.2.2格式字符串的一般形式 71

5.2.3 %d——十进制形式输出带符号整数 71

5.2.4%最小宽度d格式符 72

5.2.5 %ld格式符——以长整型方式输出 73

5.2.6%o格式符——以八进制形式输出整数 73

5.2.7 %x格式符——以十六进制的形式输出整数 74

5.2.8 %u格式符——以十进制形式输出unsigned型数据 74

5.2.9 %c格式符 75

5.2.10 %s格式符——输出字符串 76

5.2.11 %f格式符——输出实型数据 78

5.2.12 %e格式符——以指数形式输出实数 79

5.2.13 %g格式符——自动选择%f或者%e形式输出 80

5.2.14 printf函数小结 80

5.3字符输出putchar和字符串输出puts 81

5.3.1 putchar函数（字符输出函数） 81

5.3.2 puts函数（字符串输出函数） 83

5.4接收键盘输入——scanf函数详解 84

5.4.1一般形式 84

5.4.2 scanf函数的工作原理 85

5.4.3多数据输入分隔规则 86

5.4.4格式字符 88

5.4.5 scanf使用方法说明 89

5.4.6使用scanf函数的注意事项 91

5.5字符输入函数getchar 93

5.6输入输出程序举例 94

5.7小结 97

5.8上机实践 97

第6章 程序的基本构成——运算符和表达式 98

6.1认识C中的运算符和表达式 98

6.1.1认识运算符和表达式 98

6.1.2操作数、运算符和表达式 99

6.1.3 C运算符简介 99

6.2算术运算符和算术表达式 100

6.2.1基本的算术运算符 100

6.2.2++自增、——自减运算符 102

6.2.3算术表达式和运算符的优先级及结合性 104

6.3逗号运算符和逗号表达式 105

6.3.1逗号表达式的一般形式 105

6.3.2逗号表达式的优先级和结合性 106

6.4关系运算符和关系表达式 107

6.4.1关系运算符的种类 107

6.4.2关系表达式的一般形式 107

6.5逻辑运算符和逻辑表达式 109

6.5.1逻辑运算符 109

6.5.2逻辑真值表 109

6.6赋值运算符和赋值表达式 110

6.6.1赋值表达式 110

6.6.2复合赋值运算符 111

6.6.3类型转换 111

6.6.4左值与程序实体 112

6.7强制类型转换和自动类型转换 112

6.7.1强制类型转换 112

6.7.2自动类型转换 113

6.7.3函数调用时的转换 115

6.8运算符的优先级 115

6.8.1优先级、结合性汇总 115

6.8.2短路表达式 116

6.8.3 sizeof运算符与sizeof表达式 116

6.9小结 116

6.10上机实践 117

第7章 程序的最小独立单元——语句 118

7.1 5种语句类型 118

7.1.1表达式语句 118

7.1.2函数调用语句 119

7.1.3空语句 119

7.1.4复合语句（块语句） 119

7.1.5流程控制语句 120

7.2结构化程序设计 120

7.2.1什么是算法 120

7.2.2算法的表示 120

7.2.3算法的伪代码表示 121

7.2.4算法的流程图表示 121

7.2.5 3种控制结构 121

7.2.6算法示例 122

7.3小结 122

7.4上机实践 122

第8章 条件判断——分支结构 123

8.1简单的条件判断——if 语句 123

8.1.1判断表达式 123

8.1.2花括号和if结构体 124

8.2两条岔路的选择——if else结构 125

8.2.1关键在else 125

8.2.2 if else结构体 126

8.3多分支语句和分支语句嵌套 127

8.3.1多分支 127

8.3.2多分支if结构 128

8.3.3分支语句嵌套 130

8.4开关语句——switch结构 131

8.4.1一般形式 131

8.4.2为什么叫开关语句 133

8.4.3 default语句 135

8.4.4 if结构和switch结构之比较 135

8.5小结 135

8.6上机实践 135

第9章 一遍又一遍——循环结构 137

9.1构造循环 137

9.1.1循环的条件 137

9.1.2当型循环和直到型循环 138

9.2简洁循环语句——while和do while结构 138

9.2.1语法规则 139

9.2.2代码块 140

9.3最常用的循环语句——for结构 140

9.3.1基本形式 140

9.3.2表达式省略 142

9.3.3循环终止和步长 143

9.4循环嵌套 143

9.4.1嵌套示例 144

9.4.2嵌套的效率 144

9.5与循环密切相关的流程转向控制语句 145

9.5.1跳出循环——break 145

9.5.2重来一次——continue 146

9.5.3随心所欲—— goto 147

9.6小结 148

9.7上机实践 148

第二篇 一窥C语言门庭 149

第10章 写程序就是写函数——函数入门 149

10.1什么是函数——根据输入进行处理返回输出 149

10.1.1分割 149

10.1.2库函数和自定义函数 150

10.2自定义函数 150

10.2.1定义的语法 150

10.2.2函数定义范例 151

10.2.3不要重复定义 152

10.3函数调用与返回 152

10.3.1形参和实参 152

10.3.2传址调用 154

10.3.3函数返回 155

10.4告诉编译器有这么一个函数——函数原型声明 156

10.4.1函数声明的语法 156

10.4.2声明不同于定义 158

10.4.3标准库函数的声明 158

10.5面向过程的程序结构 158

10.5.1模块化 159

10.5.2函数的调用过程——模块的配合 159

10.5.3一个入口一个出口 159

10.5.4自顶向下，逐步求精 159

10.5.5封装和可重用 160

10.5.6高内聚，低耦合 160

10.6小结 160

10.7上机实践 161

第11章 同一类型多个元素的集合——简单数组 162

11.1什么是数组 162

11.1.1数组是一大片连续内存空间 162

11.1.2数组元素的访问 163

11.2一维数组 163

11.2.1一维数组的声明 163

11.2.2一维数组元素的访问 164

11.2.3数组的初始化 164

11.2.4不合法的数组操作 165

11.3二维数组 166

11.3.1二维数组的声明 166

11.3.2二维数组的初始化 167

11.3.3二维数组应用举例 167

11.4更高维的数组 168

11.4.1高维数组的声明和元素访问 169

11.4.2初始化 169

11.4.3多维数组在内存中是如何排列元素的 170

11.5小结 170

11.6上机实践 171

第12章C语言难点——指针初探 172

12.1计算机中的内存 172

12.1.1内存地址 172

12.1.2内存中保存的内容 173

12.1.3地址就是指针 173

12.2指针的定义 173

12.2.1指针变量的声明 174

12.2.2指针变量的初始化 174

12.2.3指针变量的值 174

12.2.4取地址操作符 175

12.2.5指针变量占据一定的内存空间 175

12.2.6指向指针的指针 176

12.3使用指针 176

12.3.1运算符 176

12.3.2指针的类型和指针所指向的类型 177

12.3.3同类型指针的赋值 178

12.3.4指针的类型和指针所指向的类型不同 178

12.4指针的运算 180

12.4.1算术运算之“指针+整数”或“指针-整数” 180

12.4.2指针-指针 181

12.4.3指针的大小比较 182

12.5指针表达式与左值 183

12.5.1指针与整型 183

12.5.2指针与左值 183

12.5.3指针与const 183

12.6动态内存分配 185

12.6.1动态分配的好处 185

12.6.2 malloc与free函数 185

12.6.3 calloc与free函数 187

12.6.4 free函数与指针 187

12.6.5内存泄漏 188

12.6.6释放已经释放了的内存会出问题 188

12.7小结 189

12.8上机实践 189

第13章 字符串及字符串操作 190

13.1 C风格字符串 190

13.1.1 C风格字符串的声明 190

13.1.2 C风格字符串在内存中的表示 190

13.2字符数组的输入输出 191

13.2.1字符数组可以进行整体输入输出 191

13.2.2使用gets函数读入整行输入 192

13.2.3访问字符数组中某个元素 193

13.2.4更便捷的输出——使用puts函数 193

13.3字符串处理函数 194

13.3.1理解：数组名是常指针 194

13.3.2 strlen函数与size_t 196

13.3.3字符串复制函数strcpy 197

13.3.4字符串比较函数strcmp 198

13.3.5字符串连接函数strcat 199

13.3.6全转换为大写形式 200

13.3.7链式操作 201

13.4小结 201

13.5上机实践 201

第14章 结构体、共用体、枚举和typedef 203

14.1结构体 203

14.1.1结构体的定义 203

14.1.2声明结构体变量 204

14.1.3初始化结构变量 204

14.1.4访问结构体成员 205

14.1.5结构体定义的位置 205

14.1.6结构体变量赋值 206

14.2特殊结构体 207

14.2.1结构体嵌套 207

14.2.2匿名结构体 210

14.3共用体 210

14.3.1什么是共用体 210

14.3.2共用体的定义 210

14.3.3声明共用体变量 211

14.3.4共用体变量的初始化 211

14.3.5共用体成员访问 211

14.3.6共用体赋值 213

14.4结构体和共用体的内存差异 213

14.4.1结构体变量和共用体变量内存形式的不同 213

14.4.2结构体变量的内存大小 213

14.4.3字节对齐 214

14.4.4最宽基本类型 215

14.4.5共用体的大小 216

14.5枚举类型 216

14.5.1枚举类型的定义 216

14.5.2声明枚举变量 217

14.5.3枚举常量是什么 217

14.6给类型取个别名——typedef 218

14.6.1 typedef基本用法 218

14.6.2 #define用法 218

14.7小结 219

14.8上机实践 219

第15章 如何节省内存——位运算 220

15.1什么是位运算 220

15.1.1开灯关灯 220

15.1.2改变状态 220

15.2位逻辑运算符 221

15.2.1位取反操作 221

15.2.2位与运算 221

15.2.3位或运算 221

15.2.4位异或 221

15.2.5实例分析 222

15.3移位运算 223

15.3.1基本形式 223

15.3.2移位举例 223

15.4小结 224

15.5上机实践 224

第三篇C语言进阶 227

第16章 存储不仅仅局限于内存——文件 227

16.1什么是文件 227

16.1.1文件 227

16.1.2流 228

16.1.3重定向 228

16.1.4文件的处理形式——缓冲区和非缓冲区 228

16.1.5文件的存储形式——文本形式和二进制形式 229

16.2 C语言如何使用文件 229

16.2.1文件型指针 229

16.2.2文件操作的步骤 230

16.3文件的打开与关闭 230

16.3.1打开文件——fopen 230

16.3.2打开是否成功 231

16.3.3关闭文件——fclose 232

16.4文件的读写 232

16.4.1读写的相对参照 232

16.4.2如何判断文件已经结束 232

16.4.3字符读写函数——fgetc和fputc 233

16.4.4字符串读写函数——fgets和fputs 234

16.4.5块读写函数——fread和fwrite 236

16.4.6格式化文件输入输出——fprintf 与fscanf 239

16.5文件的定位 241

16.5.1移到开头——rewind 241

16.5.2得到当前位置——ftell 242

16.5.3移动指针——fseek 242

16.6小结 243

16.7上机实践 243

第17章 灵活却难以理解——指针进阶 245

17.1指针与数组 245

17.1.1数组名指针 245

17.1.2使用数组名常指针表示数组元素 246

17.1.3指向数组元素的指针变量 246

17.1.4指向数组的指针变量 247

17.1.5指针数组 248

17.2指针、结构体和结构体数组 249

17.2.1两种访问形式 249

17.2.2声明创建一个结构数组 249

17.2.3结构数组的初始化 250

17.2.4结构数组的使用 251

17.2.5指向结构数组的指针 251

17.3函数指针 2

17.3.1函数名指针 252

17.3.2指向函数的指针 253

17.3.3函数指针类型 254

17.3.4函数指针做函数参数 256

17.3.5函数指针数组 256

17.3.6指向函数指针的指针 258

17.4小结 258

17.5上机实践 258

第18章 更深入的理解——函数进阶 260

18.1参数传递的副本机制 260

18.1.1传值调用的副本机制 260

18.1.2传址调用的副本机制 261

18.2函数返回值的副本机制 264

18.2.1 return局部变量为什么合法 264

18.2.2返回指针申请动态内存 265

18.2.3不要返回指向栈内存的指针 266

18.2.4返回指向只读存储区的指针 266

18.3函数与结构体 267

18.3.1结构体变量的传值和传址调用 267

18.3.2结构体变量的成员作为函数参数 268

18.3.3返回结构体的函数 269

18.3.4返回结构体指针的函数 270

18.4函数与数组 270

18.4.1数组元素作为函数参数 270

18.4.2数组名作为函数参数 271

18.4.3多维数组名作为函数参数 273

18.4.4数组名作为函数参数时的退化 274

18.5递归 274

18.5.1递归流程 274

18.5.2递归两要素 276

18.5.3效率与可读性 276

18.6带参数的主函数 276

18.7小结 277

18.8上机实践 277

第19章 生存期、作用域与可见域 279

19.1内存分配 279

19.1.1内存分区 279

19.1.2变量的存储类别 280

19.1.3生存期 280

19.1.4作用域与可见域 280

19.2 auto变量 281

19.2.1定义格式 281

19.2.2作用域和生存期 282

19.2.3屏蔽 282

19.2.4重复定义 283

19.2.5初始化 284

19.3 register变量 284

19.3.1定义格式 284

19.3.2使用举例 285

19.4 extern变量 286

19.4.1全局变量定义 286

19.4.2全局变量声明 286

19.4.3可见域 287

19.4.4屏蔽 289

19.4.5利与弊 290

19.5 static变量 291

19.5.1定义格式 291

19.5.2静态局部变量 291

19.5.3静态全局变量 292

19.5.4 extern变量和static变量的初始化 293

19.6函数的作用域与可见域 294

19.6.1内部函数 294

19.6.2外部函数 295

19.7结构体定义的作用域与可见域 295

19.7.1定义位置与可见域 295

19.7.2允许重复定义 296

19.8小结 297

19.9上机实践 297

第20章 编译及预处理 299

20.1编译流程 299

20.1.1编辑 299

20.1.2预处理 300

20.1.3编译 300

20.1.4连接 300

20.2程序错误 301

20.2.1错误分类 301

20.2.2编译错误 301

20.2.3连接错误 301

20.2.4逻辑错误 302

20.2.5排错 302

20.3预处理命令之宏定义 302

20.3.1宏定义 302

20.3.2不带参数的宏定义 303

20.3.3带参数的宏定义 304

20.3.4 #define定义常量与 const常量 307

20.3.5文件包含 307

20.3.6条件编译 308

20.4小结 310

20.5上机实践 3

第21章 数据结构 311

21.1链表 311

21.1.1链表的结构 311

21.1.2创建链表并遍历输出 312

21.1.3链表的插入 314

21.1.4链表结点的删除 317

21.1.5链表的逆置 319

21.1.6链表的销毁 321

21.1.7综合实例 321

21.1.8循环链表 326

21.1.9双链表 327

21.2栈和队列 330

21.2.1栈的定义 330

21.2.2栈的分类 330

21.2.3栈的操作 331

21.2.4函数与栈 333

21.2.5队列 334

21.3小结 337

21.4上机实践 337

第四篇C语言程序设计实例与面试题解析 339

第22章C语言程序课程设计：游戏 339

22.1黑白棋 339

22.1.1程序功能要求 339

22.1.2输入输出样例 339

22.1.3程序分析 340

22.1.4程序初始化 341

22.1.5初始化图形设备 341

22.1.6绘制棋盘 341

22.1.7交替绘制黑白棋 342

22.1.8游戏（同时判断是否有一方胜利） 342

22.1.9小结 357

22.2五子棋 357

22.2.1程序功能要求 357

22.2.2输入输出样例 358

22.2.3程序分析 358

22.2.4主函数程序设计 360

22.2.5系统初始化 361

22.2.6移动棋子模块 361

22.2.7程序胜负判定 365

22.2.8小结 369

22.3扫雷游戏 369

22.3.1程序功能要求 369

22.3.2输入输出样例 370

22.3.3程序分析 370

22.3.4程序设计 372

22.3.5初始化图形设备 374

22.3.6事件处理模块 377

22.3.7游戏处理部分 382

22.3.8小结 385

22.4速算24 385

22.4.1程序功能要求 385

22.4.2输入输出样例 385

22.4.3程序分析 386

22.4.4程序设计 387

22.4.5扑克牌处理部分 389

22.4.6程序运算部分 392

22.4.7小结 393

第23章面试题解析 394

23.1基础知识 394

23.1.1指针自增自减有什么不同 394

23.1.2什么是递归 394

23.1.3宏定义与操作符的区别 395

23.1.4引用与值传递的区别 395

23.1.5指针和引用有什么区别 395

23.1.6什么是栈 395

23.1.7 main函数执行前还会执行什么代码 395

23.1.8 static有什么用途 395

23.1.9定义int **a[3][4]，则变量占用的内存空间为多少 396

23.1.10什么是预编译 396

23.1.11 int （*s[10]）（int）表示什么意义 396

23.1.12结构与联合有何区别 396

23.2算法和思维逻辑知识 396

23.2.1 100美元哪里去了 397

23.2.2将16升水平均分给四个人 397

23.2.3算出小王买了几瓶啤酒、几瓶饮料 397

23.2.4找出不同的苹果 398

23.2.5找出不同的球 398

23.2.6猜自己的帽子颜色 399

23.2.7三筐水果各是什么 400

23.2.8最后剩下的是谁 401

23.2.9聪明的商人 402

23.2.10红球和白球 402

23.2.11乌龟赛跑 402

23.2.12投硬币 402

附录ASCII编码表 403