零基础学C语言（第三版） 下载 pdf 百度网盘 epub 免费 2025 电子书 mobi 在线

本书主要内容包括数据的存储和获取、屏幕的输入与输出、运算符、表达式、分支语句、循环语句、函数、数组、指针、字符串处理、结构体、共用体、枚举、位运算、文件处理、作用域、预处理、数据结构等知识点。最后一章通过一些常见的 C 语言面试题的解析，为读者踏入职场提供参考资料。

前言

第一篇 C 语言基础

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

1.1 为什么选择 C 语言

1.2 如何学好 C 语言

1.3 语言概述

1.3.1 什么是语言

1.3.2 什么是机器语言

1.3.3 什么是汇编语言

1.3.4 面向过程的语言

1.3.5 什么是 C 语言

1.4 程序的开发周期

1.4.1 编辑 C 源代码

1.4.2 编译 C 源代码

1.4.3 连接目标文件

1.4.4 编译连接过程示例

1.4.5 运行程序

1.5 VC++、C++、C 和 TC 的区别

1.6 小结

1.7 习题

第 2 章 跟我写 Hello World

2.1 了解需求才能创建程序

2.2 认识 LCC-Win32 开发环境

2.2.1 为什么选择 LCC-Win32

2.2.2 启动 LCC-Win32

2.2.3 新建 Hello World 工程

2.2.4 定义新工程

2.2.5 添加源代码到工程

2.2.6 编译器设置

2.2.7 连接器设置

2.2.8 调试器设置

2.2.9 开始编辑代码

2.3 编译运行

2.4 调试排错（debug）

2.4.1 debug 的由来

2.4.2 设置断点

2.4.3 调试运行

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

2.5.1 包含命令 include

2.5.2 关键字 main

2.5.3 表示代码行结束的分号

2.6 小结

2.7 习题

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

3.1 C 程序的构成

3.2 C 程序的注释

3.3 C 程序必须有的 main 函数

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

3.5 #include 预处理器指示符

3.5.1 函数声明及其作用

3.5.2 试验寻找 #include 的作用

3.5.3 #include 的作用

3.6 计算 1+1 的程序实例

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

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

3.7.2 编译器使用变量符号表

3.7.3 变量及其使用

3.8 自己设计 C 函数

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

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

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

3.8.4 如何自编写函数

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

3.9 语句构成程序

3.10 优秀程序员的代码风格

3.11 小结

3.12 习题

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

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

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

4.1.2 表示数据的字节和位

4.1.3 内存是存储数据的房间

4.2 数据类型

4.2.1 整数类型

4.2.2 整数的有符号和无符号

4.2.3 实数类型

4.2.4 字符类型

4.2.5 数据类型总结

4.3 常量

4.3.1 直接常量和符号常量

4.3.2 符号常量的优点

4.3.3 直接常量的书写格式

4.3.4 转义字符

4.3.5 字符串

4.4 变量

4.4.1 变量的声明

4.4.2 变量声明的意义

4.4.3 标识符和关键字

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

4.4.5 为变量赋初值

4.4.6 变量使用时常见的错误

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

4.5.1 累加和累乘

4.5.2 交换两个变量的值

4.6 小结

4.7 习题

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

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

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

5.2.1 printf() 函数的一般形式

5.2.2 printf() 函数的输出原理

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

5.2.4 输出带符号的整数 %d

5.2.5 设置最小宽度的输出

5.2.6 长整型输出 %ld

5.2.7 输出八进制形式

5.2.8 输出十六进制的形式

5.2.9 输出十进制的 unsigned 型数据

5.2.10 输出字符

5.2.11 输出字符串 %s

5.2.12 输出实型数据 %f

5.2.13 输出指数形式的实数

5.2.14 自动选择 %f 或者 %e 形式输出 %g

5.2.15 printf() 函数的几点说明

5.3 字符输出 putchar() 和字符串输出 puts()

5.3.1 字符输出函数

5.3.2 字符串输出函数

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

5.4.1 scanf() 函数的一般形式

5.4.2 scanf() 函数的输入原理

5.4.3 多数据输入分隔规则

5.4.4 控制输入的格式字符

5.4.5 scanf() 函数的使用说明

5.4.6 使用 scanf() 函数的注意事项

5.5 字符输入函数 getchar()

5.6 输入和输出程序举例

5.7 小结

5.8 习题

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

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

6.1.1 运算符和表达式

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

6.1.3 C 运算符简介

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

6.2.1 基本的算术运算符

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

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

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

6.3.1 逗号表达式的一般形式

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

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

6.4.1 关系运算符的种类

6.4.2 关系表达式的一般形式

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

6.5.1 逻辑运算符

6.5.2 逻辑真值表

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

6.6.1 赋值表达式

6.6.2 复合运算符

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

6.7.1 强制类型转换

6.7.2 自动类型转换

6.8 运算符的优先级

6.8.1 优先级、结合性汇总

6.8.2 sizeof 运算

6.9 取地址运算符

6.10 小结

6.11 习题

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

7.1 5 种语句类型

7.1.1 表达式语句

7.1.2 函数调用语句

7.1.3 空语句

7.1.4 复合语句（块语句）

7.1.5 流程控制语句

7.2 结构化程序设计

7.2.1 什么是算法

7.2.2 算法的表示

7.2.3 算法的伪代码表示

7.2.4 算法的流程图表示

7.2.5 3 种控制结构

7.2.6 算法示例

7.3 小结

7.4 习题

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

8.1 if 语句

8.1.1 判断表达式

8.1.2 花括号和 if 结构体

8.2 if...else 结构

8.2.1 关键在 else

8.2.2 if...else 结构体

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

8.3.1 多分支

8.3.2 多分支 if 结构

8.3.3 分支语句嵌套

8.4 switch 结构

8.4.1 一般形式

8.4.2 为什么叫开关语句

8.4.3 default 语句

8.4.4 if 结构和 switch 结构之比较

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

8.5 小结

8.6 习题

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

9.1 构造循环

9.1.1 循环的条件

9.1.2 当型循环和直到型循环

9.2 while 和 do...while 循环结构

9.2.1 语法规则

9.2.2 代码块

9.2.3 while 语句的常见错误

9.2.4 do...while 语句的常见错误

9.3 for 循环结构

9.3.1 基本形式

9.3.2 表达式省略

9.3.3 循环终止和步长

9.3.4 for 语句的常见错误

9.4 循环嵌套

9.4.1 嵌套示例

9.4.2 嵌套的效率

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

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

9.5.1 用 break 跳出循环

9.5.2 用 continue 重来一次

9.5.3 用 goto 实现跳转

9.6 小结

9.7 习题

第二篇 一窥 C 语言门庭

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

10.1 什么是数组

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

10.1.2 数组元素的访问

10.2 一维数组

10.2.1 一维数组的声明

10.2.2 一维数组元素的访问

10.2.3 一维数组的初始化

10.2.4 不合法的数组操作

10.3 二维数组

10.3.1 二维数组的声明

10.3.2 二维数组的初始化

10.3.3 二维数组应用举例

10.4 更高维的数组

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

10.4.2 初始化

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

10.5 小结

10.6 习题

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

11.1 什么是函数

11.1.1 函数的由来

11.1.2 C 语言中的函数

11.2 自定义函数

11.2.1 定义的语法

11.2.2 函数定义范例

11.2.3 不要重复定义

11.3 函数调用与返回

11.3.1 形参和实参

11.3.2 传址调用

11.3.3 函数返回

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

11.4.1 函数声明的语法

11.4.2 声明不同于定义

11.4.3 标准库函数的声明

11.5 函数的调用过程

11.6 小结

11.7 习题

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

12.1 计算机中的内存

12.1.1 内存地址

12.1.2 内存中保存的内容

12.1.3 地址就是指针

12.2 指针的定义

12.2.1 指针变量的声明

12.2.2 指针变量的初始化

12.2.3 指针变量的值

12.2.4 取地址操作符 &

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

12.2.6 指向指针的指针

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

12.3 使用指针

12.3.1 运算符 *

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

12.3.3 同类型指针的赋值

12.3.4 void 指针

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

12.4 指针的运算

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

12.4.2 指针 - 指针

12.4.3 指针的大小比较

12.5 指针表达式与左值

12.5.1 指针与整型

12.5.2 指针与左值

12.5.3 指针与 const

12.6 动态内存分配

12.6.1 动态分配的好处

12.6.2 malloc 与 free 函数

12.6.3 calloc 与 free

12.6.4 free 函数与指针

12.6.5 内存泄漏

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

12.7 小结

12.8 习题

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

13.1 C 风格字符串

13.1.1 C 风格字符串的声明

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

13.2 字符数组的输入输出

13.2.1 字符数组的声明

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

13.2.3 使用 gets() 函数读取整行

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

13.2.5 使用 puts() 函数实现字符串的输出

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

13.3 字符串处理函数

13.3.1 理解：数组名是常指针

13.3.2 strlen() 函数与 size_t

13.3.3 字符串复制函数 strcpy()

13.3.4 字符串比较函数 strcmp()

13.3.5 字符串连接函数 strcat()

13.3.6 全转换为大写形式

13.3.7 链式操作

13.4 小结

13.5 习题

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

14.1 结构体

14.1.1 结构体的定义

14.1.2 声明结构体变量

14.1.3 初始化结构变量

14.1.4 访问结构体成员

14.1.5 结构体定义的位置

14.1.6 结构体变量赋值

14.2 特殊结构体

14.2.1 结构体嵌套

14.2.2 匿名结构体

14.3 共用体

14.3.1 什么是共用体

14.3.2 共用体的定义

14.3.3 声明共用体变量

14.3.4 共用体变量的初始化

14.3.5 共用体成员访问

14.3.6 共用体赋值

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

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

14.4.2 结构体变量的内存大小

14.4.3 字节对齐

14.4.4 最宽基本类型

14.4.5 共用体的大小

14.5 枚举类型

14.5.1 什么是枚举类型

14.5.2 枚举类型的定义

14.5.3 声明枚举变量

14.5.4 枚举常量是什么

14.5.5 使用枚举时常见的错误

14.6 给类型取个别名——typedef

14.6.1 typedef 基本用法

14.6.2 #define 用法

14.7 小结

14.8 习题

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

15.1 什么是位运算

15.1.1 开灯关灯

15.1.2 改变状态

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

15.2 位逻辑运算符

15.2.1 位取反操作

15.2.2 位与运算

15.2.3 位或运算

15.2.4 位异或

15.2.5 实例分析

15.3 移位运算

15.3.1 基本形式

15.3.2 移位举例

15.3.3 移位和乘以 2

15.4 小结

15.5 习题

第三篇 C 语言进阶主题

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

16.1 什么是文件

16.1.1 文件

16.1.2 流

16.1.3 重定向

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

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

16.2 C 语言如何使用文件

16.2.1 文件型指针

16.2.2 文件操作的步骤

16.3 文件的打开与关闭

16.3.1 用于打开文件的 fopen() 函数

16.3.2 打开是否成功

16.3.3 用于关闭文件的 fclose() 函数

16.4 文件的读写

16.4.1 读写的相对参照

16.4.2 如何判断文件已经结束

16.4.3 字符读写函数 fgetc() 和 fputc()

16.4.4 字符串读写函数 fgets() 和 fputs()

16.4.5 块读写函数 fread() 和 fwrite()

16.4.6 格式化文件输入输出 fprintf() 与 fscanf()

16.5 文件的定位

16.5.1 移动指针到文件开头 rewind()

16.5.2 移动指针到当前位置 ftell()

16.5.3 移动指针 fseek()

16.6 小结

16.7 习题

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

17.1 指针与数组

17.1.1 数组名指针

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

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

17.1.4 指向数组的指针变量

17.1.5 指针数组

17.1.6 指针与数组的常见问题

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

17.2.1 两种访问形式

17.2.2 声明创建一个结构数组

17.2.3 结构数组的初始化

17.2.4 结构数组的使用

17.2.5 指向结构数组的指针

17.3 函数指针

17.3.1 函数名指针

17.3.2 指向函数的指针

17.3.3 函数指针类型

17.3.4 函数指针作函数参数

17.3.5 函数指针数组

17.3.6 指向函数指针的指针

17.4 小结

17.5 习题

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

18.1 参数传递的副本机制

18.1.1 传值调用的副本

18.1.2 传址调用的副本机制

18.2 函数返回值的副本机制

18.2.1 return 局部变量为什么合法

18.2.2 返回指针申请动态内存

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

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

18.3 函数与结构体

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

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

18.3.3 返回结构体的函数

18.3.4 返回结构体指针的函数

18.4 函数与数组

18.4.1 数组元素作为函数参数

18.4.2 数组名作为函数参数

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

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

18.5 递归

18.5.1 递归流程

18.5.2 递归两要素

18.5.3 效率 VS 可读性

18.6 带参数的主函数

18.7 小结

18.8 习题

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

19.1 内存分配

19.1.1 内存分区

19.1.2 变量的存储类别

19.1.3 生存期

19.1.4 作用域与可见域

19.2 auto 变量

19.2.1 定义格式

19.2.2 作用域和生存期

19.2.3 auto 变量的屏蔽准则

19.2.4 重复定义

19.2.5 auto 变量的初始化和特点

19.3 register 变量

19.3.1 定义格式

19.3.2 使用举例

19.4 extern 变量

19.4.1 全局变量定义

19.4.2 全局变量声明

19.4.3 可见域

19.4.4 全局变量的屏蔽准则

19.4.5 全局变量的利与弊

19.5 static 变量

19.5.1 定义格式

19.5.2 静态局部变量

19.5.3 静态全局变量

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

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

19.6 函数的作用域与可见域

19.6.1 内部函数

19.6.2 外部函数

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

19.7.1 定义位置与可见域

19.7.2 允许重复定义

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

19.9 小结

19.10 习题

第 20 章 编译及预处理

20.1 编译流程

20.1.1 编辑

20.1.2 预处理

20.1.3 编译

20.1.4 连接

20.2 程序错误

20.2.1 错误分类

20.2.2 编译错误

20.2.3 连接错误

20.2.4 逻辑错误

20.2.5 排错

20.3 预处理命令之宏定义

20.3.1 宏定义

20.3.2 不带参数的宏定义

20.3.3 带参数的宏定义

20.3.4 #define 定义常量与 const 常量

20.3.5 文件包含

20.3.6 条件编译

20.3.7 宏函数

20.4 小结

20.5 习题

第 21 章 数据结构

21.1 链表

21.1.1 链表的结构

21.1.2 创建链表并遍历输出

21.1.3 链表的插入

21.1.4 链表结点的删除

21.1.5 链表的逆置

21.1.6 链表的销毁

21.1.7 链表的综合实例

21.1.8 循环链表

21.1.9 双链表

21.2 栈和队列

21.2.1 栈的定义

21.2.2 栈的分类

21.2.3 栈的操作

21.2.4 函数与栈

21.2.5 队列

21.3 自定义类型

21.4 小结

21.5 习题

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

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

22.1 黑白棋

22.1.1 程序功能要求

22.1.2 输入输出样例

22.1.3 程序分析

22.1.4 程序初始化

22.1.5 初始化图形设备

22.1.6 绘制棋盘

22.1.7 交替绘制黑白棋

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

22.1.9 小结

22.2 五子棋

22.2.1 程序功能要求

22.2.2 输入输出样例

22.2.3 程序分析

22.2.4 主函数程序设计

22.2.5 系统初始化

22.2.6 移动棋子模块

22.2.7 程序胜负判定

22.2.8 小结

22.3 扫雷游戏

22.3.1 程序功能要求

22.3.2 输入输出样例

22.3.3 程序分析

22.3.4 程序设计

22.3.5 初始化图形设备

22.3.6 事件处理模块

22.3.7 游戏处理部分

22.3.8 小结

22.4 速算 24

22.4.1 程序功能要求

22.4.2 输入输出样例

22.4.3 程序分析

22.4.4 程序设计

22.4.5 扑克牌处理部分

22.4.6 程序运算部分

22.4.7 小结

第 23 章 面试题解析

23.1 基础知识

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

23.1.2 什么是递归

23.1.3 宏定义与操作符的区别

23.1.4 引用与值传递的区别

23.1.5 指针和引用有什么区别

23.1.6 什么是栈

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

23.1.8 static 有什么用途

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

23.1.10 什么是预编译

23.1.11 int (*s[10])(int) 表示什么意义

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

23.2 算法和思维逻辑知识

23.2.1 100 美元哪里去了

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

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

23.2.4 找出不同的苹果

23.2.5 找出不同的球

23.2.6 猜自己的帽子颜色

23.2.7 3 筐水果各是什么

23.2.8 最后剩下的是谁

23.2.9 聪明的商人

23.2.10 红球和白球

23.2.11 乌龟赛跑

23.2.12 投硬币

附录 ASCII 编码表

暂无相关内容，正在全力查找中

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：零基础学C语言（第三版）在线阅读

在线听书地址：零基础学C语言（第三版）在线收听

在线购买地址：零基础学C语言（第三版）在线购买

全球著名的开源组织网站：

www.sourceforge.net

专业的源代码编辑器，著名编辑工具有VI/VIM、Emacs/XEmacs等。

<代码开始 lang="c">

#include <stdio.h>

void main(void)

{

printf("nHello World!");

getchar();

}

</代码结束>

注释：

/*包含该头文件的目的是使用了函数printf()*/

/*空行，主要是为了分割，编译器忽略*/

/*主函数，入口点*/

/*函数开始*/

/*打印字符串*/

/*等待用户按回车键*/

/*函数结束*/

代码虽小，五脏俱全。

纵观代码，可以总结出如下特点：

（1）代码由单词、符号、空白组成。单词以英语单词为主，有的单词就是纯正的英语单词，如main、void、include；有的不是，如getchar、printf。单词一般都用小写。代码中的标点符号并不是随意输入的，每个符号在C中都有特定的含义。单词与单词之间用空白分隔，空白可以是空格，也可是tab制表符。空白的个数没有限制。

（2）C源代码从上往下阅读，也就是源代码的先后顺序是有讲究的。行与行之间可以有空白行，空白的行数是没有限制的。有的行顶格写，有的行却又后退了几格。这种，后退，称为“缩进”。如何缩进也是有讲究的。

（3）并没有专门的标志表示文件从哪里起始，也没有标志表示文件到哪里结束。从第一个字符开始，文件就开始了，到最后一个字符结束，文件就结束了。

C程序的注释

注释是用来帮助程序员阅读源代码和理解源代码的。编译器在编译源代码的时候，在目标代码生成以前，会把注释剔除掉，然后再进行编译。当然编译器是不会修改源文件的，这一切是在内存中完成的（？）。由于对于注释部分忽略不处理，就如同没有这些字符一样，所以注释不会增加编译后的程序的可执行代码长度，对程序运行不起任何作用。

对于注释，有以下几点说明：

（1）C语言的注释只有一种形式，就是以“/*"开始，以”/*"结束的注释对。

/*这段注释有...

void main(void){...}这一段是定义C程序的主函数。函数是可以完成一定功能的子程序。main函数是C语言程序的起始执行点，每一个C程序必须有且仅有一个main函数，它是由程序员提供的。

思考：操作系统是如何开始运行、调用一个程序的?这个问题的意思是：操作系统怎么知道一个程序的入口点在哪里?所谓入口点，就是程序的第一条指令。操作系统调入程序二进制代码到内存后，从哪条指令开始运行程序呢？

一种办法是从文件第一行开始，一行一行往下执行，直到文件结束。很多语言就是采用这种方式，比如QBASIC语言。这种方法的好处显而易见，人类是怎么阅读的，计算机就是怎么执行的。但是缺点也很多，当有两个源文件的时候，从哪个文件开始呢？

另一种办法是和运行程序的启动者协商一个规定的入口名称，从这个名称开始进入。这种方法就是C语言采用的方法。

main函数就是C程序的入口点。无论整个工程有多少个C源文件，必须编写且只能编写一个main函数。程序就是从main的第一条语句开始执行，然后在main函数中顺序执行其他语句，在这些语句中，调用其他函数，从而使整个程序运行起来。main函数结束了，整个程序也就结束了。写C程序，就是写main函数。

简单地说明一下定义函数的语法。

对于C语言，定义函数的语法规则如下：

返回值类型 函数名称（参数1，参数2...)

{

函数体

}

对比上面的语法规则可言看出，在void main(void)这一行中，第一个void是指main函数的返回值数据类型，void表示main函数仅仅完成某些功能，不向调用者返回数值。main是函数名称。函数可以是C语言系统提供的系统函数，也可以是用户自己编写的函数。用户自己编写的函数，函数名字可以自行决定。main后面是小括号对“（）”，括号里是传递给函数的参数。类似初、高中学习的代数里的函数y=f（x）一样，x就是参...

main函数体中的语句如下：

printf("nHello World!");

这行是调用了C语言提供的按格式输出函数，该函数的名称是printf，小括号内双引号括起来的文字是printf函数的参数。该函数的功能是把小括号里的文字原样打印在屏幕上。也就是说双引号里的内容变化，则打印在屏幕中的文字也会变化。

说明：

"n"在这里有特殊的含义，读者可以发现"n"并没有在屏幕中打印出来。"n"中的""是转义字符，表示其后面紧跟的字符有专门的意思。“n"表示将光标移到第二行第一格，也就是回车换行的意思。

printf函数调用语句最后用分号结束。

函数定义和函数调用有如下的不同之处：

（1）简单地说，所谓函数定义就是程序员编写程序代码，去实现函数的功能。请读者注意，定义好的函数不一定会被调用。比如C语言提供的大批库函数都已经实现，但是程序员编写程序时并不会用到库函数中的每一个函数，只是从中挑选有用的库函数来使用。

（2）函数调用就是调用已经编写好的函数。这些已经编写好的函数可以是程序员自己编写的，叫作自定义函数；有的是C语言系统提供的函数，叫作库函数；有的是第三方提供的函数，叫作第三方函数。C语言系统向程序员提供了非常丰富的库函数，以方便程序员使用。

相比其他高级语言而言，C语言本身语句很少。很多功能是通过函数完成的，因此熟悉库函数的功能是程序员非常重要的工作了。比如开发网络程序，熟悉网络套接字接口函数就非常重要，否则不能开发网络程序；开发Windows窗口界面程序，就得熟悉Windows提供的编程接口(API），否则就不能开发Windows程序。

本例中，printf函数被主函数main调用。printf函数的定义读者是看不见的，当然也看不见printf函数的代码，也就不清楚printf函数是如何实现的。

不知道读者是否还记得程序生成过程，其中有一步连接的...

源代码最终是需要被编译器处理的。编译器编译的过程比较复杂，但一般需要经历好几步，第一步是预处理。

所谓预处理，就是在编译前先进行一些预先处理，如代替源代码中需要代替的部分。

#include就是这么一个预处理指示指令。

1.函数声明及其作用

简单解释一下函数原型(prototype)概念。上节提到过函数定义，函数定义由4部分组成：返回类型、函数名、参数表、函数体。 前面三部分合起来称为函数原型。如下：

返回类型 函数名（参数表）

函数在被调用之前，一定要让编译器知道函数原型，这样编译器才知道有哪些函数名，该函数需要什么样类型的参数，返回什么样类型的值。

告诉编译器函数原型的动作称为函数声明。如下：

返回类型 函数名（参数表）；

NOTES：函数声明是一条语句，要用分号表示结束。

函数声明和函数定义中的返回值类型、参数表、函数名都要一致。虽然C语言提供了很多库函数，但是对于编译器来说还是不确定库函数的位置。所以即使使用的是C语言系统的库函数，也必须向编译器声明。

因为在本实验中print_format函数并没有向变压器你声明过其函数原型，编译器就提出抗议——一条warning（警告）。这条警告只是提醒程序员而已，如果程序员忘记了向编译器声明函数原型，编译器会自己生成一个默认的函数声明。然而代码中实际上调用了一个根本不存在也就是没有定义的函数，编译器自然要罢工了——一条错误提示。

（在LCC的安装目录下，有一个include文件夹。在Windows的文件浏览器中定位到LCC的安装文件夹中，可以发现include文件夹中可以搜索到stdio.h文件。

看见：

int getchar(void); int printf(const char*,...);

他们就是这两个函数的声明。

本节来解释#include这行代码的作用。

#include是C语言预处理器指示符。#和include可以有多个空格。#也不一定要顶格，但也一定是第一个非空白字符。#include的作用是告诉编译器，在编译前要做些预处理：将后面<>中的文件内容包含到当前文件夹内。所谓包含，是指将<>中列出的文件的内容复制到当前文件夹里。

NOTES:#一定要是第一个非空白字符，否则编译器会提示错误，并且错误信息和出错原因完全不匹配。

因为getchar和printf两个函数的声明位于stdio.h文件中，所以用include把stdio.h文件包含进来，自然就把getchar和printf两个函数的声明包含进来了。

notes：函数声明知识向编译器登记有这么一个函数，声明了函数而不调用这个函数是被容许的。这就是为什么包含了整个stdio.h文件（里面声明了很多其他函数），但实际没有使用这些函数而编译器又不提示的原因。

std：标准standard缩写。

io：Input/Output缩写。

联合起来：标准输入输出，一般就是与屏幕输出和键盘输入相关的内容。

“.h"是C语言头文件的扩展名。所谓头文件，就是该文件都是些函数的声明、变量的声明等内容。

”.c"文件是C语言实现文件，是真正做事情的文件。

书籍介绍

本书主要内容包括数据的存储和获取、屏幕的输入与输出、运算符、表达式、分支语句、循环语句、函数、数组、指针、字符串处理、结构体、共用体、枚举、位运算、文件处理、作用域、预处理、数据结构等知识点。最后一章通过一些常见的 C 语言面试题的解析，为读者踏入职场提供参考资料。