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

第一篇C语言基础 1

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

1.1 为什么选择C语言 1

1.2 如何学好C语言 3

1.3 语言概述 3

1.3.1 什么是语言 3

1.3.2 什么是机器语言 3

1.3.3 什么是汇编语言 4

1.3.4 面向过程的语言 5

1.3.5 什么是C语言 5

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 习题 12

第2章 跟我写Hello World 13

2.1 了解需求才能创建程序 13

2.2 认识LCC-Win32开发环境 13

2.2.1 为什么选择LCC-Win32 14

2.2.2 启动LCC-Win32 14

2.2.3 新建Hello World工程 14

2.2.4 定义新工程 15

2.2.5 添加源代码到工程 16

2.2.6 编译器设置 16

2.2.7 连接器设置 16

2.2.8 调试器设置 17

2.2.9 开始编辑代码 17

2.3 编译运行 18

2.4 调试排错（debug） 19

2.4.1 debug的由来 19

2.4.2 设置断点 20

2.4.3 调试运行 20

2.5 第一个程序容易出现的错误 21

2.5.1 包含命令include 21

2.5.2 关键字main 21

2.5.3 表示代码行结束的分号 22

2.6 小结 22

2.7 习题 22

第3章 分解Hello World——最简单C程序的组成 24

3.1 C程序的构成 24

3.2 C程序的注释 25

3.3 C程序必须有的main函数 26

3.4 调用函数在屏幕上显示文字 27

3.5 #include预处理器指示符 28

3.5.1 函数声明及其作用 28

3.5.2 试验寻找#include的作用 29

3.5.3 #include的作用 30

3.6 计算1+1的程序实例 31

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

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

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

3.7.3 变量及其使用 33

3.8 自己设计C函数 35

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

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

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

3.8.4 如何自编写函数 37

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

3.9 语句构成程序 39

3.10 优秀程序员的代码风格 40

3.11 小结 40

3.12 习题 41

第4章 常量、变量及数据类型 42

4.1 计算机是如何表示数据的 42

4.1.1 二进制、八进制、十六进制 42

4.1.2 表示数据的字节和位 44

4.1.3 内存是存储数据的房间 45

4.2 数据类型 46

4.2.1 整数类型 46

4.2.2 整数的有符号和无符号 48

4.2.3 实数类型 50

4.2.4 字符类型 50

4.2.5 数据类型总结 51

4.3 常量 51

4.3.1 直接常量和符号常量 52

4.3.2 符号常量的优点 53

4.3.3 直接常量的书写格式 54

4.3.4 转义字符 55

4.3.5 字符串 57

4.4 变量 58

4.4.1 变量的声明 58

4.4.2 变量声明的意义 59

4.4.3 标识符和关键字 60

4.4.4 变量在内存中占据的空间和变量的值 62

4.4.5为变量赋初值 65

4.4.6 变量使用时常见的错误 66

4.5 几个与变量相关的经典算法 67

4.5.1 累加和累乘 67

4.5.2 交换两个变量的值 68

4.6 小结 70

4.7 习题 70

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

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

5.2 向屏幕输出——printf（）函数详解 72

5.2.1 printf（）函数的一般形式 72

5.2.2 printf（）函数的输出原理 73

5.2.3 格式控制字符串的一般形式 74

5.2.4 输出带符号的整数1584664 75

5.2.5 设置最小宽度的输出 75

5.2.6 长整型输出1584664 76

5.2.7 输出八进制形式 76

5.2.8 输出十六进制的形式 77

5.2.9 输出十进制的unsigned型数据 77

5.2.10 输出字符 78

5.2.11 输出字符串? 79

5.2.12 输出实型数据0.000000 81

5.2.13 输出指数形式的实数 82

5.2.14 自动选择0.000000或者4.247839e-86形式输出-5.05812e+100 83

5.2.15 printf（）函数的几点说明 83

5.3 字符输出putchar（）和字符串输出puts（） 84

5.3.1 字符输出函数 84

5.3.2 字符串输出函数 85

5.4 接收键盘输入——scanf（）函数详解 86

5.4.1 scanf（）函数的一般形式 86

5.4.2 scanf（）函数的输入原理 87

5.4.3 多数据输入分隔规则 89

5.4.4 控制输入的格式字符 90

5.4.5 scanf（）函数的使用说明 91

5.4.6 使用scanf（）函数的注意事项 93

5.5 字符输入函数getchar（） 95

5.6 输入和输出程序举例 96

5.7 小结 98

5.8 习题 99

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

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

6.1.1 运算符和表达式 100

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

6.1.3 C运算符简介 102

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

6.2.1 基本的算术运算符 103

6.2.2 ++++自增、--自减运算符 104

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

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

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

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

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

6.4.1 关系运算符的种类 109

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

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

6.5.1 逻辑运算符 111

6.5.2 逻辑真值表 111

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

6.6.1 赋值表达式 112

6.6.2 复合运算符 113

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

6.7.1 强制类型转换 113

6.7.2 自动类型转换 115

6.8 运算符的优先级 116

6.8.1 优先级、结合性汇总 116

6.8.2 sizeof运算 117

6.9 取地址运算符 117

6.10 小结 118

6.11 习题 118

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

7.1 5种语句类型 120

7.1.1 表达式语句 120

7.1.2 函数调用语句 122

7.1.3 空语句 122

7.1.4 复合语句（块语句） 122

7.1.5 流程控制语句 123

7.2 结构化程序设计 123

7.2.1 什么是算法 123

7.2.2 算法的表示 123

7.2.3 算法的伪代码表示 124

7.2.4 算法的流程图表示 124

7.2.5 3种控制结构 124

7.2.6 算法示例 125

7.3 小结 125

7.4 习题 126

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

8.1 if语句 127

8.1.1 判断表达式 127

8.1.2 花括号和if结构体 128

8.2 if…else结构 129

8.2.1 关键在else 129

8.2.2 if…else结构体 130

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

8.3.1 多分支 131

8.3.2 多分支if结构 133

8.3.3 分支语句嵌套 134

8.4 switch结构 135

8.4.1 一般形式 135

8.4.2 为什么叫开关语句 137

8.4.3 default语句 138

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

8.4.5 switch结构的常见错误与解决方法 139

8.5 小结 140

8.6 习题 141

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

9.1 构造循环 142

9.1.1 循环的条件 142

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

9.2 while和do…while循环结构 143

9.2.1 语法规则 144

9.2.2 代码块 145

9.2.3 while语句的常见错误 145

9.2.4 do…while语句的常见错误 146

9.3 for循环结构 147

9.3.1 基本形式 147

9.3.2 表达式省略 149

9.3.3 循环终止和步长 150

9.3.4 for语句的常见错误 150

9.4 循环嵌套 151

9.4.1 嵌套示例 151

9.4.2 嵌套的效率 152

9.4.3 循环嵌套程序的常见错误 153

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

9.5.1 用break跳出循环 154

9.5.2 用continue重来一次 155

9.5.3 用goto实现跳转 156

9.6 小结 157

9.7 习题 157

第二篇 一窥C语言门庭 159

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

10.1 什么是数组 159

10.1.1 数组是一大片连续内存空间 159

10.1.2 数组元素的访问 160

10.2 一维数组 160

10.2.1 一维数组的声明 160

10.2.2 一维数组元素的访问 161

10.2.3 一维数组的初始化 162

10.2.4 不合法的数组操作 163

10.3 二维数组 164

10.3.1 二维数组的声明 164

10.3.2 二维数组的初始化 164

10.3.3 二维数组应用举例 165

10.4 更高维的数组 166

10.4.1 高维数组的声明和元素访问 166

10.4.2 初始化 166

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

10.5 小结 168

10.6 习题 168

第11章 写程序就是写函数——函数入门 170

11.1 什么是函数 170

11.1.1 函数的由来 170

11.1.2 C语言中的函数 170

11.2 自定义函数 171

11.2.1 定义的语法 171

11.2.2 函数定义范例 172

11.2.3 不要重复定义 173

11.3 函数调用与返回 173

11.3.1 形参和实参 174

11.3.2 传址调用 175

11.3.3 函数返回 176

11.4 告诉编译器有这么一个函数 177

11.4.1 函数声明的语法 177

11.4.2 声明不同于定义 179

11.4.3 标准库函数的声明 180

11.5 函数的调用过程 180

11.6 小结 180

11.7 习题 180

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

12.1 计算机中的内存 182

12.1.1 内存地址 182

12.1.2 内存中保存的内容 183

12.1.3 地址就是指针 183

12.2 指针的定义 183

12.2.1 指针变量的声明 183

12.2.2 指针变量的初始化 184

12.2.3 指针变量的值 185

12.2.4 取地址操作符＆ 185

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

12.2.6 指向指针的指针 186

12.2.7 指针变量常见的错误分析与解决 186

12.3 使用指针 187

12.3.1 运算符 188

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

12.3.3 同类型指针的赋值 189

12.3.4 void指针 190

12.3.5 指针的类型和指针所指向的类型不同 190

12.4 指针的运算 192

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

12.4.2 指针-指针 193

12.4.3 指针的大小比较 194

12.5 指针表达式与左值 194

12.5.1 指针与整型 194

12.5.2 指针与左值 195

12.5.3 指针与const 195

12.6 动态内存分配 196

12.6.1 动态分配的好处 196

12.6.2 malloc与free函数 197

12.6.3 calloc与free 198

12.6.4 free函数与指针 199

12.6.5 内存泄漏 199

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

12.7 小结 200

12.8 习题 200

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

13.1 C风格字符串 202

13.1.1 C风格字符串的声明 202

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

13.2 字符数组的输入输出 203

13.2.1 字符数组的声明 203

13.2.2 字符数组可以进行整体输入输出 204

13.2.3 使用gets（）函数读取整行 205

13.2.4 访问字符数组中某个元素 205

13.2.5 使用puts（）函数实现字符串的输出 206

13.2.6 使用字符数组的常见问题 206

13.3 字符串处理函数 207

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

13.3.2 strlen（）函数与size _t 210

13.3.3 字符串复制函数strcpy（） 211

13.3.4 字符串比较函数 strcmp（） 212

13.3.5 字符串连接函数strcat（） 213

13.3.6 全转换为大写形式 213

13.3.7 链式操作 214

13.4 小结 214

13.5 习题 215

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

14.1 结构体 216

14.1.1 结构体的定义 216

14.1.2 声明结构体变量 217

14.1.3 初始化结构变量 218

14.1.4 访问结构体成员 218

14.1.5 结构体定义的位置 219

14.1.6 结构体变量赋值 219

14.2 特殊结构体 220

14.2.1 结构体嵌套 220

14.2.2 匿名结构体 223

14.3 共用体 224

14.3.1 什么是共用体 224

14.3.2 共用体的定义 224

14.3.3 声明共用体变量 225

14.3.4 共用体变量的初始化 225

14.3.5 共用体成员访问 225

14.3.6 共用体赋值 226

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

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

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

14.4.3 字节对齐 228

14.4.4 最宽基本类型 228

14.4.5 共用体的大小 229

14.5 枚举类型 230

14.5.1 什么是枚举类型 230

14.5.2 枚举类型的定义 230

14.5.3 声明枚举变量 231

14.5.4 枚举常量是什么 231

14.5.5 使用枚举时常见的错误 232

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

14.6.1 typedef基本用法 233

14.6.2 #define用法 233

14.7 小结 234

14.8 习题 234

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

15.1 什么是位运算 235

15.1.1 开灯关灯 235

15.1.2 改变状态 235

15.1.3 计算机中的数据存储形式 236

15.2 位逻辑运算符 237

15.2.1 位取反操作 237

15.2.2 位与运算 237

15.2.3 位或运算 237

15.2.4 位异或 238

15.2.5 实例分析 238

15.3 移位运算 239

15.3.1 基本形式 239

15.3.2 移位举例 239

15.3.3 移位和乘以2 241

15.4 小结 241

15.5 习题 241

第三篇C语言进阶主题 243

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

16.1 什么是文件 243

16.1.1 文件 243

16.1.2 流 244

16.1.3 重定向 244

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

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

16.2 C语言如何使用文件 245

16.2.1 文件型指针 245

16.2.2 文件操作的步骤 246

16.3 文件的打开与关闭 246

16.3.1 用于打开文件的fopen（）函数 247

16.3.2 打开是否成功 248

16.3.3 用于关闭文件的fclose（）函数 249

16.4 文件的读写 249

16.4.1 读写的相对参照 249

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

16.4.3 字符读写函数fgetc（）和fputc（） 250

16.4.4 字符串读写函数fgets（）和fputs（） 251

16.4.5 块读写函数fread（）和fwrite（） 253

16.4.6 格式化文件输入输出fprintf（）与fscanf（） 256

16.5 文件的定位 258

16.5.1 移动指针到文件开头rewind（） 258

16.5.2 移动指针到当前位置ftell（） 258

16.5.3 移动指针fseek（） 258

16.6 小结 260

16.7 习题 260

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

17.1 指针与数组 262

17.1.1 数组名指针 262

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

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

17.1.4 指向数组的指针变量 264

17.1.5 指针数组 265

17.1.6 指针与数组的常见问题 266

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

17.2.1 两种访问形式 266

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

17.2.3 结构数组的初始化 267

17.2.4 结构数组的使用 268

17.2.5 指向结构数组的指针 268

17.3 函数指针 269

17.3.1 函数名指针 269

17.3.2 指向函数的指针 270

17.3.3 函数指针类型 272

17.3.4 函数指针作函数参数 273

17.3.5 函数指针数组 274

17.3.6 指向函数指针的指针 275

17.4 小结 275

17.5 习题 276

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

18.1 参数传递的副本机制 277

18.1.1 传值调用的副本 277

18.1.2 传址调用的副本机制 278

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

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

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

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

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

18.3 函数与结构体 283

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

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

18.3.3 返回结构体的函数 285

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

18.4 函数与数组 286

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

18.4.2 数组名作为函数参数 287

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

18.4.4 数组名作函数参数时的退化 290

18.5 递归 290

18.5.1 递归流程 290

18.5.2 递归两要素 292

18.5.3 效率VS可读性 293

18.6 带参数的主函数 294

18.7 小结 294

18.8 习题 295

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

19.1 内存分配 297

19.1.1 内存分区 297

19.1.2 变量的存储类别 298

19.1.3 生存期 299

19.1.4 作用域与可见域 299

19.2 auto变量 299

19.2.1 定义格式 300

19.2.2 作用域和生存期 300

19.2.3 auto变量的屏蔽准则 301

19.2.4 重复定义 302

19.2.5 auto变量的初始化和特点 302

19.3 register变量 303

19.3.1 定义格式 303

19.3.2 使用举例 303

19.4 extem变量 304

19.4.1 全局变量定义 304

19.4.2 全局变量声明 305

19.4.3 可见域 306

19.4.4 全局变量的屏蔽准则 307

19.4.5 全局变量的利与弊 309

19.5 static变量 309

19.5.1 定义格式 309

19.5.2 静态局部变量 310

19.5.3 静态全局变量 311

19.5.4 静态局部变量和静态全局变量的区别 312

19.5.5 extern变量和static变量的初始化 312

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

19.6.1 内部函数 313

19.6.2 外部函数 314

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

19.7.1 定义位置与可见域 314

19.7.2 允许重复定义 315

19.8 常见的有关变量存储的错误 316

19.9 小结 318

19.10 习题 318

第20章 编译及预处理 320

20.1 编译流程 320

20.1.1 编辑 321

20.1.2 预处理 321

20.1.3 编译 321

20.1.4 连接 322

20.2 程序错误 322

20.2.1 错误分类 323

20.2.2 编译错误 323

20.2.3 连接错误 323

20.2.4 逻辑错误 323

20.2.5 排错 324

20.3 预处理命令之宏定义 324

20.3.1 宏定义 324

20.3.2 不带参数的宏定义 324

20.3.3 带参数的宏定义 326

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

20.3.5 文件包含 329

20.3.6 条件编译 330

20.3.7 宏函数 331

20.4 小结 332

20.5 习题 333

第21章 数据结构 334

21.1 链表 334

21.1.1 链表的结构 334

21.1.2 创建链表并遍历输出 335

21.1.3 链表的插入 338

21.1.4 链表结点的删除 341

21.1.5 链表的逆置 342

21.1.6 链表的销毁 344

21.1.7 链表的综合实例 344

21.1.8 循环链表 349

21.1.9 双链表 349

21.2 栈和队列 352

21.2.1 栈的定义 353

21.2.2 栈的分类 353

21.2.3 栈的操作 353

21.2.4 函数与栈 356

21.2.5 队列 356

21.3 自定义类型 359

21.4 小结 361

21.5 习题 361

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

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

22.1 黑白棋 363

22.1.1 程序功能要求 363

22.1.2 输入输出样例 363

22.1.3 程序分析 364

22.1.4 程序初始化 364

22.1.5 初始化图形设备 365

22.1.6 绘制棋盘 365

22.1.7 交替绘制黑白棋 366

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

22.1.9 小结 380

22.2 五子棋 380

22.2.1 程序功能要求 380

22.2.2 输入输出样例 380

22.2.3 程序分析 381

22.2.4 主函数程序设计 382

22.2.5 系统初始化 383

22.2.6 移动棋子模块 383

22.2.7 程序胜负判定 387

22.2.8 小结 390

22.3 扫雷游戏 391

22.3.1 程序功能要求 391

22.3.2 输入输出样例 391

22.3.3 程序分析 392

22.3.4 程序设计 393

22.3.5 初始化图形设备 395

22.3.6 事件处理模块 398

22.3.7 游戏处理部分 402

22.3.8 小结 405

22.4 速算24 405

22.4.1 程序功能要求 406

22.4.2 输入输出样例 406

22.4.3 程序分析 406

22.4.4 程序设计 407

22.4.5 扑克牌处理部分 409

22.4.6 程序运算部分 411

22.4.7 小结 413

第23章 面试题解析 414

23.1 基础知识 414

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

23.1.2 什么是递归 414

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

23.1.4 引用与值传递的区别 415

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

23.1.6 什么是栈 415

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

23.1.8 static有什么用途 415

23.1.9 定义int **a［3］［4］，则变量占用的内存空间为多少 416

23.1.10 什么是预编译 416

23.1.11 int （*s［101）（int）表示什么意义 416

23.1.12 结构体与共同体有何区别 416

23.2 算法和思维逻辑知识 417

23.2.1 100美元哪里去了 417

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

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

23.2.4 找出不同的苹果 418

23.2.5 找出不同的球 419

23.2.6 猜自己的帽子颜色 419

23.2.7 3筐水果各是什么 420

23.2.8 最后剩下的是谁 421

23.2.9 聪明的商人 422

23.2.10 红球和白球 422

23.2.11 乌龟赛跑 422

23.2.12 投硬币 423

附录ASCII编码表 424