C语言入门学习教程

个人整理面向入门基础级别的C语言学习教程。

关键词：C语言

Ⅰ —— 基础知识介绍

此教程会用一些注记符号，表示某种格式。

1.1 C语言背景知识

C语言是一种通用的、面向过程式的计算机程序设计语言。1972 年，为了移植与开发 UNIX 操作系统，丹尼斯·里奇在贝尔电话实验室设计开发了 C 语言。

C语言标准有C89、C99、C11、C17、C2x ……等，后面的数字是标准发布的年份。如果想了解每个标准有什么差异，自行必应搜索。本教程的完整代码在GNU C17下成功运行。

1.2 用什么写C语言

编写C语言，就连基本的文本编辑器——记事本也可以完成。但我们并不会只想着使用那么奇奇怪怪的记事本，去编写十来行代码甚至上千行代码，至少是真的不习惯。

接触C语言，会有很多人推荐你用那个什么什么写啊，一点一动就行；但如果在大学学习，教师可能会让你使用Visual C++ 6.0（下简称VC 6.0）去写。

感受过VC 6.0软件界面的人都知道，很不舒服，甚至降低自己的效率。VC 6.0甚至比我的年龄还大，算是老古董了。但是目前教材用的是VC 6.0，实验室配置的是VC 6.0，乃至你的考试，甚至计算机二级，都是VC 6.0，所以用VC 6.0而不是别的软件，更加容易应付教学。

所以在此，我推荐使用的C语言编辑器是：

• 基础小白或图方便可使用Dev-C++

• 非基础小白可使用Visual Studio或Visual Studio Code

此教程的代码使用Dev-C++，均在Dev-C++下成功运行。

按 Ctrl + N 可以新建文件，或者点击左上角文件新建文件。

在 工具 → 编译选项 → 代码生成/优化 → 代码生成 处可以找到语言标准。

1.3 从代码到执行程序

在上一节我提到了用什么写C语言，这是关于编辑器（Editor）的事情。字面意思，它只负责编辑，也就是敲上一个个的字母数字，就像写英语日记、写英语文章一样。

事实上，你在编辑器上写的内容，还不能完全算是程序，这个内容称为 源代码（Source Code） 。存放源代码的文件称为 源文件 。

我们还需要经过一些步骤，使得源代码变成 可执行文件（Executable file） ，也就是你计算机里面那些.exe文件。把这些步骤称之为 编译（Build） 和 链接（Link） 。

• 编译：编译需要 编译器 完成。编译器把一个源代码翻译成可执行文件的工作过程分为五个阶段：词法分析；语法分析；语义检查和中间代码生成；代码优化；目标代码生成。主要是进行词法分析和语法分析，又称为源程序分析，分析过程中发现有语法错误，给出提示信息。常见的编译器有：MinGW、MSVC等。

• 链接：链接需要 链接器 完成。链接是将各种代码和数据片段收集并组合成为一个单一文件的过程，这个文件可被加载（复制）到内存并执行。链接可以执行于编译时，也就是在源代码被翻译成机器代码时；也可以执行于加载时，也就是在程序被加载器加载到内存并执行时；甚至执行于运行时，也就是由应用程序来执行。链接的意义在于我们不用将一个大型的应用程序组织成一个巨大的源文件，而是可以把它分解成为更小、更好管理的模块，可以独立的修改和编译这些模块。当我们改变这些模块中的一个时，只需要简单的重新编译它，并重新链接应用，而不必重新编译其他文件。

这些只是一些知识补充，想详细了解可参阅编译原理。另外，如果你选择了Dev-C++或者Visual Studio这样的集成软件，编译器和链接器的配置会相对简单。

1.4 认识最基础的C语言代码

学习C语言的开始，从输出一个“Hello World！”开始，这似乎是所有编程语言一开始都经历的事情。

我在此直接给出完整代码，心急的可以复制到Dev-C++运行试试。

1
2
3
4
5
6
7
8

// Hello World.c 
#include <stdio.h>

int main()
{
	printf("Hello World!");
	return 0;
}

现在来逐行认识基本的C语言代码结构。

• // 表示当前整行被编译器忽略，又称注释，供程序员理解语句。

• #include<stdio.h>中的 #（井号）表示预处理命令，即在程序编译前进行提前处理的部分。若是头文件，可用 <>（单书名号）括起来，也可用 " "（引号）包含起来。 其中由 <> 括起来的头文件表示在系统头文件的文件夹中查找，由 "" 括起来的头文件表示在源文件当前文件夹查找。

• int main() 是一个函数的开头，再加以 {}（大括号）包含主函数内容。此处是主函数，主函数是一个程序最重要的函数，程序从此开始编译。

• printf("Hello World!"); 为程序工作语句，其作用是输出“Hello World！”。

• C语言中以 ;（分号）作为一条语句的结束标志。

• return 0;是函数的结构之一，在函数一节介绍。

一般情况下， 一个C语言程序包含预处理器指令、函数、变量、语句（表达式和注释）等 。函数是一个进行某种功能操作的模块，目前认识到的是主函数，还可以自定义函数。变量即程序运行时其值可以改变的量，变量的功能就是存储数据。

C语言代码按 顺序结构 ，由上到下顺序执行代码。

还有一件比较重要的事情，养成良好的代码风格，即令人舒适的缩进、空格位置等；千万不要所有代码都挤到一块或者全都左对齐。

1.5 头文件

在上一节提到了预处理命令包含的头文件，那么头文件是什么？

头文件是扩展名为.h的文件，包含了C语言一些函数甚至几乎所有函数的提前 声明（Statement） 和 定义（Definition） ，没有这些声明和定义，编译器不会认识这些函数，故而不能运行。

有两种类型的头文件：程序员编写的头文件和编译器自带的头文件。

在程序中要使用头文件，需要使用预处理指令 #include 来引用它，引用头文件相当于复制头文件的内容。如stdio.h头文件，它包含了printf()这一函数。

1.6 关键字

C语言的关键字是C语言的基本构成要素，共有32个，根据关键字的作用，可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。

1 数据类型关键字（12个）：
(1) char ：声明字符型变量或函数
(2) double ：声明双精度变量或函数
(3) enum ：声明枚举类型
(4) float ：声明浮点型变量或函数
(5) int ：声明整型变量或函数
(6) long ：声明长整型变量或函数
(7) short ：声明短整型变量或函数
(8) signed ：声明有符号类型变量或函数
(9) struct ：声明结构体变量或函数
(10) union ：声明共用体（联合）数据类型
(11) unsigned ：声明无符号类型变量或函数
(12) void ：声明函数无返回值或无参数，声明无类型指针

2 控制语句关键字（12个）：
A循环语句
(1) for ：一种循环语句(可意会不可言传）
(2) do ：循环语句的循环体
(3) while ：循环语句的循环条件
(4) break ：跳出当前循环
(5) continue ：结束当前循环，开始下一轮循环
B条件语句
(1) if : 条件语句
(2) else ：条件语句否定分支（与 if 连用）
(3) goto ：无条件跳转语句
C开关语句
(1) switch :用于开关语句
(2) case：开关语句分支
(3) default：开关语句中的“其他”分支
D返回语句
return ：函数返回语句（可以带参数，也可不带参数）

3 存储类型关键字（4个）
(1) auto ：声明自动变量 一般不使用
(2) extern ：声明变量是在其他文件正声明（也可以看做是引用变量）
(3) register：声明积存器变量
(4) static ：声明静态变量

4 其它关键字（4个）：
(1) const ：声明只读变量
(2) sizeof ：计算数据类型长度
(3) typedef ：用以给数据类型取别名
(4) volatile ：说明变量在程序执行中可被隐含地改变

你可能不明白这些关键字什么意思怎么用，但你只需要知道这些关键字不能随便用，它们被C语言内部定义占用了。

Ⅱ —— 函数

函数是用来完成特定任务的一组语句。在C语言中，每个程序至少有一个主函数 main() 。此外，C语言还提供了许多内置函数，可以在相应的头文件中找到。有时候，我们也可以称函数为方法。

当我们编写代码时，我们可以将其分割成不同的函数。划分代码到不同的函数中是我们自己决定的。但是从逻辑上来说，我们通常会根据每个函数执行特定的任务来进行划分。例如，如果我们正在编写一个计算器程序，我们可以使用四个函数分别处理加法、减法、乘法和除法。这样的划分可以让代码更有组织性，并且更易于理解和维护。

2.1 函数的基本结构

函数的结构应当如下，包括 函数返回类型return_type ， 函数名字function_name 、 参数arguments 和 函数主体Body 等。

1
2
3
4

return_type function_name(arguments)
{
	// body
}

• 函数返回类型：一个函数可以返回一个值，return_type是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void 。

• 函数名字：这是函数的实际名称。函数名和参数列表一起构成了 函数签名（Function signature） 。

• 参数列表：当函数被调用时，可以向参数传递值。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。

• 函数主体：函数主体包含一组定义函数执行任务的语句。若有返回值的函数使用 return 返回。函数主体中遇到返回表示结束函数。

2.2 函数声明和定义

函数的产生有两个概念： 函数声明（Function Statement） 和 函数定义（Function Definition） 。函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。 使用函数之前必须先声明（也可以直接声明并定义）。
开玩笑地说，声明就是你骗机器有这么一个函数，但是当机器要找这个函数用的时候，你最好是有个定义。

1
2
3
4
5
6
7
8

// 函数声明
int add(int a, int b);

// 函数定义
int add(int a, int b)
{
	return a + b;
}

1
2
3
4
5

// 函数声明并定义
int sub(int a, int b)
{
	return a - b;
}

C语言从上到下运行，如果是先写了 main 函数，再写 sub 函数，而在 main 函数调用了 sub 函数的情况下，需要有一个声明在 main 函数的前面，告知编译器有这个函数，否则按从上到下的顺序，此时并未出现 sub 函数；

如果是先写了 sub 函数，再写 main 函数，而在 main 函数调用了 sub 函数的情况下，在 main 函数之前的 sub 函数就相当于函数声明并定义，main 函数调用 sub 函数也自然成功。

函数声明中的参数列表可以不具体写变量名，但函数定义中的参数列表必须写变量名。如上述代码的声明可以写成：

1

int add(int, int);

2.3 调用函数

当我们写完我们的函数，使用时直接称呼 函数签名（函数名字+参数列表）即可。

1
2
3
4
5
6
7
8

// 声明并定义函数
int add(int a, int b)
{
	return a + b;
}

// 函数调用
add(c, d);

2.4 函数参数传递

如果函数要使用参数，接受参数值的变量称为函数的 形式参数 。如上面 int add(int a, int b) 中的 a 和 b。

如果调用函数时，传递进入的参数称为 实际参数。如上面 add(1, 2)中的 c 和 d 。

参数传递有两种方式： 值传递 和 地址传递 。

• 值传递：把参数的数值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。

• 地址（引用）传递：把参数的地址复制给函数的形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 对于地址传递，经过指针的学习可能更清晰。

Ⅲ —— 数据、运算符及语句

3.1 数据的表现形式

数据以常量、变量、常变量或标识符的形式出现。

变量、常变量的出现包括 声明 、 定义 、 初始化 三个步骤。 为变量分配地址和存储空间的称为定义，不分配地址的称为声明。

变量定义：用于为变量分配存储空间，还可为变量指定初始值，程序中，变量有且仅有一个定义。

变量声明：用于向程序表明变量的类型和名字。

定义也是声明：当定义变量时我们声明了它的类型和名字。

所有变量使用之前需要有声明或定义。

• 常量 ，其值不能改变的量。其分为 整型常量 （即整数，如1，2，1000，666）、 实型常量 、 字符常量 。

• 实型常量 ，包括十进制小数形式（由数字和小数点组成）和指数形式，指数形式以E或e代表以10为底的指数，如1e6，注意：e或E之前必须有数字，且e或E之后必须为整数；

• 字符常量之字符常量 ，由 ‘’ （单引号）包括的一个字符，如 ‘a’ 、 ‘A’ 等。普通字符，详见ASCII字符集；转义字符，特殊形式的字符，以 \ 开头。 引号在此充当界限符，字符常量和字符串常量不包括引号。

• 字符常量之字符串常量 ，由 “ ” （双引号）包括的一个字符串，可以超过一个字符，如 “boy” 。

• 字符常量之符号常量 ，用 #define 指令指定一个符号名称代表一个常量。

1

#define Pi 3.14 //符号常量，之后所有语句中所有Pi用3.14替换

#define宏定义与常变量const的区别是，#define宏定义的值为实型常量，且#define为预处理命令，不分配内存，但常变量具有使程序稳定性提高的优点，使用方便。

• 变量 ，在运行期间可以改变的量。变量必须先定义后使用。

1
2

int a;  //定义整型变量 a
a = 3;  //把3赋值给变量 a

• 常变量 ，在变量存在期间不可改变的量。也必须先定义后使用。用法是在定义变量前加上“const”。

1

const int a = 3;  //定义一个整数常变量 a，后续不可修改。 

• 标识符 ，简单来说就是一个对象的名字，遵守命名规则。

变量的命名规则：

1. 变量名的开头必须是字母或下划线，不能是数字。实际编程中最常用的是以字母开头，而以下划线开头的变量名是系统专用的。

2. 变量名中的字母是区分大小写的。比如 a 和 A 是不同的变量名，num 和 Num 也是不同的变量名。

3. 变量名绝对不可以是C语言关键字。

4. 变量名中不能有空格。这个可以这样理解：因为上面我们说过，变量名是字母、数字、下划线的组合，没有空格这一项。

3.2 数据的类型

3.2.1 整型数据

注意，各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主，下同。为了得到某个类型或某个变量在特定平台上的准确大小，您可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。

上述只讨论十进制，实际上C语言还可以表示八进制(int a = 010)和十六进制(int a = 0x10)。

特别指出，unsigned表示无符号数据，即非负数，但只有整型和字符型数据可以加unsigned修饰符。

由于ASCII码的存在， char 类型的数据范围恰好最小完整表达字符，所以 char 类型又称为字符类型。

3.2.2 浮点型数据

需要注意，计算机对于浮点数的存储并不完全精准。

若我们声明定义的变量超过数据类型的数据范围时，编译会警告我们，我们可在数据末尾加专用字符进行类型转换。如在 float 类型数据后加“f”，指定为 float 类型，如在实型变量后加“L”，指定为 long double 型。

1
2
3
4

float a = 3.14159;
//在某些系统中，会发出警告超出float类型，系统自动转化会影响精度
float a = 3.14159f;
//在数字后面加“f”，指定为float型，编译时不发出警告

3.2.3 Void类型

void 它通常用于以下三种情况下：

1. 函数返回为空：C中有各种函数都不返回值，或者可以说它们返回空。不返回值的函数的返回类型为空。
2. 函数参数为空：C中有各种函数不接受任何参数。不带参数的函数可以接受一个 void 。
3. 指针指向 void ：类型为 void * 的指针代表对象的地址，而不是类型。返回指向 void 的指针，可以转换为任何数据类型。

3.2.4 类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C 语言中有两种类型转换：

• 隐式类型转换：隐式类型转换是在表达式中自动发生的，无需进行任何明确的指令或函数调用。它通常是将一种较小的类型自动转换为较大的类型，例如，将int类型转换为long类型或float类型转换为double类型。隐式类型转换也可能会导致数据精度丢失或数据截断。

1
2
3

int i = 10;
float f = 3.14;
double d = i + f; // 隐式将int类型转换为double类型

• 显式类型转换：显式类型转换需要使用强制类型转换运算符（type casting operator），它可以将一个数据类型的值强制转换为另一种数据类型的值。强制类型转换可以使程序员在必要时对数据类型进行更精确的控制，但也可能会导致数据丢失或截断。

1
2

double d = 3.14159;
int i = (int)d; // 显式将double类型转换为int类型

3.3 运算符

3.3.1 算术运算符

% 运算符的操作数只可以是整数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// test.c
#include<stdio.h>
int main()
{
	int a, b, ans1;
	int c, d, ans2;
	ans1 = a + b; //两个整型变量相加的结果仍为整型。
	ans1 = a - b; //两个整型变量相减的结果仍为整型。
	ans1 = a * b; //两个整型变量相乘的结果仍为整型。
	ans1 = a / b; //两个整型变量相除的结果仍为整型，多数为除不尽向零取整。
	//如 5/3=1，-5/3=-1；
	ans2 = c % d; // 取余运算要求运算对象均为整数，即整型。
	return 0;
}

应当注意， ++i 和 i++ ， --i 和 i-- 是两回事。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// test2.c
//以下例子可能理解更加深刻
#include<stdio.h>
int main()
{
	int i,j;
  
	i = 1;
	i++;    //i使用后，使i的值加一,此时 i=1；
	j = i;    // j=i=2;
    
	i = 1;
	++i;    //i使用前，使i的值加一,此时 i=2；
	j = i;    // j=i=2;
    
	i = 1;
	i--;    //j使用后，使i的值减一，此时 i=1；
	j = i;    //j=i=0;
    
	i = 1;
	--i;    //j使用前，使i的值减一，此时 i=0；
	j = i;    //j=i=0;
	return 0; 
}

3.3.2 关系运算符

3.3.3 逻辑运算符

3.3.4 位运算符

位运算符是对数据转化为二进制，再逐位进行运算。如$60_{10} = 00111100_{2}$，再对每一位进行逻辑运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// bit.c
#include <stdio.h>
 
int main()
{
 
	unsigned int a = 60;    /* 60 = 0011 1100 */  
	unsigned int b = 13;    /* 13 = 0000 1101 */
	int c = 0;           
 
	c = a & b;       /* 12 = 0000 1100 */ 
	printf("c 的值是 %d\n", c ); // 一个输出的函数
 
	c = a | b;       /* 61 = 0011 1101 */
	printf("c 的值是 %d\n", c );
 
	c = a ^ b;       /* 49 = 0011 0001 */
	printf("c 的值是 %d\n", c );
 
	c = ~a;          /*-61 = 1100 0011 */
	printf("c 的值是 %d\n", c );
 
	c = a << 2;     /* 240 = 1111 0000 */
	printf("c 的值是 %d\n", c );
 
	c = a >> 2;     /* 15 = 0000 1111 */
	printf("c 的值是 %d\n", c );
	return 0;
}

3.3.5 赋值运算符

赋值运算符参与的表达式中，赋值表达式返回赋值符号右边的值。

3.3.6 其他运算符

• 条件运算符 （? : ） ：其形式为 (表达式1)? 表达式2 : 表达式3 ，先求解表达式1，若其值为真（非0）则将表达式2的值作为整个表达式的取值，否则（表达式1的值为0）将表达式3的值作为整个表达式的取值。

1
2
3
4
5
6
7
8
9

// test.c
#include<stdio.h>
int main()
{
	int i = 9, o = 6, q;
	i > o ? i : o;
	// i大于o吗，大于（真）则返回i的值，小于（假）则返回o的值。
	return 0;
}

• 逗号运算符 , ：其形式为 表达式1,表达式2 ，逗号运算符确保操作数被顺序地处理：先计算左边的操作数，再计算右边的操作数。右操作数的类型和值作为整个表达式的结果，而左操作数只是当作副作用被计算，其值和类型不会被返回。

1
2
3
4
5
6
7
8
9

// test.c
#include<stdio.h>
int main()
{
	int i = 9, o = 6, q;
	q = (i + o, i - o);
	// q = 3
	return 0;
}

• 指针运算符 & 和 * 。 * ：取值符，指向一个变量； & ：取地址符，取址运算符的操作数必须是在内存中可寻址到的地址。换句话说，该运算符只能用于函数或对象。

• 成员运算符 . 和 -> 。用于返回复杂数据类型的子成员。

• 下标运算符 [] 。用于访问下标，在数组中用到。

• 求字节运算符 sizeof() 。返回变量的大小，将需要求字节内存的变量或其他数据结构放于括号中。

• 强制类型转换运算符 (类型名)(表达式) 。 如 (float)(a + b) 。

3.3.7 运算符优先级

3.4 语句

1. 控制语句

1
2
3
4
5

//条件语句
if(条件)  //如果小括号里面的条件为真，则运行大括号的语句。
{
  …… 
}

1
2
3
4
5
6

//循环语句
for(语句1;语句2;语句3)  //语句2为条件，为真则运行大括号的语句，直至条件为假
{
  …… 
}
//注意，小括号内必须得有两个分号，即使没有语句

1
2
3
4
5
6
7
8
9
10
11
12

//循环语句
while(条件)  //如果小括号的条件为真，则运行大括号的语句，直至条件为假
{
  …… 
}

do
{
  …… 
}while(条件);  //如果小括号的条件为真，则运行大括号的语句，直至条件为假

// 注意，while(…){…}和do{…}while;的区别是，do-while至少循环一次，无视条件真或假。

1
2
3
4
5
6
7

continue;
//用于循环语句
//作用是结束该次循环，转至下一次循环，不改变总循环次数

break;
//用于循环语句或者switch语句
//作用是结束整个循环，改变总循环次数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//条件语句
switch (对象)
{
  case 值1:
    语句1 
    break;
  case 值2:
    语句2 
    break;
  default:  //default表示除以上case之外的情况
    语句3
    break;
}
//该语句每个case中的break不可省略。
//若省略break则系统会一直往下读语句，直至结束或者break，可自行上机作死

1
2

return ……;
//从函数中返回语句，一般情况下返回语句也是函数结束的地方

1
2
3
4
5
6
7

//转向语句
goto a;
  number = 0;
a:
  number = 1;
//结果number为1;  
//声明一处标记为a，使用goto语句使程序转向a处；

2. 函数调用语句：右一个函数调用加分号构成。

3. 复合语句：用 {} 括起来的语句，也称语句块。

4. 空语句：只有一个分号。

5. 表达式语句：一个表达式加上一个分号构成。用C语言运算符将运算对象连接起来的式子称为表达式。

3.5 变量的作用范围

任何一种编程中， 作用域 是程序中定义的变量所存在的区域，超过该区域变量就不能被访问。

C语言中有三个地方可以声明变量：

1. 在函数或块（由花括号包括起来的称为代码块）内部的局部变量

2. 在所有函数外部的全局变量

3. 在形式参数的函数参数定义中

变量按作用范围可分为 局部变量 、 全局变量 、 形式参数 。

• 局部变量

在某个函数或块的内部声明的变量称为局部变量。它们只能被该函数或该代码块内部的语句使用。局部变量在函数外部是不可知的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// test.c
#include <stdio.h>
int main()
{
	// 局部变量声明
	int a, b;
	int c;
 
	// 实际初始化 
	a = 10;
	b = 20;
	c = a + b;
 
	printf ("value of a = %d, b = %d and c = %d\n", a, b, c);
	return 0;
}

• 全局变量

全局变量是定义在函数外部，通常是在程序的顶部。全局变量在整个程序生命周期内都是有效的，在任意的函数内部能访问全局变量。也就是说，全局变量在声明后整个程序中都是可用的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>
// 全局变量声明
int g;
int main ()
{
	// 局部变量声明
	int a, b;
 
	// 实际初始化
	a = 10;
	b = 20;
	g = a + b;
 
	printf ("value of a = %d, b = %d and g = %d\n", a, b, g);
	return 0;
}

• 形式参数

函数的参数就是形式参数，被当作该函数内的局部变量，如果与全局变量同名它们会优先使用，同样如果局部变量与全局变量同名时优先使用当前区域的局部变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// test.c
#include <stdio.h>
// 全局变量声明
int a = 20;
int main()
{
	// 在主函数中的局部变量声明
	int a = 10;
	int b = 20;
	int c = 0;
	int sum(int, int);
 
	printf ("主函数中的 a = %d\n", a);
	c = sum(a, b);
	printf ("主函数中的 c = %d\n", c);
	return 0;
}
 
// 添加两个整数的函数
int sum(int a, int b)
{
	printf ("sum函数中的 a = %d\n",  a);
	printf ("sum函数中的 b = %d\n",  b);
	return a + b;
}

1
2
3
4
5

输出结果：
主函数中的 a = 10
sum函数中的 a = 10
sum函数中的 b = 20
主函数中的 c = 30

• 全局变量与局部变量在内存中的区别

1. 全局变量保存在内存的全局存储区中，占用静态的存储单元；

2. 局部变量保存在栈中，只有在所在函数被调用时才动态地为变量分配存储单元。

• 局部变量和全局变量的初始化

当局部变量被定义时，系统不会对其初始化，必须自行对其初始化。定义全局变量时，系统会自动对其初始化，如下所示：

Ⅳ —— 格式化输入输出

格式化的输入输出函数位于 stdio.h 头文件中。

4.1 格式化的输出

• printf()函数进行格式化的输出，其函数定义如下：

1
2
3
4

int printf(const char *fmt, ...);
// fmt：为常量字符串,存储在内存的常量字段，fmt为该字符串首地址；
// ...表示存在可变形参
// 输出正确返回输出的字符总数，输出错误返回负值

也可以参考这样的格式： printf(格式控制,输出表列)

1
2
3
4
5
6
7
8

// printf.c
#include<stdio.h>
int main()
{
	int a = 1, b = 2, c = 3;
	printf("%d %d %d\n", a, b, c);
	return 0;
}

1
2

输出结果：
1 2 3

格式控制，是使用双引号括起来的一个字符串，称为格式控制字符串，包括格式声明和普通字符。

1. 格式声明，由 %（百分号）和格式字符组成，其作用是将输出的数据转换为指定的格式后输出。格式声明总是由 % 字符开始。

2. 普通字符，即原样输出的字符，包括逗号、空格等。

应当注意的是：

1. 当我们想在显示器输出一个 % 时，我们需要在格式控制字符串中连续使用两个 % 表示一个 % 。

2. 当我们想在显示器输出一个 \ 时，我们需要在格式控制字符串中连续使用两个 \ 表示一个 \ 。

对于格式字符，有如下：

• PS：正常来说，一个数字的前面加 0 ，表示该数字为八进制。上述中不输出前导 0 ，但当格式为 %#o 时，输出前导 0 ；一个数字的前面加 0x ，表示该数字为十六进制。上述中不输出前导符，但当格式为 %#x 时，输出前导 0x 。

输入下面的代码可以直观感受输出的格式问题：会因为格式字符与输出的数据类型不匹配而导致输出乱码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// test.c

#include<stdio.h>
int main()
{
	int a = 1;
	float b = 3.1415926535; 
	double c = 3.1415926535;
	long int d = 1e9;
	long long int e=1e18;
	printf("%d\t\t%ld\t\t%lld\t\t%f\t%lf\n", a, a, a, a, a);
	printf("%d\t%ld\t%lld\t%.8f\t%.8lf\n", b, b, b, b, b);
	printf("%d\t%ld\t%lld\t%.8f\t%.8lf\n", c, c, c, c, c);
	printf("%d\t%ld\t%lld\t%f\t%lf\n", d, d, d, d, d);
	printf("%d\t%ld\t%lld\t%f\t%lf\n", e, e, e, e, e);
	return 0;
}

1
2
3
4
5
6

运行结果：
1               1               4294967297              0.000000        0.000000
1610612736      1074340347      4614256656748904448     3.14159274      3.14159274
1413551940      1074340347      4614256656551843652     3.14159265      3.14159265
1000000000      1000000000      4294967297000000000     3.141592        3.141593
-1486618624     232830643       1000000000000000000     0.000000        0.000000

应该清晰格式字符，不乱用不混用。 输出表列的数量需与%d（或其他格式声明）的数量一致。

%f 默认保留6位小数，而 %m.nf 可以自定义小数位，m指输出宽度，n指保留小数位。如果想用 0 控制宽度，在宽度控制数字前加 0 可以这么使用 %06d 、%07.2f ，但只能补前导 0 。而单独的 %.nf 就可以控制输出的小数位。

当m前面添加 - ，则输出数据向左对齐，再补空格或 0 。当m前面无 - ，则输出数据向右对齐，再补空格或 0 ，此时称前导空格或前导 0 。

如 %7.2f ，表示输出数据占7列（小数点也占一列），保留2位小数。运行以下代码可深刻理解：

1
2
3
4
5
6
7
8
9

// test.c
#include<stdio.h>
int main()
{
	float a = 3.141592;
	printf("|%07.2f|\n", a);
	printf("|%-07.2f|\n", a);
	return 0;
}

1
2
3

运行结果：
|0003.14|
|3.14   |

由 %f 拓展， %d 等格式声明都可在 % 和格式字符之间加一个数字（正或负），表示控制整个输出所占宽度，如 %7d 、 %4c 等。

如果事先并不知道保留多少小数位，而是后续输入的情况，可以使用占位符 %.*f 解决。

1
2
3
4
5
6
7
8
9
10

// test.c
#include<stdio.h>
int main()
{
	float a = 3.1415926;
	int k;
	scanf("%d", &k); // 根据输入的k决定保留多少位小数
	printf("%.*f", k, a);
	return 0;
}

另外， printf() 函数在运行时的形参是 从右到左 处理，具体效果如下：

1
2
3
4
5
6
7
8

// test.c
#include <stdio.h> 
int main() 
{ 
    int a = 5, b = 2;
    printf("%d %d\n", b = a + 1, a += 1);
    return 0;
}

1
2

输出结果:
7 6

由于是 从右到左 的顺序处理，所以先是 a += 1 ，a变成6，再接着 b = a + 1，b变成7。

• putchar()：输出一个字符

函数原型： int putchar(int _Character) ，函数定义在 stdio.h 中。

• puts()：输出一个字符串，并换行

函数原型： int puts(const char *s); ，函数定义在 stdio.h 中。

1
2
3
4
5
6
7
8
9
10

// test.c
#include<stdio.h>
int main()
{
	char a = 'a';
	putchar('!');
	putchar(a);
	puts("Hello World!");
	return 0;
}

1
2
3

运行结果：
!aHello World!

4.2 格式化的输入

• 用 scanf() 函数进行格式化的输入，其函数定义如下：

1
2
3

int scanf(const char * restrict format,...);
// 第一参数为输入格式字符串，省略号表示存在可变形参
// 输入成功返回成功读入的数据项数，输入数据时遇到了结束则返回EOF（End Of File）。

也可以参考这样的格式： scanf(格式控制，地址表列)；。格式控制字符串同输入的规则。在使用 scanf() 的时候，我们应当注意， scanf() 函数的地址表列是需要输入的变量地址，而不是变量名，因此，我们要在变量名前加 & 取地址符。如：

1
2

scanf("%d %d %d", a, b, c);    //此写法错误
scanf("%d %d %d", &a, &b, &c); //此写法正确

当我们不加取地址符的时候，程序会因为储存内存溢出（输入的内容没有正确的地方存放）而终止程序。因此，当我们的程序莫名中断崩掉时，我们可以优先考虑是否在输入时加取地址符。

从另一个角度理解，对于函数而言，我们希望输入一个值，也就是修改变量里面的值，应当传入其地址，而不是直接传入值。

还需要注意的是， scanf() 的格式控制字符串应与我们输入的格式严格一致，即格式控制字符串中有逗号或空格等的时候，我们输入也需加上逗号或空格等。如：

1
2

scanf("%d %d %d", &a, &b, &c);//此时应当输入 1 2 3
scanf("%d,%d,%d", &a, &b, &c);//此时应当输入 1,2,3

如果没有留意到这个问题，那么当我们输入数据的时候，可能会出现数据吞没的情况，因为输入的跟字符串规定的不匹配，不读入。

该函数还有自动处理的地方，如

1. 当我们的输入格式控制为 %d%d%d 时，系统会自动把空格或者换行（回车）作为分隔两个数据的标志。

2. 当我们的输入格式控制为 %f%f%f 时，系统会自动把小数点、空格或者换行（回车）作为分隔两个数据的标志。

1
2
3
4
5
6
7
8
9

// test.c
#include<stdio.h>
int main()
{
	float a, b;
	scanf("%f%f", &a, &b);
	printf("%f %f\n", a, b);
	return 0;
}

1
2
3

运行窗口：
3.142.77                              //输入
3.142000 0.770000                     //输出

虽然系统会自动把空格作为分隔两个数据的标志而不读入空格，但是总有办法可以使得 scanf() 函数输入带空格，如下代码：

1
2
3
4
5
6
7
8
9

// getstring.c
#include <stdio.h>
int main() 
{
	char a[20]; // 存放字符串
	scanf("%[^\n]", a); // 可输入带空格的字符串
	printf("%s\n", a);
	return 0;
}

实际上， scanf() 函数的注意点与其的键盘缓冲区和输入流有关。该函数会从输入流中选择数据放入键盘缓冲区中。在未输入满前忽略掉空白字符（空格、制表符和新行符），在输入满时把空白字符当作中断的标志。所以要注意反思输入流和键盘缓冲区里面的内容是什么，是否有键盘缓冲区遗留问题导致提前终止输入，是否有数据仍在输入流中没有进入键盘缓冲区而丢弃等。

• getchar()：输入一个字符

函数原型： int getchar(void); ，返回值则是输入的字符的ASCII码，若读取失败返回EOF或-1，函数定义在 stdio.h 中。

1
2
3
4
5
6
7
8
9

// test.c
#include<stdio.h>
int main()
{
	char b;
	b = getchar();
	putchar(b);
	return 0;
}

1
2
3

运行窗口：
h	// 输入
h	// 输出

• gets()：输入一个字符串，一般使用 scanf() 输入字符串的时候不能输入含空格的字符串，而使用 gets() 则可以输入含空格的字符串。

由于 gets() 函数的不安全性，在C99标准中，已经不再建议使用该函数，而在C11中更是直接抛弃了这个函数。

Ⅴ —— 条件结构

实际上，在很多情况下，需要根据某个条件是否满足来决定是否执行指定操作任务，或者从给定的两种或多种操作选择其一。这就是选择结构需要解决的问题。再举个详细的例子，当我们处于岔路时，做出方向的选择；比如数学上的分段函数，条件不同对应函数关系不同。

通过条件结构，可以完成一些简单的语法题，如交换两个数，输出两数最大值和最小值，由键盘输入三个数输出最大值，判断闰年……

条件的真假如果对应到数字上，0为假，非0为真，即正负数都为真。

5.1 if构成的条件结构

if 语句的结构如下：

1
2
3
4
5
6
7

if( condition is true ) 
{
  sentence1;
  sentence2;
  …………
}
//先简单地翻译一遍以上代码：如果（ 某个条件成立 ），则运行花括号中的内容。

需要注意， if 语句在没有花括号的情况下，只连带其后的一句语句。即 if(condition) 后只能跟一个语句，其可以是单个简单语句，也可以是由花括号包含起来的复合语句。

再加之 else （另外，否则），可以组成以下三种形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// 情况一，无else子句部分，只有单个if语句
if( condition )
{
	sentence;
}   
    
// 情况二，有else子句部分
if( condition )
{
	sentence1;
} 
else
{
	sentence2;
}
      
// 情况三，在else部分又嵌套多层if语句
if( condition )
{
	sentence1;
} 
else if( condition1 )
{
	sentence2;
}   
else
{
	sentence3;
}

// 情况三还可以写成下面的形式
if( condition )
{
	sentence1;
} 
else 
{
	if( condition1 )
	{
		sentence2;
	}   
	else
	{
		sentence3;
	}
}

if 语句无论写几行，都是一个整体，属于同一个语句，只是将其分成 if 部分和 else 部分。在 if 语句中要对给定的条件进行检查，判定所给定的条件是否成立。判断的结果是一个逻辑值“是”或“否”。

if 语句小括号中的 condition ，应该是由关系运算符与逻辑运算符构成的表达式，运算符号详见运算符。如表达x大于1时写成 x>1 ，表达x在10到20之间时写成 x >=10 && x <= 20 ，表达x不等于4时写成 x != 4 ，表达x等于4时写成 x == 4 。可以试着巧妙应用 ? : 三目运算符转化繁琐的if结构。

下面结合一个例子剖析 if-else 语句，在数学中有阶跃函数（分段函数），当x＞0时，y＝1；当x＝0时，y＝0；当x＜0时，y＝-1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// test.c
#include <stdio.h> //声明头文件

int main() 
{
	int x, y; //定义x和y变量
	scanf("%d", &x); //输入x
	if(x > 0) //第一个判断，做x＞0的判断
	{
		y = 1;
	}
	
	else if( x == 0 ) //排除第一个判断后的另外一个判断，做x＝0的判断
	{
		y = 0;
	}
  
	else if( x < 0 ) //排除以上两种情况后的另一种情况，做x＜0的判断
	{
		y = -1;
	}
	
	//其实这种情况下，排除以上两种情况，剩下唯一的可能，可以写成else部分
	//如：
	//  else
	//  {
	//     y = -1;
	//  }
  
	printf("%d", y); //输出y
	return 0;
}

if 语句可以多个嵌套， if 中又带有 if-else 等情况，请注意辨识。应当注意 if 与 else 的配对关系。 else 总是与它上面最近的未配对的 if 配对， else 一般不能单独出现，上面必须先有 if 部分。上面的例子用 if 语句嵌套可如下表示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// test.c
#include <stdio.h> //声明头文件

int main() 
{
	int x, y; //定义x和y变量
	scanf("%d", &x); //输入x
	if(x >= 0)  //将大于等于零归为一类
	{
		if(x > 0)//再判断大于0的情况
			y = 1;
		else //在x大于等于零的情况下，再排除x大于零，即x等于零
			y = ;  
	}
	else //排除x大于等于零的情况下，即x小于零 
		y = -1;
  
	printf("%d", y); //输出y
	return 0;
}

5.2 switch构成的条件结构

switch 语句的结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

switch (object) //对于某个变量或表达式进行switch
{
	case constant1: //对于常量1的情况，进行语句
		//操作部分语句
		break; //注意break必须存在

	case constant2: //对于常量2的情况，进行语句
		//操作部分语句
		break; //注意break必须存在

	default: //对于默认情况，即排除上述情况，进行语句
		//操作部分语句
		break; //注意break不必存在，建议存在
}

在此强调， switch 语句中 case 情况部分的 break 语句必须存在，此为语法规定。当去掉 break 语句时，系统将逐句往下运行。更具体地说，如果 switch 时 case 情况1的话，你想运行情况1部分的语句，但因为缺少 break 语句，系统还会运行下面 case 情况的语句，造成逻辑表达上的错误。可以对下面的代码中每个 break 试着取消注释，让其运行，观察系统运行语句输出区别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// test.c
#include <stdio.h> //声明头文件

int main() 
{
	int object = 1, sum = 0;
	switch(object) 
	{
		case 0 : 
			sum = 0;
			//break;
		case 1 : 
			sum = 1;
			//brea;
		case 2 :
			sum = 2;
			//break;
		default :
			sum = -1;
			//break;
	}
	printf("%d", sum);
	return 0;
}

switch 语句的对象应该是 整型和字符类型的变量或变量表达式 ，如 int 变量 number 、 char 变量 ch 、 number%10 、 ch+32 ……相对于的 case 情况应该是整型常量或者是字符常量。如整数1、2、3……和字符’A’、‘B’、‘c’……

对于 switch 语句，还有以下规则说明。操作部分语句可以不止一个语句，其一直运行到 break 语句为止。可以没有 default 的情况，但此时如果没有与 switch 表达式相匹配的 case 常量时，不执行任何语句。 case 情况出现的次序不影响执行结果，每个 case 情况常量必须互不相同，不能存在一个值有多种执行情况。

这里有一个例子，对于输入分数，输出分数评级，可以辅助理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// test.c
#include <stdio.h> //声明头文件

int main() 
{
	int score ; //输入分数score，此处人为规定输入值在0到100之间 
	char grade ; //输出分数评级，由'A'到'E' 
	scanf("%d" , &score ) ; //输入分数 
	switch( score / 10 ) 
	//对分数除以十，即判断十位的情况，如80分到90，除以十为8 
	{
		case 10: 
			grade = 'A' ;
			break ;
		case 9: 
			grade = 'A' ;
			break ;    
		case 8: 
			grade = 'B' ;
			break ;
		case 7: 
			grade = 'C' ;
			break ;
		case 6: 
			grade = 'D' ;
			break ;
		default:
			grade = 'E' ;
			break ;      
	}
	printf("Your grade is %c .\n" , grade ) ;
	return 0;
}

switch 语句也是可以嵌套的，但结构上比较繁琐。

Ⅵ —— 循环结构

有时候用条件结构还是不能简便解决问题，还需要使用循环结构，如处理求多个整数的和、处理多个判断。

再如在输入的时候，我希望输入50个数字，我们可以复制粘贴50句 scanf() 来实现这个要求。学了循环之后，至少，不再需要50句语句。

需要注意的是， 循环语句一定要设置终止条件，否则将进入死循环，无法得出结果！！！

通过循环结构，可以完成一些简单的语法题，如判断一个数是否为素数，计算斐波那契数列，计算阶乘……

6.1 while构成的循环结构

while 语句的一般形式如下：

1
2
3
4
5
6

while( condition is true ) 
{
	sentences;
	……………………
	//花括号内的内容总称为循环体
}

此处 condition 为表达式，只有当循环条件为真，即表达式为真，就执行循环体语句。循环体可以是一条语句，也可以是一个语句块（用花括号包起来）。 while 循环的特点是先判断条件表达式，后执行循环体语句。

while 语句的运行顺序是：从上至下，先判断条件表达式是否为真，为真则执行循环体。循环体运行完后再次判断条件表达式，为真则执行循环体。一直循环直至判断条件表达式为假。

这里给出一个例子，求1到100的和，希望通过例子更好理解 while 循环：

分析此问题，将100个数相加，要重复进行100次加法，显然是需要循环结构介入。有兴趣的可以尝试画画流程图（此处不做介绍）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// add-100-number.c
#include <stdio.h> //声明头文件 
int main()
{
	int i = 1; //初始化循环变量，从1开始 
	int sum = 0; //用来存求和的值 
	while(i <= 100) 
	{
		sum += i; //相当于sum=sum+i，求和 
		i ++; //i自增，实现从1到2到3到……100 
	}
	printf("sum = %d\n", sum); //输出求和的值 
	return 0;
}

while 括号里的 condition 条件表达式实际上也会被执行的，如果条件表达式是赋值语句（赋值成功则表达式为真）、自增自减等也会生效。

6.2 do-while构成的循环结构

do-while 语句。其一般形式如下：

1
2
3
4
5
6

do 
{
	sentences;
	……………………
	//花括号内的内容总称为循环体
} while(condition is true); //注意这有一个分号

此处 condition 为表达式，道理同上。 do-while 循环的特点是先无条件执行循环体，然后判断循环条件是否成立。即 do-while 循环至少进行一次循环，注意与 while 语句区分。

do-while 语句的运行顺序是：从上至下，先无条件执行一次循环体，再判断条件表达式是否为真，为真则回到循环体开始重新执行循环体。循环体运行完后再次判断条件表达式，为真则执行循环体。一直循环直至判断条件表达式为假。

此处同样解决上面的问题，从1加到100求和。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// add-100-number.c
#include <stdio.h> //声明头文件 
int main()
{
	int i = 1; //初始化循环变量，从1开始 
	int sum = 0; //用来存求和的值 
	do
	{
		sum += i; //相当于sum=sum+i，求和 
		i ++; //i自增，实现从1到2到3到……100 
	} while(i <= 100);
	printf("sum = %d\n", sum); //输出求和的值 
	return 0;
}

while 括号里的 condition 条件表达式实际上也会被执行的，如果条件表达式是赋值语句（赋值成功则表达式为真）、自增自减等也会生效。

6.3 for构成的循环结构

for 语句的一般形式如下：

1
2
3
4
5
6

for( sentence1; condition; sentence2 )
{
	sentences3
	…………………………
	//花括号内的内容总称为循环体
}

此处 sentence1 和 sentence2 为普通表达式， sentence1 只执行一次，而 sentence2 在每次执行完循环体后都会运行一次。 condition 为条件控制表达式，只有当循环条件为真，即表达式为真，就执行循环体语句。

for 语句的运行顺序是：先进行一次 sentence1 ，接着判断 condition 是否为真，为真则执行循环体。循环体运行完后执行 sentence2 。然后再次判断 condition ，一直循环直至条件为假。

所以延展出常用的 for 语句使用格式：

1
2
3
4

for(循环变量赋值初始化; 循环条件; 循环变量变化)
{
  循环体
}

做个补充，在老版本的C语言中， sentence1 不支持声明变量并同时初始化，如： for(int i = 1; i <= 100; i ++) 。但是在C99版本后是允许的。

事实上， for 语句中的 sentence1 语句、 sentence2 语句和 condition 语句并非必要。即这三句语句可以省略，省略 condition 语句默认为真，写成 for( ; ; ) ，但是两个分号绝不可少。在省略掉这三句语句时，我们仍要思考如何终止循环。例如在 for 语句上面就把变量初始化，在循环体中设置判断 if 什么条件就终止循环，在循环体中处理条件变化……

6.4 循环的终止与继续

• 使用 break 语句终止循环。

之前使用 break 语句，可能是条件结构中跳出 switch 语句。实际上， break 语句还可以用来跳出循环体，即终止循环。

以求1到100和的例子，假如我希望在和刚好大于等于2500的时候结束，并想知道此时是多少个数的和，那怎么实现呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// use-break.c
#include <stdio.h> //声明头文件 

int main() 
{
	int i, sum = 0;
	for(i = 1; i <= 100; i ++) 
	{
		sum += i;
		if(sum >= 2500) //当sum大于等于2500 
		break; //终止所在的一层for循环 
	}
	printf("sum = %d, and now i is %d\n", sum, i);
	return 0;
}

当然也可以这样解决：

1
2
3
4
5
6
7
8
9
10
11
12
13

// use-for.c
#include <stdio.h> //声明头文件 

int main() 
{
	int i, sum = 0;
	for(i = 1; sum < 2500; i ++) 
	{
		sum += i;
	}
	printf("sum = %d, and now i is %d\n", sum, i);
	return 0;
}

注释中我写到，终止 break 所在的一层 for 循环，因为当有多个循环嵌套时， break 不会终止所有的循环，而是一层循环。（可以自己做实验研究）

• 使用 continue 语句跳过本次循环。

有时候不希望终止整个循环，而是想结束这一次循环，还得执行下次循环。这时可以使用 continue 语句。

还是求1到100和的例子，但我希望求1到100中是偶数的和，那么奇数就没必要加进去，此时可以使用 continue 语句跳过本次循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Find-the-sum-of-even-numbers-from-1-to-100.c
#include <stdio.h> //声明头文件 
int main() 
{
	int i, sum = 0;
	for(i = 1; i <= 100; i ++) 
	{
		if(i % 2 == 1) //当i为奇数，即除于2余数为1 
			continue; //结束本次循环 
		sum += i; 
	}
	printf("sum = %d\n", sum);
	return 0;
}

需要注意的是，结束本次循环并不是完全不进入循环，而是不执行 continue 下面的循环体部分。上面的代码，如果 sum += i 在 continue 的上面，结果还是会加上奇数的部分。

Ⅶ —— 枚举

枚举是C语言中的一种基本数据类型，用于定义一组具有离散值的常量。枚举类型通常用于为程序中的一组相关的常量取名字，以便于程序的可读性和维护性。

定义一个枚举类型，需要使用 enum 关键字，后面跟着枚举类型的名称，以及用大括号 {} 括起来的一组枚举常量。每个枚举常量可以用一个标识符来表示，也可以为它们指定一个整数值，如果没有指定，那么默认从0开始递增。

枚举语法定义格式为：

1

enum　枚举名　{枚举元素1,枚举元素2,……};

举个例子，一周有7天，如果想将星期一映射为数字1，星期天映射为数字7，我们可以使用枚举。

1
2
3
4
5
6

enum Day
{
	MON=1, TUE, WED, THU, FRI, SAT, SUN
};
// MON映射到1，后面的会自动递增
// 效果跟#define MON 1 等一样

如果想让星期三之后特殊一些，星期三映射到8，星期天映射到12，只需在中间添加赋值即可。

1
2
3
4
5

enum Day
{
	MON=1, TUE, WED=8, THU, FRI, SAT, SUN
};
// MON映射到1，TUE映射到2，WED映射到8，后面的会自动递增

使用时直接输出即可：

1

printf("%d", MON);

然而上面是对枚举类型的使用，下面介绍枚举变量的定义和使用。

枚举类型是一种数据类型，可以对标 int 理解；枚举变量是一个变量，可以对标 int number 中的 number 理解。

可以通过三种方式定义枚举变量：

1. 先定义枚举类型，再定义枚举变量

1
2
3
4
5

enum DAY
{
	MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;

2. 定义枚举类型的同时定义枚举变量

1
2
3
4

enum DAY
{
	MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

3. 省略枚举名称，直接定义枚举变量

1
2
3
4

enum
{
	MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

给出使用枚举变量的情形：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// test.c
#include <stdio.h>
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
 
int main()
{
    enum DAY day;
    day = WED;
    printf("%d", day);
    return 0;
}

在 枚举类型值连续 的情况下还可以进行循环：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// test.c
#include <stdio.h>
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
int main()
{
    // 遍历枚举元素
    for (day = MON; day <= SUN; day++) 
    {
        printf("枚举元素：%d \n", day);
    }
    return 0;
}

如果将将整数转换为现有枚举值，只需强制类型转换：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// test.c
#include <stdio.h>

int main()
{
 
    enum day
    {
        saturday, sunday, monday, tuesday, wednesday, thursday, friday
    } workday;
 
    int a = 1;
    enum day weekend;
    weekend = ( enum day ) a;  //类型转换
    //weekend = a; //错误
    printf("%d",weekend);
    return 0;
}

1
2

输出结果：
1

Ⅷ —— 数组

数组是一种可以存储固定大小的相同类型元素的顺序集合。简单来说，数组可以存放一串相同的数据类型。

8.1 数组结构

数组的结构如下图：

数组的每一个单体称作 元素 ，每个元素有它的 索引号 ，用于访问该元素。 索引号从0开始。

8.2 数组的定义和访问

数组的定义十分简单，其定义格式是：

1

type arrayName [arraySize];

如 int array[5]; 就定义了一个大小为5的整型数组，数组名为array，它可以存放5个整型数据，索引号从0到4。

访问数组时直接使用 arrayName[index] 的方式进行，如 array[0] 就是array数组的第一个元素的值。使用循环还可以将数组的内容输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// test.c
#include <stdio.h>
int main()
{
	int i;
	int array[5];
	
	// 访问数组并赋值
   	for(i = 0; i < 5; ++ i)
   		array[i] = i + 1;
   	
   	// 访问数组并输出
   	for(i = 0; i < 5; ++ i)
   		printf("%d ", array[i]);
   	return 0;
}

补充个冷知识，我们比较经常使用 array[0] 访问元素，实际上还能以 0[array] 的方式访问元素。

8.3 数组的初始化

通过上面的例子，我们可以通过循环给数组中的每个元素赋值。但是还可以通过声明时的初始化语句进行相同的操作。

1

int array[5] = {1, 2, 3, 4, 5};

大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。即等价于：

1

int array[] = {1, 2, 3, 4, 5};

8.4 多维数组

C 语言支持多维数组。多维数组声明的一般形式如下：

1

type name[size1][size2]...[sizeN];

下面以二维数组作为示例。一个二维数组，在本质上，是一个元素为一维数组的数组。定义形式如下：

1

type arrayName [x][y];

如一个二维数组初始化如下：

1
2
3
4
5

int array[3][4] = {  
 {1, 2, 3, 4} ,   /*  初始化索引号为 0 的行 */
 {5, 6, 7, 8} ,   /*  初始化索引号为 1 的行 */
 {9, 10, 11, 12}   /*  初始化索引号为 2 的行 */
};

二维数组中的元素是通过使用下标（即数组的行索引和列索引）访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// test.c
#include <stdio.h> 
int main ()
{
	// 一个带有 5 行 2 列的数组
	int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
	int i, j;
 
	// 输出数组中每个元素的值
	for (i = 0; i < 5; i++)
	{
		for (j = 0; j < 2; j++)
		{
			printf("a[%d][%d] = %d\n", i, j, a[i][j]);
		}
	}
	return 0;
}

8.5 数组的使用

• 求数组长度：使用 sizeof 关键字，将整个数组占的内存大小除以每个元素占的内存大小，得到的就是元素个数。

1
2

int numbers[] = {1, 2, 3, 4, 5};
int length = sizeof(numbers) / sizeof(numbers[0]);

• 将数组作为函数参数传入

1. 形式参数是一个已定义大小的数组

1
2
3
4

void fun(int param[10])
{
	// ……
}

2. 形式参数是一个未定义大小的数组

1
2
3
4

void fun(int param[])
{
	// ……
}

为了函数的通用性，通常使用未定义大小的数组，再将数组大小作为第二参数传入。

1
2
3
4
5
6
7
8
9
10
11
12

double getAverage(int arr[], int size) // 求数组的平均值
{
	int i;
	double avg;
	double sum;
	for (i = 0; i < size; ++ i)
	{
		sum += arr[i];
	}
	avg = sum / size;
	return avg;
}

需要注意的是，我们传入的是数组，在函数内部中如若有对数组元素的修改，也会同步对外部的数组进行修改。因为此处形式参数是以地址传递的形式传入。

为什么传递数组名字会是以地址传递的形式传入呢？那是因为 数组名实际上是一个指针 ，它存放数组中首元素的地址。至于什么是指针，可查阅下一节。

Ⅸ —— 指针

指针是C语言很重要的一环。

数据都有一个内存空间，内存空间都有一个地址，我们形象地把这个地址称为指针。指针也就是内存地址，指针变量是用来存放内存地址的变量。

9.1 指针变量的定义

指针变量定义的一般形式为：

1

type *var_name;

type 是指针的基类型，它必须是一个有效的数据类型， var_name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的，但在此处的意义是标记改变量是指针变量，称为指针运算符。一个指针对应一个 * 。

所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个 代表内存地址的长的十六进制数 。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

当我们需要取一个变量的地址时，我们需要加 & （取地址符）；当我们需要取一个指针的数据时，我们需要加 * 。

1
2

int a = 1;
int *pa = &a;

之前使用 scanf() 函数时所加的 & ，表明我们是把数据放到某变量名所处的地址，而不是塞到变量名里面。

如果想输出地址的话，可以使用 %p 或 %x 输出：

1
2

int a = 1;
printf("%p", &a);

指针使用前必须有初始化值，即定义时必须赋值，若无值则指向NULL。

1

int *p = NULL;

如果使用前没有初始化值时，该指针会变成 野指针 ，指针指向了一块随机的空间，不受程序控制。有可能是系统重要软件的地址，贸然使用可能使得系统崩溃。

9.2 指针的运算

• 指针之间不能进行 + 运算，无意义。

• 指针进行 < 运算时，表示实际内存高低位的比较；

• 指针进行 = 运算时，表示把右边的地址赋值给左边；

• 指针进行 - 运算时，表示在两指针之间相隔相同类型元素的个数。

• 指针进行 ++ 运算时，表示在指针递增，会指向下一个元素的存储单元。指针在递增时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。

• 指针进行 -- 运算时，表示在指针递减，会指向上一个元素的存储单元。指针在递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。

9.3 指针的使用

• 指针间接访问变量

通过指针输出：

1
2
3
4
5
6
7
8
9
10
11
12
13

// test.c
#include<stdio.h>
int main()
{
	int a = 100, b = 10;
	int *pointer1, *pointer2;
	pointer1 = &a;
	pointer2 = &b;
	printf("a=%d,b=%d\n", a, b); 
	printf("pointer1=%d,pointer2=%d\n", pointer1, pointer2); 
	printf("pointer1=%d,pointer2=%d\n", *pointer1, *pointer2);
	return 0;
}

1
2
3
4

输出结果：
a=100,b=10
pointer1=6422216,pointer2=6422220
pointer1=100,pointer2=10

通过指针将两个变量存放的值交换，用地址传递实现存储空间上的交换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// swap-ab.c
#include<stdio.h>
void swap(int *a,int *b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

int main()
{
	int x = 1, y = 2;
	printf("x=%d,y=%d\n", x, y);
	swap(&x, &y);
	printf("x=%d,y=%d\n", x, y);
	return 0;
}

1
2
3

输出结果：
x=1,y=2
x=2,y=1

• 指针引用一维数组

数组名即是该数组首元素（即序号为0的元素）的地址。所以我们可以直接用指针指向数组名，无需取地址符。

1
2
3

int a[10];
int *p;
p = a;

同时，我们可以对数组首元素进行取地址，即下代码等价：

1
2

p = a;      //p指向数组首元素的地址，即a[0]的地址；
p = &a[0];  //p指向a[0]的地址

当我们正确把指针指向一个数组的时候，可以对指针进行以下运算： p++ , ++p , p-- , --p , p = p + 1 , p = p - 1 等。

1
2
3
4
5
6
7
8
9
10
11
12

// test.c
#include<stdio.h>
int main()
{
	int a[5] = {101,102,103,104,105};
	int *p;
	p = a;
	printf("%d ", *p);
	printf("%d ", *(p+1));
	printf("%d", *(p+2));
	return 0;      
}

1
2

输出结果：
101 102 103

因为数组名也有地址的属性，所以输出语句还可以改成：

1
2
3

printf("%d ", *a);
printf("%d ", *(a+1));
printf("%d", *(a+2));

但数组名不能进行自增自减，如不能 a++ 或 a-- 等。

指针还可以引用字符串（字符数组），字符串的本质是一个字符数组。我们可以类似指针引用一维数组那样引用字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13

// test.c
#include<stdio.h>
int main()
{
  char a[] = "computer!";
  char *p;
  p = a;
  printf("%c\n", *p);  //%c，取*时，具体到某个元素，此处是首元素
  printf("%c\n", *(p + 2));
  printf("%s\n", p);  //%s，不取*，从首元素输出所有字符
  printf("%s\n", p + 2);  // 从a[2]开始输出所有字符
  return 0;
}

1
2
3
4
5
6

输出结果：
输出结果：
c
m
computer!
mputer!

1
2
3
4

//以上也可用字符指针变量表示，如下所示：
char *p="computer!";//此处可能会出现warning，但无关紧要
//上句等价于char *p; p="computer!";
printf("%s",p);//此处无需*p，注意对比

char *p="computer!" 的意思是将字符指针变量 p 指到"computer!"的首地址即"c"的地址。

之前，我们用字符数组也能实现打印字符串，而使用字符指针的不同是：

①可以对字符指针变量赋值，但不能对数组名赋值，初始化不等于赋值，如不能：

1
2
3

char a[10] = {"computer!"}; //此句合法
char a[10]; 
a = "computer!"; //此句不合法

②储存内容不同，字符数组把每一个元素的值都存放，而字符指针只存放第一个元素的地址。

• 指针指向二维数组

二维数组有两个下标，那么一个指针怎么指，我们将指针分为 行指针 和 列指针 。行指针，即指向某一行元素的指针；列指针，即指向某一列元素的指针。

下有二维数组 a[4][5] ：

• 动态数组

像 int a[5]; 这样的定义数组，我们称之为 静态数组 。在程序编译时，静态数组的内存空间就被分配好了，存储在栈上或者全局数据区。静态数组的大小在声明时确定且无法在运行时改变。静态数组的生命周期与其作用域相关。如果在函数内部声明静态数组，其生命周期为整个函数执行期间；如果在函数外部声明静态数组，其生命周期为整个程序的执行期间。

动态数组 是在运行时通过动态内存分配函数（如 malloc 和 calloc ）手动分配内存的数组。动态数组的内存空间在运行时通过动态内存分配函数手动分配，并存储在堆上。需要使用 malloc 、 calloc 等函数来申请内存，并使用 free 函数来释放内存。动态数组的大小在运行时可以根据需要进行调整。可以使用 realloc 函数来重新分配内存，并改变数组的大小。动态数组的生命周期由程序员控制。需要在使用完数组后手动释放内存，以避免内存泄漏。

1
2
3
4

int size = 5;
int *dynamicArray = (int *)malloc(size * sizeof(int)); // 动态数组内存分配
// 使用动态数组
free(dynamicArray); // 动态数组内存释放

• 数组指针

数组指针，其本质是指针，指向一个一维数组的指针。所以定义时，由运算符优先级，我们需要带上小括号

定义数组指针： 类型名 (*指针变量名)[长度];

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// test.c
#include<stdio.h>
int main()
{
	int a[4][5] = {
		1,2,3,4,5,
		6,7,8,9,10,
		11,12,13,14,15,
		16,17,18,19,20};
	int (*p)[5];
	p = a+1; // 指向第2行
	for(int i=0;i<5;i++)  printf("%d ",(*p)[i]);
	return 0;
}

1
2

输出结果：
6 7 8 9 10

• 指针数组

指针数组，其本质是数组，是一个元素均为指针类型的数组。

定义指针数组： 类型名 *数组名[长度];

举例：（将数字转化为对应的英文月份）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// test.c
#include<stdio.h>
int main()
{
	char *p[13];
	p[1]="Januray";  p[2]="February";  p[3]="March"; 
	p[4]="April";  p[5]="May";      p[6]="June";
	p[7]="July";  p[8]="August";    p[9]="September";
	p[10]="October";p[11]="November";  p[12]="December";
	//可能会警告，但无关紧要
	int n;
	scanf("%d",&n);
	printf("%s\n",p[n]);
	return 0;
}

1
2
3

运行结果：
3 	// 输入
March 	// 输出

• 指向函数的指针

函数名也代表函数的起始地址。

此内容直接看以下例子——比较两个数字的大小

1
2
3
4
5
6
7
8
9
10
11
12
13

// test.c
#include<stdio.h>
int max(int x,int y)
{
	return (x > y ? x : y);
}

int main()
{
	int a = 50, b = 100;
	printf("max=%d", max(a, b));
	return 0;
}

上代码等价于：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// test.c
#include<stdio.h>
int max(int x,int y)
{
	return (x > y ? x : y);
}

int main()
{
	int a = 50, b = 100;
	int (*p)(int,int);
	p = max;
	printf("max=%d", (*p)(a,b));
	return 0;
}

注意 int (*p)(int,int)；定义指向函数的指针变量： 类型名 (* 指针变量名)(函数参数表列);

指向函数的指针变量的一个重要用途是把函数的入口地址作为参数传递到其他函数，下附一个使用函数指针的例子；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// test.c
#include<stdio.h>
void fun(int x, int y, int (*p)(int,int))
{
	int ans;
	ans = (*p)(x,y);
	printf("%d", ans);
}
int max(int x,int y)
{
	printf("max=");
	return x > y ? x : y;
}
int min(int x,int y)
{
	printf("min=");
	return x < y ? x : y;
}

int main()
{
	int a = 34, b = -21, n;
	printf("请输入你的选择(1-求最大值，2-求最小值)：");
	scanf("%d", &n);
	if(n==1)  fun(a, b, max);
	if(n==2)  fun(a, b, min);
	return 0;
}

• 返回指针类型的函数

定义返回指针值得函数形式为： 类型名* 函数名(参数表列);

依然是使用一个例子：对若干学生成绩，找出不合格得课程得学生及其学生号，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// test.c
#include<stdio.h>
float* search(float (*pointer)[4])//定义函数
{
	int i = 0;
	float *pt;
	pt = NULL;
	//切记初始化指针，无则指向NULL

	for(; i < 4; i ++)
	{
		if(*(*pointer+i)<60)  pt = *pointer;
		//如有不及格，使pt指向score[i][0]
	}
	return pt;
}
int main()
{
	float score[][4] = {{60,70,80,90},{56,89,67,88},{34,78,90,66}};
	//定义数组，初始化成绩，有3名学生，每名学生有4门成绩
	float *p;
	int i, j;
	for(i = 0; i < 3; i ++)
	{
		p = search(score + i);
		//调用search函数，如不及格则返回score[i][0]的地址
		//否则返回NULL
		if(p == *(score+i))  //若返回的不是NULL，则输出学生成绩
		{
			printf("No.%d score:",i);
			for(j = 0; j < 4; j ++)
				printf("%5.2f ", *(p+j));
			printf("\n");
		}
	}
	return 0;
}

• 指向指针数据的指针变量

指向指针数据的指针，可以嵌套，如：

1
2
3
4
5
6
7
8
9
10
11
12

// test.c
#include<stdio.h>
int main()
{
	int a = 100;
	int *p;
	p = &a;
	int **q;
	q = &p;
	printf("%d ", **q);
	return 0;
}

1
2

输出结果：
100

Ⅹ —— 共用体与结构体

10.1 共用体

共用体（Union） 是一种特殊的数据类型，允许在相同的内存位置存储不同的数据类型。可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。

为了定义共用体，必须使用 union 语句。 union 语句定义了一个新的数据类型，带有多个成员。定义格式如下：