2021-11-02发表2025-08-16更新阮一峰计算机科学 / 编程语言 / C·C++11 小时读完 (大约100972个字)0次访问

《C语言入门教程》阮一峰

原文地址：https://www.ruanyifeng.com/blog/2021/09/c-language-tutorial.html
我把这些都转载到这里了

C 语言简介

历史

C 语言最初是作为 Unix 系统的开发工具而发明的。

1969年，美国贝尔实验室的肯·汤普森（Ken Thompson）与丹尼斯·里奇（Dennis Ritchie）一起开发了 Unix 操作系统。Unix 是用汇编语言写的，无法移植到其他计算机，他们决定使用高级语言重写。但是，当时的高级语言无法满足他们的要求，汤普森就在 BCPL 语言的基础上发明了 B 语言。

1972年，丹尼斯·里奇和布莱恩·柯林汉（Brian Kernighan）又在 B 语言的基础上重新设计了一种新语言，这种新语言取代了 B 语言，所以称为 C 语言。

1973年，整个 Unix 系统都使用 C 语言重写。此后，这种语言开始快速流传，广泛用于各种操作系统和系统软件的开发。

1988年，美国国家标准协会（ANSI）正式将 C 语言标准化，标志着 C 语言开始稳定和规范化。

几十年后的今天，C 语言依然是最广泛使用、最流行的系统编程语言之一，Unix 和 Linux 系统现在还是使用 C 语言开发。

C 语言的特点

C 语言能够长盛不衰、广泛应用，主要原因是它有一些鲜明的特点。

（1）低级语言

C 语言能够直接操作硬件、管理内存、跟操作系统对话，这使得它是一种非常接近底层的语言，也就是低级语言，非常适合写需要跟硬件交互、有极高性能要求的程序。

（2）可移植性

C 语言的原始设计目的，是将 Unix 系统移植到其他计算机架构。这使得它从一开始就非常注重可移植性，C 程序可以相对简单地移植到各种硬件架构和操作系统。

除了计算机，C 语言现在还是嵌入式系统的首选编程语言，汽车、照相机、家用电器等设备的底层系统都是用 C 语言编程，这也是因为它良好的可移植性。

（3）简单性

C 语言的语法相对简单，语法规则不算太多，也几乎没有语法糖。一般来说，如果两个语法可以完成几乎相同的事情，C 语言就只会提供一种，这样大大减少了语言的复杂性。

而且，C 语言的语法都是基础语法，不提供高级的数据结构，比如 C 语言没有“类”（class），复杂的数据结构都需要自己构造。

（4）灵活性

C 语言对程序员的限制很少。它假设程序员知道自己在干嘛，不会限制你做各种危险的操作，你干什么都可以，后果也由自己负责。

C 语言的哲学是“信任程序员，不要妨碍他们做事”。比如，它让程序员自己管理内存，不提供内存自动清理功能。另外，也不提供类型检查、数组的负索引检查、指针位置的检查等保护措施。

表面上看，这似乎很危险，但是对于高级程序员来说，却有了更大的编程自由。不过，这也使得 C 语言的 debug 不太容易。

（5）总结

上面这些特点，使得 C 语言可以写出性能非常强、完全发挥硬件潜力的程序，而且 C 语言的编译器实现难度相对较低。但是另一方面，C 语言代码容易出错，一般程序员不容易写好。

此外，当代很多流行语言都是以 C 语言为基础，比如 C++、Java、C#、JavaScript 等等。学好 C 语言有助于对这些语言加深理解。

C 语言的版本

历史上，C 语言有过多个版本。

（1）K＆R C

K&R C指的是 C 语言的原始版本。1978年，C 语言的发明者丹尼斯·里奇（Dennis Ritchie）和布莱恩·柯林（Brian Kernighan）合写了一本著名的教材《C 编程语言》（The C programming language）。由于 C 语言还没有成文的语法标准，这本书就成了公认标准，以两位作者的姓氏首字母作为版本简称“K&R C”。

（2）ANSI C（又称 C89 或 C90）

C 语言的原始版本非常简单，对很多情况的描述非常模糊，加上 C 语法依然在快速发展，要求将 C 语言标准化的呼声越来越高。

1989年，美国国家标准协会（ANSI）制定了一套 C 语言标准。1990年，国际标准化组织（ISO）通过了这个标准。它被称为“ANSI C”，也可以按照发布年份，称为“C89 或 C90”。

（3）C95

1995年，美国国家标准协会对1989年的那个标准，进行了补充，加入多字节字符和宽字符的支持。这个版本称为 C95。

（4）C99

C 语言标准的第一次大型修订，发生在1999年，增加了许多语言特性，比如双斜杠（//）的注释语法。这个版本称为 C99，是目前最流行的 C 版本。

（5）C11

2011年，标准化组织再一次对 C 语言进行修订，增加了 Unicode 和多线程的支持。这个版本称为 C11。

（6）C17

C11 标准在2017年进行了修补，但发布是在2018年。新版本只是解决了 C11 的一些缺陷，没有引入任何新功能。这个版本称为 C17。

（7）C2x

标准化组织正在讨论 C 语言的下一个版本，据说可能会在2023年通过，到时就会称为 C23。

C 语言的编译

C 语言是一种编译型语言，源码都是文本文件，本身无法执行。必须通过编译器，生成二进制的可执行文件，才能执行。编译器将代码从文本翻译成二进制指令的过程，就称为编译阶段，又称为“编译时”（compile time），跟运行阶段（又称为“运行时”）相区分。

目前，最常见的 C 语言编译器是自由软件基金会推出的 GCC 编译器，它可以免费使用。本书也使用这个编译器。Linux 和 Mac 系统可以直接安装 GCC，Windows 系统可以安装 MinGW。但是，也可以不用这么麻烦，网上有在线编译器，能够直接在网页上模拟运行 C 代码，查看结果，下面就是两个这样的工具。

CodingGround: https://tutorialspoint.com/compile_c_online.php
OnlineGDB: https://onlinegdb.com/online_c_compiler

本书的例子都使用 GCC 在命令行进行编译。

Hello World 示例

C 语言的源代码文件，通常以后缀名.c结尾。下面是一个简单的 C 程序hello.c。它就是一个普通的文本文件，任何文本编译器都能用来写。

#include <stdio.h>

int main(void) {
  printf("Hello World\n");
  return 0;
}

上面这个程序的唯一作用，就是在屏幕上面显示“Hello World”。

这里不讲解这些代码是什么意思，只是作为一个例子，让大家看看 C 代码应该怎么编译和运行。假设你已经安装好了 GCC 编译器，可以打开命令行，执行下面的命令。

1	gcc hello.c

上面命令使用gcc编译器，将源文件hello.c编译成二进制代码。注意，$是命令行提示符，你真正需要输入的是$后面的部分。

运行这个命令以后，默认会在当前目录下生成一个编译产物文件a.out（assembler output 的缩写，Windows 平台为a.exe）。执行该文件，就会在屏幕上输出Hello World。

1 2	$ ./a.out Hello World

GCC 的-o参数（output 的缩写）可以指定编译产物的文件名。

1	gcc -o hello hello.c

上面命令的-o hello指定，编译产物的文件名为hello（取代默认的a.out）。编译后就会生成一个名叫hello的可执行文件，相当于为a.out指定了名称。执行该文件，也会得到同样的结果。

1 2	$ ./hello Hello World

GCC 的-std=参数（standard 的缩写）还可以指定按照哪个 C 语言的标准进行编译。

1	gcc -std=c99 hello.c

上面命令指定按照 C99 标准进行编译。

注意，-std后面需要用=连接参数，而不是像上面的-o一样用空格，并且=前后也不能有多余的空格。

C 语言基本语法

语句

C 语言的代码由一行行语句（statement）组成。语句就是程序执行的一个操作命令。C 语言规定，语句必须使用分号结尾，除非有明确规定可以不写分号。

1	int x = 1;

上面就是一个变量声明语句，声明整数变量x，并且将值设为1。

多个语句可以写在一行。

1	int x; x = 1;

上面示例是两个语句写在一行。所以，语句之间的换行符并不是必需的，只是为了方便阅读代码。

一个语句也可以写成多行，这时就要依靠分号判断语句在哪一行结束。

int x;
x
=
1
;

上面示例中，第二个语句x = 1;被拆成了四行。编译器会自动忽略代码里面的换行。

单个分号也是有效语句，称为“空语句”，虽然毫无作用。

表达式

C 语言的各种计算，主要通过表达式完成。表达式（expression）是一个计算式，用来获取值。

1 + 2

上面代码就是一个表达式，用来获取1 + 2这个算术计算的结果。

表达式加上分号，也可以成为语句，但是没有实际的作用。

1
2

8;
3 + 4;

上面示例是两个表达式，加上分号以后成为语句。

表达式与语句的区别主要是两点：

语句可以包含表达式，但是表达式本身不构成语句。
表达式都有返回值，语句不一定有。因为语句用来执行某个命令，很多时候不需要返回值，比如变量声明语句（int x = 1）就没有返回值。

语句块

C 语言允许多个语句使用一对大括号{}，组成一个块，也称为复合语句（compounded statement）。在语法上，语句块可以视为多个语句组成的一个复合语句。

{
  int x;
  x = 1;
}

上面示例中，大括号形成了一个语句块。

大括号的结尾不需要添加分号。

空格

C 语言里面的空格，主要用来帮助编译器区分语法单位。如果语法单位不用空格就能区分，空格就不是必须的，只是为了增加代码的可读性。

1
2
3

int x = 1;
// 等同于
int x=1;

上面示例中，赋值号（=）前后有没有空格都可以，因为编译器这里不借助空格，就能区分语法单位。

语法单位之间的多个空格，等同于单个空格。

1	int x = 1;

上面示例中，各个语法单位之间的多个空格，跟单个空格的效果是一样的。

空格还用来表示缩进。多层级的代码有没有缩进，其实对于编译器来说并没有差别，没有缩进的代码也是完全可以运行的。强调代码缩进，只是为了增强代码可读性，便于区分代码块。

大多数 C 语言的风格要求是，下一级代码比上一级缩进4个空格。为了书写的紧凑，本书采用缩写两个空格。

// 缩进四个空格
if (x > 0)
    printf("positive\n");

// 缩进两个空格
if (x > 0)
  printf("positive\n");

只包含空格的行被称为空白行，编译器会完全忽略该行。

注释

注释是对代码的说明，编译器会忽略注释，也就是说，注释对实际代码没有影响。

C 语言的注释有两种表示方法。第一种方法是将注释放在/*...*/之间，内部可以分行。

/* 注释 */

/*
  这是一行注释
*/

这种注释可以插在行内。

1	int open(char* s /* file name */, int mode);

上面示例中，/* file name */用来对函数参数进行说明，跟在它后面的代码依然会有效执行。

这种注释一定不能忘记写结束符号*/，否则很容易导致错误。

printf("a "); /* 注释一
printf("b ");
printf("c "); /* 注释二 */
printf("d ");

上面示例的原意是，第一行和第三行代码的尾部，有两个注释。但是，第一行注释忘记写结束符号，导致注释一延续到第三行结束。

第二种写法是将注释放在双斜杠//后面，从双斜杠到行尾都属于注释。这种注释只能是单行，可以放在行首，也可以放在一行语句的结尾。这是 C99 标准新增的语法。

1
2
3

// 这是一行注释

int x = 1; // 这也是注释

不管是哪一种注释，都不能放在双引号里面。双引号里面的注释符号，会成为字符串的一部分，解释为普通符号，失去注释作用。

1	printf("// hello /* world */ ");

上面示例中，双引号里面的注释符号，都会被视为普通字符，没有注释作用。

编译时，注释会被替换成一个空格，所以min/* space */Value会变成min Value，而不是minValue。

printf()

基本用法

本书的示例会大量用到printf()函数，这里先介绍一下这个函数。

printf()的作用是将参数文本输出到屏幕。它名字里面的f代表format（格式化），表示可以定制输出文本的格式。

1	printf("Hello World");

上面命令会在屏幕上输出一行文字“Hello World”。

printf()不会在行尾自动添加换行符，运行结束后，光标就停留在输出结束的地方，不会自动换行。为了让光标移到下一行的开头，可以在输出文本的结尾，添加一个换行符\n。

1	printf("Hello World\n");

如果文本内部有换行，也是通过插入换行符来实现。

1	printf("Hello\nWorld\n");

上面示例先输出一个Hello，然后换行，在下一行开头输出World，然后又是一个换行。

上面示例也可以写成两个printf()，效果完全一样。

1 2	printf("Hello\n"); printf("World\n");

printf()是在标准库的头文件stdio.h定义的。使用这个函数之前，必须在源码文件头部引入这个头文件。

#include <stdio.h>

int main(void) {
  printf("Hello World\n");
}

上面示例中，只有在源码头部加上#include <stdio.h>，才能使用printf()这个函数。#include指令的详细解释，请看《预处理器》一章。

占位符

printf()可以在输出文本中指定占位符。所谓“占位符”，就是这个位置可以用其他值代入。

1 2	// 输出 There are 3 apples printf("There are %i apples\n", 3);

上面示例中，There are %i apples\n是输出文本，里面的%i就是占位符，表示这个位置要用其他值来替换。占位符的第一个字符一律为百分号%，第二个字符表示占位符的类型，%i表示这里代入的值必须是一个整数。

printf()的第二个参数就是替换占位符的值，上面的例子是整数3替换%i。执行后的输出结果就是There are 3 apples。

常用的占位符除了%i，还有%s表示代入的是字符串。

1	printf("%s will come tonight\n", "Jane");

上面示例中，%s表示代入的是一个字符串，所以printf()的第二个参数就必须是字符串，这个例子是Jane。执行后的输出就是Jane will come tonight。

输出文本里面可以使用多个占位符。

1	printf("%s says it is %i o'clock\n", "Ben", 21);

上面示例中，输出文本%s says it is %i o'clock有两个占位符，第一个是字符串占位符%s，第二个是整数占位符%i，分别对应printf()的第二个参数（Ben）和第三个参数（21）。执行后的输出就是Ben says it is 21 o'clock。

printf()参数与占位符是一一对应关系，如果有n个占位符，printf()的参数就应该有n + 1个。如果参数个数少于对应的占位符，printf()可能会输出内存中的任意值。

printf()的占位符有许多种类，与 C 语言的数据类型相对应。下面按照字母顺序，列出常用的占位符，方便查找，具体含义在后面章节介绍。

%a：浮点数。
%A：浮点数。
%c：字符。
%d：十进制整数。
%e：使用科学计数法的浮点数，指数部分的e为小写。
%E：使用科学计数法的浮点数，指数部分的E为大写。
%i：整数，基本等同于%d。
%f：小数（包含float类型和double类型）。
%g：6个有效数字的浮点数。整数部分一旦超过6位，就会自动转为科学计数法，指数部分的e为小写。
%G：等同于%g，唯一的区别是指数部分的E为大写。
%hd：十进制 short int 类型。
%ho：八进制 short int 类型。
%hx：十六进制 short int 类型。
%hu：unsigned short int 类型。
%ld：十进制 long int 类型。
%lo：八进制 long int 类型。
%lx：十六进制 long int 类型。
%lu：unsigned long int 类型。
%lld：十进制 long long int 类型。
%llo：八进制 long long int 类型。
%llx：十六进制 long long int 类型。
%llu：unsigned long long int 类型。
%Le：科学计数法表示的 long double 类型浮点数。
%Lf：long double 类型浮点数。
%n：已输出的字符串数量。该占位符本身不输出，只将值存储在指定变量之中。
%o：八进制整数。
%p：指针。
%s：字符串。
%u：无符号整数（unsigned int）。
%x：十六进制整数。
%zd：size_t类型。
%%：输出一个百分号。

输出格式

printf()可以定制占位符的输出格式。

（1）限定宽度

printf()允许限定占位符的最小宽度。

1	printf("%5d\n", 123); // 输出为 " 123"

上面示例中，%5d表示这个占位符的宽度至少为5位。如果不满5位，对应的值的前面会添加空格。

输出的值默认是右对齐，即输出内容前面会有空格；如果希望改成左对齐，在输出内容后面添加空格，可以在占位符的%的后面插入一个-号。

1	printf("%-5d\n", 123); // 输出为 "123 "

上面示例中，输出内容123的后面添加了空格。

对于小数，这个限定符会限制所有数字的最小显示宽度。

1 2	// 输出 " 123.450000" printf("%12f\n", 123.45);

上面示例中，%12f表示输出的浮点数最少要占据12位。由于小数的默认显示精度是小数点后6位，所以123.45输出结果的头部会添加2个空格。

（2）总是显示正负号

默认情况下，printf()不对正数显示+号，只对负数显示-号。如果想让正数也输出+号，可以在占位符的%后面加一个+。

1 2	printf("%+d\n", 12); // 输出 +12 printf("%+d\n", -12); // 输出 -12

上面示例中，%+d可以确保输出的数值，总是带有正负号。

（3）限定小数位数

输出小数时，有时希望限定小数的位数。举例来说，希望小数点后面只保留两位，占位符可以写成%.2f。

1 2	// 输出 Number is 0.50 printf("Number is %.2f\n", 0.5);

上面示例中，如果希望小数点后面输出3位（0.500），占位符就要写成%.3f。

这种写法可以与限定宽度占位符，结合使用。

1 2	// 输出为 " 0.50" printf("%6.2f\n", 0.5);

上面示例中，%6.2f表示输出字符串最小宽度为6，小数位数为2。所以，输出字符串的头部有两个空格。

最小宽度和小数位数这两个限定值，都可以用*代替，通过printf()的参数传入。

printf("%*.*f\n", 6, 2, 0.5);

// 等同于
printf("%6.2f\n", 0.5);

上面示例中，%*.*f的两个星号通过printf()的两个参数6和2传入。

（4）输出部分字符串

%s占位符用来输出字符串，默认是全部输出。如果只想输出开头的部分，可以用%.[m]s指定输出的长度，其中[m]代表一个数字，表示所要输出的长度。

1 2	// 输出 hello printf("%.5s\n", "hello world");

上面示例中，占位符%.5s表示只输出字符串“hello world”的前5个字符，即“hello”。

标准库，头文件

程序需要用到的功能，不一定需要自己编写，C 语言可能已经自带了。程序员只要去调用这些自带的功能，就省得自己编写代码了。举例来说，printf()这个函数就是 C 语言自带的，只要去调用它，就能实现在屏幕上输出内容。

C 语言自带的所有这些功能，统称为“标准库”（standard library），因为它们是写入标准的，到底包括哪些功能，应该怎么使用的，都是规定好的，这样才能保证代码的规范和可移植。

不同的功能定义在不同的文件里面，这些文件统称为“头文件”（header file）。如果系统自带某一个功能，就一定还会自带描述这个功能的头文件，比如printf()的头文件就是系统自带的stdio.h。头文件的后缀通常是.h。

如果要使用某个功能，就必须先加载对应的头文件，加载使用的是#include命令。这就是为什么使用printf()之前，必须先加载stdio.h的原因。

1	#include <stdio.h>

注意，加载头文件的#include语句不需要分号结尾，详见《预处理器》一章。

变量

变量（variable）可以理解成一块内存区域的名字。通过变量名，可以引用这块内存区域，获取里面存储的值。由于值可能发生变化，所以称为变量，否则就是常量了。

变量名

变量名在 C 语言里面属于标识符（identifier），命名有严格的规范。

只能由字母（包括大写和小写）、数字和下划线（_）组成。
不能以数字开头。
长度不能超过63个字符。

下面是一些无效变量名的例子。

$zj
j**p
2cat
Hot-tab
tax rate
don't

上面示例中，每一行的变量名都是无效的。

变量名区分大小写，star、Star、STAR都是不同的变量。

并非所有的词都能用作变量名，有些词在 C 语言里面有特殊含义（比如int），另一些词是命令（比如continue），它们都称为关键字，不能用作变量名。另外，C 语言还保留了一些词，供未来使用，这些保留字也不能用作变量名。下面就是 C 语言主要的关键字和保留字。

auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, inline, int, long, register, restrict, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while

另外，两个下划线开头的变量名，以及一个下划线 + 大写英文字母开头的变量名，都是系统保留的，自己不应该起这样的变量名。

变量的声明

C 语言的变量，必须先声明后使用。如果一个变量没有声明，就直接使用，会报错。

每个变量都有自己的类型（type）。声明变量时，必须把变量的类型告诉编译器。

1	int height;

上面代码声明了变量height，并且指定类型为int（整数）。

如果几个变量具有相同类型，可以在同一行声明。

int height, width;

// 等同于
int height;
int width;

注意，声明变量的语句必须以分号结尾。

一旦声明，变量的类型就不能在运行时修改。

变量的赋值

C 语言会在变量声明时，就为它分配内存空间，但是不会清除内存里面原来的值。这导致声明变量以后，变量会是一个随机的值。所以，变量一定要赋值以后才能使用。

赋值操作通过赋值运算符（=）完成。

1 2	int num; num = 42;

上面示例中，第一行声明了一个整数变量num，第二行给这个变量赋值。

变量的值应该与类型一致，不应该赋予不是同一个类型的值，比如num的类型是整数，就不应该赋值为小数。虽然 C 语言会自动转换类型，但是应该避免赋值运算符两侧的类型不一致。

变量的声明和赋值，也可以写在一行。

1	int num = 42;

多个相同类型变量的赋值，可以写在同一行。

1	int x = 1, y = 2;

注意，赋值表达式有返回值，等于等号右边的值。

int x, y;

x = 1;
y = (x = 2 * x);

上面代码中，变量y的值就是赋值表达式（x = 2 * x）的返回值2。

由于赋值表达式有返回值，所以 C 语言可以写出多重赋值表达式。

1
2
3

int x, y, z, m, n;

x = y = z = m = n = 3;

上面的代码是合法代码，一次为多个变量赋值。赋值运算符是从右到左执行，所以先为n赋值，然后依次为m、z、y和x赋值。

C 语言有左值（left value）和右值（right value）的概念。左值是可以放在赋值运算符左边的值，一般是变量；右值是可以放在赋值运算符右边的值，一般是一个具体的值。这是为了强调有些值不能放在赋值运算符的左边，比如x = 1是合法的表达式，但是1 = x就会报错。

变量的作用域

作用域（scope）指的是变量生效的范围。C 语言的变量作用域主要有两种：文件作用域（file scope）和块作用域（block scope）。

文件作用域（file scope）指的是，在源码文件顶层声明的变量，从声明的位置到文件结束都有效。

int x = 1;

int main(void) {
  printf("%i\n", x);
}

上面示例中，变量x是在文件顶层声明的，从声明位置开始的整个当前文件都是它的作用域，可以在这个范围的任何地方读取这个变量，比如函数main()内部就可以读取这个变量。

块作用域（block scope）指的是由大括号（{}）组成的代码块，它形成一个单独的作用域。凡是在块作用域里面声明的变量，只在当前代码块有效，代码块外部不可见。

int a = 12;

if (a == 12) {
  int b = 99;
  printf("%d %d\n", a, b);  // 12 99
}

printf("%d\n", a);  // 12
printf("%d\n", b);  // 出错

上面例子中，变量b是在if代码块里面声明的，所以对于大括号外面的代码，这个变量是不存在的。

代码块可以嵌套，即代码块内部还有代码块，这时就形成了多层的块作用域。它的规则是：内层代码块可以使用外层声明的变量，但外层不可以使用内层声明的变量。如果内层的变量与外层同名，那么会在当前作用域覆盖外层变量。

{
  int i = 10;

  {
    int i = 20;
    printf("%d\n", i);  // 20
  }

  printf("%d\n", i);  // 10
}

上面示例中，内层和外层都有一个变量i，每个作用域都会优先使用当前作用域声明的i。

最常见的块作用域就是函数，函数内部声明的变量，对于函数外部是不可见的。for循环也是一个块作用域，循环变量只对循环体内部可见，外部是不可见的。

for (int i = 0; i < 10; i++)
  printf("%d\n", i);

printf("%d\n", i); // 出错

上面示例中，for循环省略了大括号，但依然是一个块作用域，在外部读取循环变量i，编译器就会报错。

运算符

C 语言的运算符非常多，一共有 50 多种，可以分成若干类。

算术运算符

算术运算符专门用于算术运算，主要有下面几种。

+：正值运算符（一元运算符）
-：负值运算符（一元运算符）
+：加法运算符（二元运算符）
-：减法运算符（二元运算符）
*：乘法运算符
/：除法运算符
%：余值运算符

（1）+，-

+和-既可以作为一元运算符，也可以作为二元运算符。所谓“一元运算符”，指的是只需要一个运算数就可以执行。一元运算符-用来改变一个值的正负号。

1	int x = -12;

上面示例中，-将12这个值变成-12。

一元运算符+对正负值没有影响，是一个完全可以省略的运算符，但是写了也不会报错。

1 2	int x = -12; int y = +x;

上面示例中，变量y的值还是-12，因为+不会改变正负值。

二元运算符+和-用来完成加法和减法。

1 2	int x = 4 + 22; int y = 61 - 23;

（2）*

运算符*用来完成乘法。

1 2	int num = 5; printf("%i\n", num * num); // 输出 25

（3）/

运算符/用来完成除法。注意，两个整数相除，得到还是一个整数。

1 2	float x = 6 / 4; printf("%f\n", x); // 输出 1.000000

上面示例中，尽管变量x的类型是float（浮点数），但是6 / 4得到的结果是1.0，而不是1.5。原因就在于 C 语言里面的整数除法是整除，只会返回整数部分，丢弃小数部分。

如果希望得到浮点数的结果，两个运算数必须至少有一个浮点数，这时 C 语言就会进行浮点数除法。

1 2	float x = 6.0 / 4; // 或者写成 6 / 4.0 printf("%f\n", x); // 输出 1.500000

上面示例中，6.0 / 4表示进行浮点数除法，得到的结果就是1.5。

下面是另一个例子。

1 2	int score = 5; score = (score / 20) * 100;

上面的代码，你可能觉得经过运算，score会等于25，但是实际上score等于0。这是因为score / 20是整除，会得到一个整数值0，所以乘以100后得到的也是0。

为了得到预想的结果，可以将除数20改成20.0，让整除变成浮点数除法。

1	score = (score / 20.0) * 100;

（4）%

运算符%表示求模运算，即返回两个整数相除的余值。这个运算符只能用于整数，不能用于浮点数。

1	int x = 6 % 4; // 2

负数求模的规则是，结果的正负号由第一个运算数的正负号决定。

1
2
3

11 % -5 // 1
-11 % -5 // -1
-11 % 5 // -1

上面示例中，第一个运算数的正负号（11或-11）决定了结果的正负号。

（5）赋值运算的简写形式

如果变量对自身的值进行算术运算，C 语言提供了简写形式，允许将赋值运算符和算术运算符结合成一个运算符。

+=
-=
*=
/=
%=

下面是一些例子。

i += 3;  // 等同于 i = i + 3
i -= 8;  // 等同于 i = i - 8
i *= 9;  // 等同于 i = i * 9
i /= 2;  // 等同于 i = i / 2
i %= 5;  // 等同于 i = i % 5

自增运算符，自减运算符

C 语言提供两个运算符，对变量自身进行+ 1和- 1的操作。

++：自增运算符
--：自减运算符

1 2	i++; // 等同于 i = i + 1 i--; // 等同于 i = i - 1

这两个运算符放在变量的前面或后面，结果是不一样的。++var和--var是先执行自增或自减操作，再返回操作后var的值；var++和var--则是先返回操作前var的值，再执行自增或自减操作。

int i = 42;
int j;

j = (i++ + 10);
// i: 43
// j: 52

j = (++i + 10)
// i: 44
// j: 54

上面示例中，自增运算符的位置差异，会导致变量j得到不同的值。这样的写法很容易出现意料之外的结果，为了消除意外，可以改用下面的写法。

/* 写法一 */
j = (i + 10);
i++;

/* 写法二 */
i++;
j = (i + 10);

上面示例中，变量i的自增运算与返回值是分离的两个步骤，这样就不太会出错，也提高了代码的可读性。

关系运算符

C 语言用于比较的表达式，称为“关系表达式”（relational expression），里面使用的运算符就称为“关系运算符”（relational operator），主要有下面6个。

> 大于运算符
< 小于运算符
>= 大于等于运算符
<= 小于等于运算符
== 相等运算符
!= 不相等运算符

下面是一些例子。

a == b;
a != b;
a < b;
a > b;
a <= b;
a >= b;

关系表达式通常返回0或1，表示真伪。C 语言中，0表示伪，所有非零值表示真。比如，20 > 12返回1，12 > 20返回0。

关系表达式常用于if或while结构。

1
2
3

if (x == 3) {
  printf("x is 3.\n");
}

注意，相等运算符==与赋值运算符=是两个不一样的运算符，不要混淆。有时候，可能会不小心写出下面的代码，它可以运行，但很容易出现意料之外的结果。

1	if (x = 3) ...

上面示例中，原意是x == 3，但是不小心写成x = 3。这个式子表示对变量x赋值3，它的返回值为3，所以if判断总是为真。

为了防止出现这种错误，有的程序员喜欢将变量写在等号的右边。

1	if (3 == x) ...

这样的话，如果把==误写成=，编译器就会报错。

1 2	/* 报错 */ if (3 = x) ...

另一个需要避免的错误是，多个关系运算符不宜连用。

i < j < k

上面示例中，连续使用两个小于运算符。这是合法表达式，不会报错，但是通常达不到想要的结果，即不是保证变量j的值在i和k之间。因为关系运算符是从左到右计算，所以实际执行的是下面的表达式。

1	(i < j) < k

上面式子中，i < j返回0或1，所以最终是0或1与变量k进行比较。如果想要判断变量j的值是否在i和k之间，应该使用下面的写法。

1	i < j && j < k

逻辑运算符

逻辑运算符提供逻辑判断功能，用于构建更复杂的表达式，主要有下面三个运算符。

!：否运算符（改变单个表达式的真伪）。
&&：与运算符（两侧的表达式都为真，则为真，否则为伪）。
||：或运算符（两侧至少有一个表达式为真，则为真，否则为伪）。

下面是与运算符的例子。

1 2	if (x < 10 && y > 20) printf("Doing something!\n");

上面示例中，只有x < 10和y > 20同时为真，x < 10 && y > 20才会为真。

下面是否运算符的例子。

1 2	if (!(x < 12)) printf("x is not less than 12\n");

上面示例中，由于否运算符!具有比<更高的优先级，所以必须使用括号，才能对表达式x < 12进行否运算。当然，合理的写法是if (x >= 12)，这里只是为了举例。

对于逻辑运算符来说，任何非零值都表示真，零值表示伪。比如，5 || 0会返回1，5 && 0会返回0。

逻辑运算符还有一个特点，它总是先对左侧的表达式求值，再对右边的表达式求值，这个顺序是保证的。如果左边的表达式满足逻辑运算符的条件，就不再对右边的表达式求值。这种情况称为“短路”。

1	if (number != 0 && 12/number == 2)

上面示例中，如果&&左侧的表达式（number != 0）为伪，即number等于0时，右侧的表达式（12/number == 2）是不会执行的。因为这时左侧表达式返回0，整个&&表达式肯定为伪，就直接返回0，不再执行右侧的表达式了。

由于逻辑运算符的执行顺序是先左后右，所以下面的代码是有问题的。

1	while ((x++ < 10) && (x + y < 20))

上面示例中，执行左侧表达式后，变量x的值就已经变了。等到执行右侧表达式的时候，是用新的值在计算，这通常不是原始意图。

位运算符

C 语言提供一些位运算符，用来操作二进制位（bit）。

（1）取反运算符～

取反运算符～是一个一元运算符，用来将每一个二进制位变成相反值，即0变成1，1变成0。

1 2	// 返回 01101100 ~ 10010011

上面示例中，~对每个二进制位取反，就得到了一个新的值。

注意，~运算符不会改变变量的值，只是返回一个新的值。

（2）与运算符&

与运算符&将两个值的每一个二进制位进行比较，返回一个新的值。当两个二进制位都为1，就返回1，否则返回0。

1 2	// 返回 00010001 10010011 & 00111101

上面示例中，两个八位二进制数进行逐位比较，返回一个新的值。

与运算符&可以与赋值运算符=结合，简写成&=。

int val = 3;
val = val & 0377;

// 简写成
val &= 0377;

（3）或运算符|

或运算符|将两个值的每一个二进制位进行比较，返回一个新的值。两个二进制位只要有一个为1（包含两个都为1的情况），就返回1，否则返回0。

1 2	// 返回 10111111 10010011 \| 00111101

或运算符|可以与赋值运算符=结合，简写成|=。

int val = 3;
val = val | 0377;

// 简写为
val |= 0377;

（4）异或运算符^

异或运算符^将两个值的每一个二进制位进行比较，返回一个新的值。两个二进制位有且仅有一个为1，就返回1，否则返回0。

1 2	// 返回 10101110 10010011 ^ 00111101

异或运算符^可以与赋值运算符=结合，简写成^=。

int val = 3;
val = val ^ 0377;

// 简写为
val ^= 0377;

（5）左移运算符<<

左移运算符<<将左侧运算数的每一位，向左移动指定的位数，尾部空出来的位置使用0填充。

1 2	// 1000101000 10001010 << 2

上面示例中，10001010的每一个二进制位，都向左侧移动了两位。

左移运算符相当于将运算数乘以2的指定次方，比如左移2位相当于乘以4（2的2次方）。

左移运算符<<可以与赋值运算符=结合，简写成<<=。

int val = 1;
val = val << 2;

// 简写为
val <<= 2;

（6）右移运算符>>

右移运算符>>将左侧运算数的每一位，向右移动指定的位数，尾部无法容纳的值将丢弃，头部空出来的位置使用0填充。

1 2	// 返回 00100010 10001010 >> 2

上面示例中，10001010的每一个二进制位，都向右移动两位。最低的两位10被丢弃，头部多出来的两位补0，所以最后得到00100010。

注意，右移运算符最好只用于无符号整数，不要用于负数。因为不同系统对于右移后如何处理负数的符号位，有不同的做法，可能会得到不一样的结果。

右移运算符相当于将运算数除以2的指定次方，比如右移2位就相当于除以4（2的2次方）。

右移运算符>>可以与赋值运算符=结合，简写成>>=。

int val = 1;
val = val >> 2;

// 简写为
val >>= 2;

逗号运算符

逗号运算符用于将多个表达式写在一起，从左到右依次运行每个表达式。

1	x = 10, y = 20;

上面示例中，有两个表达式（x = 10和y = 20），逗号使得它们可以放在同一条语句里面。

逗号运算符返回最后一个表达式的值，作为整个语句的值。

1 2	int x; x = 1, 2, 3;

上面示例中，逗号的优先级低于赋值运算符，所以先执行赋值运算，再执行逗号运算，变量x等于1。

运算优先级

优先级指的是，如果一个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不一样的。

1	3 + 4 * 5;

上面示例中，表达式3 + 4 * 5里面既有加法运算符（+），又有乘法运算符（*）。由于乘法的优先级高于加法，所以会先计算4 * 5，而不是先计算3 + 4。

如果两个运算符优先级相同，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（=）。

1	5 * 6 / 2;

上面示例中，*和/的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算5 * 6，再计算6 / 2。

运算符的优先级顺序很复杂。下面是部分运算符的优先级顺序（按照优先级从高到低排列）。

圆括号（()）
自增运算符（++），自减运算符（--）
一元运算符（+和-）
乘法（*），除法（/）
加法（+），减法（-）
关系运算符（<、>等）
赋值运算符（=）

由于圆括号的优先级最高，可以使用它改变其他运算符的优先级。

1	int x = (3 + 4) * 5;

上面示例中，由于添加了圆括号，加法会先于乘法进行运算。

完全记住所有运算符的优先级没有必要，解决方法是多用圆括号，防止出现意料之外的情况，也有利于提高代码的可读性。

流程控制

C 语言的程序是顺序执行，即先执行前面的语句，再执行后面的语句。开发者如果想要控制程序执行的流程，就必须使用流程控制的语法结构，主要是条件执行和循环执行。

if 语句

if语句用于条件判断，满足条件时，就执行指定的语句。

1	if (expression) statement

上面式子中，表达式expression为真（值不为0）时，就执行statement语句。

if后面的判断条件expression外面必须有圆括号，否则会报错。语句体部分statement可以是一个语句，也可以是放在大括号里面的复合语句。下面是一个例子。

1	if (x == 10) printf("x is 10");

上面示例中，当变量x为10时，就会输出一行文字。对于只有一个语句的语句体，语句部分通常另起一行。

1 2	if (x == 10) printf("x is 10\n");

如果有多条语句，就需要把它们放在大括号里面，组成一个复合语句。

if (line_num == MAX_LINES) {
  line_num = 0;
  page_num++;
}

if语句可以带有else分支，指定条件不成立时（表达式expression的值为0），所要执行的代码。

1 2	if (expression) statement else statement

下面是一个例子。

if (i > j)
  max = i;
else
  max = j;

如果else的语句部分多于一行，同样可以把它们放在大括号里面。

else可以与另一个if语句连用，构成多重判断。

if (expression)
  statement
else if (expression)
  statement
...
else if (expression)
  statement
else
  statement

如果有多个if和else，可以记住这样一条规则，else总是跟最接近的if匹配。

if (number > 6)
  if (number < 12)
    printf("The number is more than 6, less than 12.\n");
else
  printf("It is wrong number.\n");

上面示例中，else部分匹配最近的if（即number < 12），所以如果number等于6，就不会执行else的部分。

这样很容易出错，为了提供代码的可读性，建议使用大括号，明确else匹配哪一个if。

if (number > 6) {
  if (number < 12) {
    printf("The number is more than 6, less than 12.\n");
  }
} else {
  printf("It is wrong number.\n");
}

上面示例中，使用了大括号，就可以清晰地看出else匹配外层的if。

三元运算符 ?

C 语言有一个三元表达式?:，可以用作if...else的简写形式。

1	<expression1> ? <expression2> : <expression3>

这个操作符的含义是，表达式expression1如果为true（非0值），就执行expression2，否则执行expression3。

下面是一个例子，返回两个值之中的较大值。

1	(i > j) ? i : j;

上面的代码等同于下面的if语句。

if (i > j)
  return i;
else
  return j;

switch 语句

switch 语句是一种特殊形式的 if…else 结构，用于判断条件有多个结果的情况。它把多重的else if改成更易用、可读性更好的形式。

switch (expression) {
  case value1: statement
  case value2: statement
  default: statement
}

上面代码中，根据表达式expression不同的值，执行相应的case分支。如果找不到对应的值，就执行default分支。

下面是一个例子。

switch (grade) {
  case 0:
    printf("False");
    break;
  case 1:
    printf("True");
    break;
  default:
    printf("Illegal");
}

上面示例中，根据变量grade不同的值，会执行不同的case分支。如果等于0，执行case 0的部分；如果等于1，执行case 1的部分；否则，执行default的部分。default表示处理以上所有case都不匹配的情况。

每个case语句体的结尾，都应该有一个break语句，作用是跳出整个switch结构，不再往下执行。如果缺少break，就会导致继续执行下一个case或default分支。

switch (grade) {
  case 0:
    printf("False");
  case 1:
    printf("True");
    break;
  default:
    printf("Illegal");
}

上面示例中，case 0的部分没有break语句，导致这个分支执行完以后，不会跳出switch结构，继续执行case 1分支。

利用这个特点，如果多个case分支对应同样的语句体，可以写成下面这样。

switch (grade) {
  case 0:
  case 1:
    printf("True");
    break;
  default:
    printf("Illegal");
}

上面示例中，case 0分支没有任何语句，导致case 0和case 1都会执行同样的语句体。

case后面的语句体，不用放在大括号里面，这也是为什么需要break的原因。

default分支用来处理前面的 case 都不匹配的情况，最好放在所有 case 的后面，这样就不用写break语句。这个分支是可选的，如果没有该分支，遇到所有的 case 都不匹配的情况，就会直接跳出整个 switch 代码块。

while 语句

while语句用于循环结构，满足条件时，不断执行循环体。

1 2	while (expression) statement

上面代码中，如果表达式expression为非零值（表示真），就会执行statement语句，然后再次判断expression是否为零；如果expression为零（表示伪）就跳出循环，不再执行循环体。

1 2	while (i < n) i = i + 2;

上面示例中，只要i小于n，i就会不断增加2。

如果循环体有多个语句，就需要使用大括号将这些语句组合在一起。

while (expression) {
  statement;
  statement;
}

下面是一个例子。

i = 0;

while (i < 10) {
  printf("i is now %d!\n", i);
  i++;
}

printf("All done!\n");

上面代码中，循环体会执行10次，每次将i增加1，直到等于10才退出循环。

只要条件为真，while会产生无限循环。下面是一种常见的无限循环的写法。

1
2
3

while (1) {
  // ...
}

上面的示例虽然是无限循环，但是循环体内部可以用break语句跳出循环。

do…while 结构

do...while结构是while的变体，它会先执行一次循环体，然后再判断是否满足条件。如果满足的话，就继续执行循环体，否则跳出循环。

1 2	do statement while (expression);

上面代码中，不管条件expression是否成立，循环体statement至少会执行一次。每次statement执行完毕，就会判断一次expression，决定是否结束循环。

i = 10;

do --i;
while (i > 0);

上面示例中，变量i先减去1，再判断是否大于0。如果大于0，就继续减去1，直到i等于0为止。

如果循环部分有多条语句，就需要放在大括号里面。

i = 10;

do {
  printf("i is %d\n", i);
  i++;
} while (i < 10);

printf("All done!\n");

上面例子中，变量i并不满足小于10的条件，但是循环体还是会执行一次。

for 语句

for语句是最常用的循环结构，通常用于精确控制循环次数。

1 2	for (initialization; continuation; action) statement;

上面代码中，for语句的条件部分（即圆括号里面的部分）有三个表达式。

initialization：初始化表达式，用于初始化循环变量，只执行一次。
continuation：判断表达式，只要为true，就会不断执行循环体。
action：循环变量处理表达式，每轮循环结束后执行，使得循环变量发生变化。

循环体部分的statement可以是一条语句，也可以是放在大括号里面的复合语句。下面是一个例子。

1 2	for (int i = 10; i > 0; i--) printf("i is %d\n", i);

上面示例中，循环变量i在for的第一个表达式里面声明，该变量只用于本次循环。离开循环体之后，就会失效。

条件部分的三个表达式，每一个都可以有多个语句，语句与语句之间使用逗号分隔。

int i, j;
for (i = 0, j = 999; i < 10; i++, j--) {
  printf("%d, %d\n", i, j);
}

上面示例中，初始化部分有两个语句，分别对变量i和j进行赋值。

for的三个表达式都不是必需的，甚至可以全部省略，这会形成无限循环。

1
2
3

for (;;) {
  printf("本行会无限循环地打印。\n" );
}

上面示例由于没有判断条件，就会形成无限循环。

break 语句

break语句有两种用法。一种是与switch语句配套使用，用来中断某个分支的执行，这种用法前面已经介绍过了。另一种用法是在循环体内部跳出循环，不再进行后面的循环了。

for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    printf("%d, %d\n", i, j);
    break;
  }
}

上面示例中，break语句使得循环跳到下一个i。

while ((ch = getchar()) != EOF) {
  if (ch == '\n') break;
  putchar(ch);
}

上面示例中，一旦读到换行符（\n），break命令就跳出整个while循环，不再继续读取了。

注意，break命令只能跳出循环体和switch结构，不能跳出if结构。

if (n > 1) {
  if (n > 2) break; // 无效
  printf("hello\n");
}

上面示例中，break语句是无效的，因为它不能跳出外层的if结构。

continue 语句

continue语句用于在循环体内部终止本轮循环，进入下一轮循环。只要遇到continue语句，循环体内部后面的语句就不执行了，回到循环体的头部，开始执行下一轮循环。

for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    printf("%d, %d\n", i, j);
    continue;
  }
}

上面示例中，有没有continue语句，效果一样，都表示跳到下一个j。

while ((ch = getchar()) != '\n') {
  if (ch == '\t') continue;
  putchar(ch);
}

上面示例中，只要读到的字符是制表符（\t），就用continue语句跳过该字符，读取下一个字符。

goto 语句

goto 语句用于跳到指定的标签名。这会破坏结构化编程，建议不要轻易使用，这里为了语法的完整，介绍一下它的用法。

char ch;

top: ch = getchar();

if (ch == 'q')
  goto top;

上面示例中，top是一个标签名，可以放在正常语句的前面，相当于为这行语句做了一个标记。程序执行到goto语句，就会跳转到它指定的标签名。

1
2
3

infinite_loop:
  print("Hello, world!\n");
  goto infinite_loop;

上面的代码会产生无限循环。

goto 的一个主要用法是跳出多层循环。

for(...) {
  for (...) {
    while (...) {
      do {
        if (some_error_condition)
          goto bail;    
      } while(...);
    }
  }
}
    
bail:
// ... ...

上面代码有很复杂的嵌套循环，不使用 goto 的话，想要完全跳出所有循环，写起来很麻烦。

goto 的另一个用途是提早结束多重判断。

if (do_something() == ERR)
  goto error;
if (do_something2() == ERR)
  goto error;
if (do_something3() == ERR)
  goto error;
if (do_something4() == ERR)
  goto error;

上面示例有四个判断，只要有一个发现错误，就使用 goto 跳过后面的判断。

注意，goto 只能在同一个函数之中跳转，并不能跳转到其他函数。

数据类型

C 语言的每一种数据，都是有类型（type）的，编译器必须知道数据的类型，才能操作数据。所谓“类型”，就是相似的数据所拥有的共同特征，那么一旦知道某个值的数据类型，就能知道该值的特征和操作方式。

基本数据类型有三种：字符（char）、整数（int）和浮点数（float）。复杂的类型都是基于它们构建的。

字符类型

字符类型指的是单个字符，类型声明使用char关键字。

1	char c = 'B';

上面示例声明了变量c是字符类型，并将其赋值为字母B。

C 语言规定，字符常量必须放在单引号里面。

在计算机内部，字符类型使用一个字节（8位）存储。C 语言将其当作整数处理，所以字符类型就是宽度为一个字节的整数。每个字符对应一个整数（由 ASCII 码确定），比如B对应整数66。

字符类型在不同计算机的默认范围是不一样的。一些系统默认为-128到127，另一些系统默认为0到255。这两种范围正好都能覆盖0到127的 ASCII 字符范围。

只要在字符类型的范围之内，整数与字符是可以互换的，都可以赋值给字符类型的变量。

1
2
3

char c = 66;
// 等同于
char c = 'B';

上面示例中，变量c是字符类型，赋给它的值是整数66。这跟赋值为字符B的效果是一样的。

两个字符类型的变量可以进行数学运算。

char a = 'B'; // 等同于 char a = 66;
char b = 'C'; // 等同于 char b = 67;

printf("%d\n", a + b); // 输出 133

上面示例中，字符类型变量a和b相加，视同两个整数相加。占位符%d表示输出十进制整数，因此输出结果为133。

单引号本身也是一个字符，如果要表示这个字符常量，必须使用反斜杠转义。

1	char t = '\'';

上面示例中，变量t为单引号字符，由于字符常量必须放在单引号里面，所以内部的单引号要使用反斜杠转义。

这种转义的写法，主要用来表示 ASCII 码定义的一些无法打印的控制字符，它们也属于字符类型的值。

\a：警报，这会使得终端发出警报声或出现闪烁，或者两者同时发生。
\b：退格键，光标回退一个字符，但不删除字符。
\f：换页符，光标移到下一页。在现代系统上，这已经反映不出来了，行为改成类似于\v。
\n：换行符。
\r：回车符，光标移到同一行的开头。
\t：制表符，光标移到下一个水平制表位，通常是下一个8的倍数。
\v：垂直分隔符，光标移到下一个垂直制表位，通常是下一行的同一列。
\0：null 字符，代表没有内容。注意，这个值不等于数字0。

转义写法还能使用八进制和十六进制表示一个字符。

\nn：字符的八进制写法，nn为八进制值。
\xnn：字符的十六进制写法，nn为十六进制值。

char x = 'B';
char x = 66;
char x = '\102'; // 八进制
char x = '\x42'; // 十六进制

上面示例的四种写法都是等价的。

整数类型

简介

整数类型用来表示较大的整数，类型声明使用int关键字。

int a;

上面示例声明了一个整数变量a。

不同计算机的int类型的大小是不一样的。比较常见的是使用4个字节（32位）存储一个int类型的值，但是2个字节（16位）或8个字节（64位）也有可能使用。它们可以表示的整数范围如下。

16位：-32,768 到 32,767。
32位：-2,147,483,648 到 2,147,483,647。
64位：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。

signed，unsigned

C 语言使用signed关键字，表示一个类型带有正负号，包含负值；使用unsigned关键字，表示该类型不带有正负号，只能表示零和正整数。

对于int类型，默认是带有正负号的，也就是说int等同于signed int。由于这是默认情况，关键字signed一般都省略不写，但是写了也不算错。

1
2
3

signed int a;
// 等同于
int a;

int类型也可以不带正负号，只表示非负整数。这时就必须使用关键字unsigned声明变量。

1	unsigned int a;

整数变量声明为unsigned的好处是，同样长度的内存能够表示的最大整数值，增大了一倍。比如，16位的signed int最大值为32,767，而unsigned int的最大值增大到了65,535。

unsigned int里面的int可以省略，所以上面的变量声明也可以写成下面这样。

1	unsigned a;

字符类型char也可以设置signed和unsigned。

1 2	signed char c; // 范围为 -128 到 127 unsigned char c; // 范围为 0 到 255

注意，C 语言规定char类型默认是否带有正负号，由当前系统决定。这就是说，char不等同于signed char，它有可能是signed char，也有可能是unsigned char。这一点与int不同，int就是等同于signed int。

整数的子类型

如果int类型使用4个或8个字节表示一个整数，对于小整数，这样做很浪费空间。另一方面，某些场合需要更大的整数，8个字节还不够。为了解决这些问题，C 语言在int类型之外，又提供了三个整数的子类型。这样有利于更精细地限定整数变量的范围，也有利于更好地表达代码的意图。

short int（简写为short）：占用空间不多于int，一般占用2个字节（整数范围为-32768～32767)。
long int（简写为long）：占用空间不少于int，至少为4个字节。
long long int（简写为long long）：占用空间多于long，至少为8个字节。

1
2
3

short int a;
long int b;
long long int c;

上面代码分别声明了三种整数子类型的变量。

默认情况下，short、long、long long都是带符号的（signed），即signed关键字省略了。它们也可以声明为不带符号（unsigned），使得能够表示的最大值扩大一倍。

1
2
3

unsigned short int a;
unsigned long int b;
unsigned long long int c;

C 语言允许省略int，所以变量声明语句也可以写成下面这样。

short a;
unsigned short a;

long b;
unsigned long b;

long long c;
unsigned long long c;

不同的计算机，数据类型的字节长度是不一样的。确实需要32位整数时，应使用long类型而不是int类型，可以确保不少于4个字节；确实需要64位的整数时，应该使用long long类型，可以确保不少于8个字节。另一方面，为了节省空间，只需要16位整数时，应使用short类型；需要8位整数时，应该使用char类型。

整数类型的极限值

有时候需要查看，当前系统不同整数类型的最大值和最小值，C 语言的头文件limits.h提供了相应的常量，比如SCHAR_MIN代表 signed char 类型的最小值-128，SCHAR_MAX代表 signed char 类型的最大值127。

为了代码的可移植性，需要知道某种整数类型的极限值时，应该尽量使用这些常量。

SCHAR_MIN，SCHAR_MAX：signed char 的最小值和最大值。
SHRT_MIN，SHRT_MAX：short 的最小值和最大值。
INT_MIN，INT_MAX：int 的最小值和最大值。
LONG_MIN，LONG_MAX：long 的最小值和最大值。
LLONG_MIN，LLONG_MAX：long long 的最小值和最大值。
UCHAR_MAX：unsigned char 的最大值。
USHRT_MAX：unsigned short 的最大值。
UINT_MAX：unsigned int 的最大值。
ULONG_MAX：unsigned long 的最大值。
ULLONG_MAX：unsigned long long 的最大值。

整数的进制

C 语言的整数默认都是十进制数，如果要表示八进制数和十六进制数，必须使用专门的表示法。

八进制使用0作为前缀，比如017、0377。

1	int a = 012; // 八进制，相当于十进制的10

十六进制使用0x或0X作为前缀，比如0xf、0X10。

1	int a = 0x1A2B; // 十六进制，相当于十进制的6699

有些编译器使用0b前缀，表示二进制数，但不是标准。

1	int x = 0b101010;

注意，不同的进制只是整数的书写方法，不会对整数的实际存储方式产生影响。所有整数都是二进制形式存储，跟书写方式无关。不同进制可以混合使用，比如10 + 015 + 0x20是一个合法的表达式。

printf()的进制相关占位符如下。

%d：十进制整数。
%o：八进制整数。
%x：十六进制整数。
%#o：显示前缀0的八进制整数。
%#x：显示前缀0x的十六进制整数。
%#X：显示前缀0X的十六进制整数。

int x = 100;
printf("dec = %d\n", x); // 100
printf("octal = %o\n", x); // 144
printf("hex = %x\n", x); // 64
printf("octal = %#o\n", x); // 0144
printf("hex = %#x\n", x); // 0x64
printf("hex = %#X\n", x); // 0X64

浮点数类型

任何有小数点的数值，都会被编译器解释为浮点数。所谓“浮点数”就是使用 m * b^e 的形式，存储一个数值，m是小数部分，b是基数（通常是2），e是指数部分。这种形式是精度和数值范围的一种结合，可以表示非常大或者非常小的数。

浮点数的类型声明使用float关键字，可以用来声明浮点数变量。

1	float c = 10.5;

上面示例中，变量c的就是浮点数类型。

float类型占用4个字节（32位），其中8位存放指数的值和符号，剩下24位存放小数的值和符号。float类型至少能够提供（十进制的）6位有效数字，指数部分的范围为（十进制的）-37到37，即数值范围为10^-37到10³⁷。

有时候，32位浮点数提供的精度或者数值范围还不够，C 语言又提供了另外两种更大的浮点数类型。

double：占用8个字节（64位），至少提供13位有效数字。
long double：通常占用16个字节。

注意，由于存在精度限制，浮点数只是一个近似值，它的计算是不精确的，比如 C 语言里面0.1 + 0.2并不等于0.3，而是有一个很小的误差。

1	if (0.1 + 0.2 == 0.3) // false

C 语言允许使用科学计数法表示浮点数，使用字母e来分隔小数部分和指数部分。

1
2
3

double x = 123.456e+3; // 123.456 x 10^3
// 等同于
double x = 123.456e3;

上面示例中，e后面如果是加号+，加号可以省略。注意，科学计数法里面e的前后，不能存在空格。

另外，科学计数法的小数部分如果是0.x或x.0的形式，那么0可以省略。

0.3E6
// 等同于
.3E6

3.0E6
// 等同于
3.E6

布尔类型

C 语言原来并没有为布尔值单独设置一个类型，而是使用整数0表示伪，所有非零值表示真。

int x = 1;
if (x) {
  printf("x is true!\n");
}

上面示例中，变量x等于1，C 语言就认为这个值代表真，从而会执行判断体内部的代码。

C99 标准添加了类型_Bool，表示布尔值。但是，这个类型其实只是整数类型的别名，还是使用0表示伪，1表示真，下面是一个示例。

_Bool isNormal;

isNormal = 1;
if (isNormal)
  printf("Everything is OK.\n");

头文件stdbool.h定义了另一个类型别名bool，并且定义了true代表1、false代表0。只要加载这个头文件，就可以使用这几个关键字。

1
2
3

#include <stdbool.h>

bool flag = false;

上面示例中，加载头文件stdbool.h以后，就可以使用bool定义布尔值类型，以及false和true表示真伪。

字面量的类型

字面量（literal）指的是代码里面直接出现的值。

1	int x = 123;

上面代码中，x是变量，123就是字面量。

编译时，字面量也会写入内存，因此编译器必须为字面量指定数据类型，就像必须为变量指定数据类型一样。

一般情况下，十进制整数字面量（比如123）会被编译器指定为int类型。如果一个数值比较大，超出了int能够表示的范围，编译器会将其指定为long int。如果数值超过了long int，会被指定为unsigned long。如果还不够大，就指定为long long或unsigned long long。

小数（比如3.14）会被指定为double类型。

字面量后缀

有时候，程序员希望为字面量指定一个不同的类型。比如，编译器将一个整数字面量指定为int类型，但是程序员希望将其指定为long类型，这时可以为该字面量加上后缀l或L，编译器就知道要把这个字面量的类型指定为long。

1	int x = 123L;

上面代码中，字面量123有后缀L，编译器就会将其指定为long类型。这里123L写成123l，效果也是一样的，但是建议优先使用L，因为小写的l容易跟数字1混淆。

八进制和十六进制的值，也可以使用后缀l和L指定为 Long 类型，比如020L和0x20L。

1 2	int y = 0377L; int z = 0x7fffL;

如果希望指定为无符号整数unsigned int，可以使用后缀u或U。

1	int x = 123U;

L和U可以结合使用，表示unsigned long类型。L和U的大小写和组合顺序无所谓。

1	int x = 123LU;

对于浮点数，编译器默认指定为 double 类型，如果希望指定为其他类型，需要在小数后面添加后缀f（float）或l（long double）。

科学计数法也可以使用后缀。

1 2	1.2345e+10F 1.2345e+10L

总结一下，常用的字面量后缀有下面这些。

f和F：float类型。
l和L：对于整数是long int类型，对于小数是long double类型。
ll和LL：Long Long 类型，比如3LL。
u和U：表示unsigned int，比如15U、0377U。

u还可以与其他整数后缀结合，放在前面或后面都可以，比如10UL、10ULL和10LLU都是合法的。

下面是一些示例。

int           x = 1234;
long int      x = 1234L;
long long int x = 1234LL

unsigned int           x = 1234U;
unsigned long int      x = 1234UL;
unsigned long long int x = 1234ULL;

float x       = 3.14f;
double x      = 3.14;
long double x = 3.14L;

溢出

每一种数据类型都有数值范围，如果存放的数值超出了这个范围（小于最小值或大于最大值），需要更多的二进制位存储，就会发生溢出。大于最大值，叫做向上溢出（overflow）；小于最小值，叫做向下溢出（underflow）。

一般来说，编译器不会对溢出报错，会正常执行代码，但是会忽略多出来的二进制位，只保留剩下的位，这样往往会得到意想不到的结果。所以，应该避免溢出。

unsigned char x = 255;
x = x + 1;

printf("%d\n", x); // 0

上面示例中，变量x加1，得到的结果不是256，而是0。因为x是unsign char类型，最大值是255（二进制11111111），加1后就发生了溢出，256（二进制100000000）的最高位1被丢弃，剩下的值就是0。

再看下面的例子。

unsigned int ui = UINT_MAX;  // 4,294,967,295
ui++;
printf("ui = %u\n", ui); // 0
ui--;
printf("ui = %u\n", ui); // 4,294,967,295

上面示例中，常量UINT_MAX是 unsigned int 类型的最大值。如果加1，对于该类型就会溢出，从而得到0；而0是该类型的最小值，再减1，又会得到UINT_MAX。

溢出很容易被忽视，编译器又不会报错，所以必须非常小心。

1	for (unsigned int i = n; i >= 0; --i) // 错误

上面代码表面看似乎没有问题，但是循环变量i的类型是 unsigned int，这个类型的最小值是0，不可能得到小于0的结果。当i等于0，再减去1的时候，并不会返回-1，而是返回 unsigned int 的类型最大值，这个值总是大于等于0，导致无限循环。

为了避免溢出，最好方法就是将运算结果与类型的极限值进行比较。

unsigned int ui;
unsigned int sum;

// 错误
if (sum + ui > UINT_MAX) too_big();
else sum = sum + ui;

// 正确
if (ui > UINT_MAX - sum) too_big();
else sum = sum + ui;

上面示例中，变量sum和ui都是 unsigned int 类型，它们相加的和还是 unsigned int 类型，这就有可能发生溢出。但是，不能通过相加的和是否超出了最大值UINT_MAX，来判断是否发生了溢出，因为sum + ui总是返回溢出后的结果，不可能大于UINT_MAX。正确的比较方法是，判断UINT_MAX - sum与ui之间的大小关系。

下面是另一种错误的写法。

unsigned int i = 5;
unsigned int j = 7;

if (i - j < 0) // 错误
  printf("negative\n");
else
  printf("positive\n");

上面示例的运算结果，会输出positive。原因是变量i和j都是 unsigned int 类型，i - j的结果也是这个类型，最小值为0，不可能得到小于0的结果。正确的写法是写成下面这样。

1	if (j > i) // ....

sizeof 运算符

sizeof是 C 语言提供的一个运算符，返回某种数据类型或某个值占用的字节数量。它的参数可以是数据类型的关键字，也可以是变量名或某个具体的值。

// 参数为数据类型
int x = sizeof(int);

// 参数为变量
int i;
sizeof(i);

// 参数为数值
sizeof(3.14);

上面的第一个示例，返回得到int类型占用的字节数量（通常是4或8）。第二个示例返回整数变量占用字节数量，结果与前一个示例完全一样。第三个示例返回浮点数3.14占用的字节数量，由于浮点数的字面量一律存储为 double 类型，所以会返回8，因为 double 类型占用的8个字节。

sizeof运算符的返回值，C 语言只规定是无符号整数，并没有规定具体的类型，而是留给系统自己去决定，sizeof到底返回什么类型。不同的系统中，返回值的类型有可能是unsigned int，也有可能是unsigned long，甚至是unsigned long long，对应的printf()占位符分别是%u、%lu和%llu。这样不利于程序的可移植性。

C 语言提供了一个解决方法，创造了一个类型别名size_t，用来统一表示sizeof的返回值类型。该别名定义在stddef.h头文件（引入stdio.h时会自动引入）里面，对应当前系统的sizeof的返回值类型，可能是unsigned int，也可能是unsigned long。

C 语言还提供了一个常量SIZE_MAX，表示size_t可以表示的最大整数。所以，size_t能够表示的整数范围为[0, SIZE_MAX]。

printf()有专门的占位符%zd或%zu，用来处理size_t类型的值。

1	printf("%zd\n", sizeof(int));

上面代码中，不管sizeof返回值的类型是什么，%zd占位符（或%zu）都可以正确输出。

如果当前系统不支持%zd或%zu，可使用%u（unsigned int）或%lu（unsigned long int）代替。

类型的自动转换

某些情况下，C 语言会自动转换某个值的类型。

赋值运算

赋值运算符会自动将右边的值，转成左边变量的类型。

（1）浮点数赋值给整数变量

浮点数赋予整数变量时，C 语言直接丢弃小数部分，而不是四舍五入。

1	int x = 3.14;

上面示例中，变量x是整数类型，赋给它的值是一个浮点数。编译器会自动把3.14先转为int类型，丢弃小数部分，再赋值给x，因此x的值是3。

这种自动转换会导致部分数据的丢失（3.14丢失了小数部分），所以最好不要跨类型赋值，尽量保证变量与所要赋予的值是同一个类型。

注意，舍弃小数部分时，不是四舍五入，而是整个舍弃。

1	int x = 12.99;

上面示例中，x等于12，而不是四舍五入的13。

（2）整数赋值给浮点数变量

整数赋值给浮点数变量时，会自动转为浮点数。

1	float y = 12 * 2;

上面示例中，变量y的值不是24，而是24.0，因为等号右边的整数自动转为了浮点数。

（3）窄类型赋值给宽类型

字节宽度较小的整数类型，赋值给字节宽度较大的整数变量时，会发生类型提升，即窄类型自动转为宽类型。

比如，char或short类型赋值给int类型，会自动提升为int。

1 2	char x = 10; int i = x + y;

上面示例中，变量x的类型是char，由于赋值给int类型，所以会自动提升为int。

（4）宽类型赋值给窄类型

字节宽度较大的类型，赋值给字节宽度较小的变量时，会发生类型降级，自动转为后者的类型。这时可能会发生截值（truncation），系统会自动截去多余的二进制位，导致难以预料的结果。

1 2	int i = 321; char ch = i; // ch 的值是 65 （321 - 256）

上面例子中，变量ch是char类型，宽度是8个二进制位。变量i是int类型，将i赋值给ch，后者只能容纳i（二进制形式为101000001，共9位）的后八位，前面多出来的二进制位被丢弃，保留后八位就变成了01000001（十进制的65，相当于字符A）。

浮点数赋值给整数类型的值，也会发生截值，浮点数的小数部分会被截去。

1 2	double pi = 3.14159; int i = pi; // i 的值为 3

上面示例中，i等于3，pi的小数部分被截去了。

混合类型的运算

不同类型的值进行混合计算时，必须先转成同一个类型，才能进行计算。转换规则如下：

（1）整数与浮点数混合运算时，整数转为浮点数类型，与另一个运算数类型相同。

1	3 + 1.2 // 4.2

上面示例是int类型与float类型的混合计算，int类型的3会先转成float的3.0，再进行计算，得到4.2。

（2）不同的浮点数类型混合运算时，宽度较小的类型转为宽度较大的类型，比如float转为double，double转为long double。

（3）不同的整数类型混合运算时，宽度较小的类型会提升为宽度较大的类型。比如short转为int，int转为long等，有时还会将带符号的类型signed转为无符号unsigned。

下面例子的执行结果，可能会出人意料。

1
2
3

int a = -5;
if (a < sizeof(int)）
  do_something();

上面示例中，变量a是带符号整数，sizeof(int)是size_t类型，这是一个无符号整数。按照规则，signed int 自动转为 unsigned int，所以a会自动转成无符号整数4294967291（转换规则是-5加上无符号整数的最大值，再加1），导致比较失败，do_something()不会执行。

所以，最好避免无符号整数与有符号整数的混合运算。因为这时 C 语言会自动将signed int转为unsigned int，可能不会得到预期的结果。

整数类型的运算

两个相同类型的整数运算时，或者单个整数的运算，一般来说，运算结果也属于同一类型。但是有一个例外，宽度小于int的类型，运算结果会自动提升为int。

unsigned char a = 66;

if ((-a) < 0) printf("negative\n");
else printf("positive\n");

上面示例中，变量a是 unsigned char 类型，这个类型不可能小于0，但是-a不是 unsigned char 类型，会自动转为 int 类型，导致上面的代码输出 negative。

再看下面的例子。

unsigned char a = 1;
unsigned char b = 255;
unsigned char c = 255;

if ((a - 5) < 0) do_something();
if ((b + c) > 300) do_something();

上面示例中，表达式a - 5和b + c都会自动转为 int 类型，所以函数do_something()会执行两次。

函数

函数的参数和返回值，会自动转成函数定义里指定的类型。

int dostuff(int, unsigned char);

char m = 42;
unsigned short n = 43;
long long int c = dostuff(m, n);

上面示例中，参数变量m和n不管原来的类型是什么，都会转成函数dostuff()定义的参数类型。

下面是返回值自动转换类型的例子。

char func(void) {
  int a = 42;
  return a;
}

上面示例中，函数内部的变量a是int类型，但是返回的值是char类型，因为函数定义中返回的是这个类型。

类型的显式转换

原则上，应该避免类型的自动转换，防止出现意料之外的结果。C 语言提供了类型的显式转换，允许手动转换类型。

只要在一个值或变量的前面，使用圆括号指定类型(type)，就可以将这个值或变量转为指定的类型，这叫做“类型指定”（casting）。

1	(unsigned char) ch

上面示例将变量ch转成无符号的字符类型。

1	long int y = (long int) 10 + 12;

上面示例中，(long int)将10显式转为long int类型。这里的显示转换其实是不必要的，因为赋值运算符会自动将右边的值，转为左边变量的类型。

可移植类型

C 语言的整数类型（short、int、long）在不同计算机上，占用的字节宽度可能是不一样的，无法提前知道它们到底占用多少个字节。

程序员有时控制准确的字节宽度，这样的话，代码可以有更好的可移植性，头文件stdint.h创造了一些新的类型别名。

（1）精确宽度类型(exact-width integer type)，保证某个整数类型的宽度是确定的。

int8_t：8位有符号整数。
int16_t：16位有符号整数。
int32_t：32位有符号整数。
int64_t：64位有符号整数。
uint8_t：8位无符号整数。
uint16_t：16位无符号整数。
uint32_t：32位无符号整数。
uint64_t：64位无符号整数。

上面这些都是类型别名，编译器会指定它们指向的底层类型。比如，某个系统中，如果int类型为32位，int32_t就会指向int；如果long类型为32位，int32_t则会指向long。

下面是一个使用示例。

#include <stdio.h>
#include <stdint.h>

int main(void) {
  int32_t x32 = 45933945;
  printf("x32 = %d\n", x32);
  return 0;
}

上面示例中，变量x32声明为int32_t类型，可以保证是32位的宽度。

（2）最小宽度类型（minimum width type），保证某个整数类型的最小长度。

int_least8_t
int_least16_t
int_least32_t
int_least64_t
uint_least8_t
uint_least16_t
uint_least32_t
uint_least64_t

上面这些类型，可以保证占据的字节不少于指定宽度。比如，int_least8_t表示可以容纳8位有符号整数的最小宽度的类型。

（3）最快的最小宽度类型（fast minimum width type），可以使整数计算达到最快的类型。

int_fast8_t
int_fast16_t
int_fast32_t
int_fast64_t
uint_fast8_t
uint_fast16_t
uint_fast32_t
uint_fast64_t

上面这些类型是保证字节宽度的同时，追求最快的运算速度，比如int_fast8_t表示对于8位有符号整数，运算速度最快的类型。这是因为某些机器对于特定宽度的数据，运算速度最快，举例来说，32位计算机对于32位数据的运算速度，会快于16位数据。

（4）可以保存指针的整数类型。

intptr_t：可以存储指针（内存地址）的有符号整数类型。
uintptr_t：可以存储指针的无符号整数类型。

（5）最大宽度整数类型，用于存放最大的整数。

intmax_t：可以存储任何有效的有符号整数的类型。
uintmax_t：可以存放任何有效的无符号整数的类型。

上面的这两个类型的宽度比long long和unsigned long更大。

指针

指针是 C 语言最重要的概念之一，也是最难理解的概念之一。

简介

指针是什么？首先，它是一个值，这个值代表一个内存地址，因此指针相当于指向某个内存地址的路标。

字符*表示指针，通常跟在类型关键字的后面，表示指针指向的是什么类型的值。比如，char*表示一个指向字符的指针，float*表示一个指向float类型的值的指针。

1	int* intPtr;

上面示例声明了一个变量intPtr，它是一个指针，指向的内存地址存放的是一个整数。

星号*可以放在变量名与类型关键字之间的任何地方，下面的写法都是有效的。

1
2
3

int   *intPtr;
int * intPtr;
int*  intPtr;

本书使用星号紧跟在类型关键字后面的写法（即int* intPtr;），因为这样可以体现，指针变量就是一个普通变量，只不过它的值是内存地址而已。

这种写法有一个地方需要注意，如果同一行声明两个指针变量，那么需要写成下面这样。

// 正确
int * foo, * bar;

// 错误
int* foo, bar;

上面示例中，第二行的执行结果是，foo是整数指针变量，而bar是整数变量，即*只对第一个变量生效。

一个指针指向的可能还是指针，这时就要用两个星号**表示。

1	int** foo;

上面示例表示变量foo是一个指针，指向的还是一个指针，第二个指针指向的则是一个整数。

* 运算符

*这个符号除了表示指针以外，还可以作为运算符，用来取出指针变量所指向的内存地址里面的值。

1
2
3

void increment(int* p) {
  *p = *p + 1;
}

上面示例中，函数increment()的参数是一个整数指针p。函数体里面，*p就表示指针p所指向的那个值。对*p赋值，就表示改变指针所指向的那个地址里面的值。

上面函数的作用是将参数值加1。该函数没有返回值，因为传入的是地址，函数体内部对该地址包含的值的操作，会影响到函数外部，所以不需要返回值。事实上，函数内部通过指针，将值传到外部，是 C 语言的常用方法。

变量地址而不是变量值传入函数，还有一个好处。对于需要大量存储空间的大型变量，复制变量值传入函数，非常浪费时间和空间，不如传入指针来得高效。

& 运算符

&运算符用来取出一个变量所在的内存地址。

1 2	int x = 1; printf("x's address is %p\n", &x);

上面示例中，x是一个整数变量，&x就是x的值所在的内存地址。printf()的%p是内存地址的占位符，可以打印出内存地址。

上一小节中，参数变量加1的函数，可以像下面这样使用。

void increment(int* p) {
  *p = *p + 1;
}

int x = 1;
increment(&x);
printf("%d\n", x); // 2

上面示例中，调用increment()函数以后，变量x的值就增加了1，原因就在于传入函数的是变量x的地址&x。

&运算符与*运算符互为逆运算，下面的表达式总是成立。

1
2
3

int i = 5;

if (i == *(&i)) // 正确

指针变量的初始化

声明指针变量之后，编译器会为指针变量本身分配一个内存空间，但是这个内存空间里面的值是随机的，也就是说，指针变量指向的值是随机的。这时一定不能去读写指针变量指向的地址，因为那个地址是随机地址，很可能会导致严重后果。

1 2	int* p; *p = 1; // 错误

上面的代码是错的，因为p指向的那个地址是随机的，向这个随机地址里面写入1，会导致意想不到的结果。

正确做法是指针变量声明后，必须先让它指向一个分配好的地址，然后再进行读写，这叫做指针变量的初始化。

int* p;
int i;

p = &i;
*p = 13;

上面示例中，p是指针变量，声明这个变量后，p会指向一个随机的内存地址。这时要将它指向一个已经分配好的内存地址，上例就是再声明一个整数变量i，编译器会为i分配内存地址，然后让p指向i的内存地址（p = &i;）。完成初始化之后，就可以对p指向的内存地址进行赋值了（*p = 13;）。

为了防止读写未初始化的指针变量，可以养成习惯，将未初始化的指针变量设为NULL。

1	int* p = NULL;

NULL在 C 语言中是一个常量，表示地址为0的内存空间，这个地址是无法使用的，读写该地址会报错。

指针的运算

指针本质上就是一个无符号整数，代表了内存地址。它可以进行运算，但是规则并不是整数运算的运算。

（1）指针与整数值的加减运算

指针与整数值的运算，表示指针的移动。

1
2
3

short* j;
j = (short*)0x1234;
j = j + 1; // 0x1236

上面示例中，j是一个指针，指向内存地址0x1234。你可能以为j + 1等于0x1235，但正确答案是0x1236。原因是j + 1表示指针向高位移动一个单位，而一个单位的short类型占据两个字节的宽度，所以相当于向高位移动两个字节。同样的，j - 1得到的结果是0x1232。

指针移动的单位，与指针指向的数据类型有关。数据类型占据多少个字节，每单位就移动多少个字节。

（2）指针与指针的加法运算

指针只能与整数值进行加减运算，两个指针进行加法是非法的。

1
2
3

unsigned short* j;
unsigned short* k;
x = j + k; // 非法

上面示例是两个指针相加，这是非法的。

（3）指针与指针的减法

相同类型的指针允许进行减法运算，返回它们之间的距离，即相隔多少个数据单位。

高位地址减去低位地址，返回的是正值；低位地址减去高位地址，返回的是负值。

这时，减法返回的值属于ptrdiff_t类型，这是一个带符号的整数类型别名，具体类型根据系统不同而不同。这个类型的原型定义在头文件stddef.h里面。

short* j1;
short* j2;

j1 = (short*)0x1234;
j2 = (short*)0x1236;

ptrdiff_t dist = j2 - j1;
printf("%d\n", dist); // 1

上面示例中，j1和j2是两个指向 short 类型的指针，变量dist是它们之间的距离，类型为ptrdiff_t，值为1，因为相差2个字节正好存放一个 short 类型的值。

（4）指针与指针的比较运算

指针之间的比较运算，比较的是各自的内存地址哪一个更大，返回值是整数1（true）或0（false）。

函数

简介

函数是一段可以重复执行的代码。它可以接受不同的参数，完成对应的操作。下面的例子就是一个函数。

1
2
3

int plus_one(int n) {
  return n + 1;
}

上面的代码声明了一个函数plus_one()。

函数声明的语法有以下几点，需要注意。

（1）返回值类型。函数声明时，首先需要给出返回值的类型，上例是int，表示函数plus_one()返回一个整数。

（2）参数。函数名后面的圆括号里面，需要声明参数的类型和参数名，plus_one(int n)表示这个函数有一个整数参数n。

（3）函数体。函数体要写在大括号里面，后面（即大括号外面）不需要加分号。大括号的起始位置，可以跟函数名在同一行，也可以另起一行，本书采用同一行的写法。

（4）return语句。return语句给出函数的返回值，程序运行到这一行，就会跳出函数体，结束函数的调用。如果函数没有返回值，可以省略return语句，或者写成return;。

调用函数时，只要在函数名后面加上圆括号就可以了，实际的参数放在圆括号里面，就像下面这样。

1 2	int a = plus_one(13); // a 等于 14

函数调用时，参数个数必须与定义里面的参数个数一致，参数过多或过少都会报错。

int plus_one(int n) {
  return n + 1;
}

plus_one(2, 2); // 报错
plus_one();  // 报错

上面示例中，函数plus_one()只能接受一个参数，传入两个参数或不传参数，都会报错。

函数必须声明后使用，否则会报错。也就是说，一定要在使用plus_one()之前，声明这个函数。如果像下面这样写，编译时会报错。

int a = plus_one(13);

int plus_one(int n) {
  return n + 1;
}

上面示例中，在调用plus_one()之后，才声明这个函数，编译就会报错。

C 语言标准规定，函数只能声明在源码文件的顶层，不能声明在其他函数内部。

不返回值的函数，使用void关键字表示返回值的类型。没有参数的函数，声明时要用void关键字表示参数类型。

1
2
3

void myFunc(void) {
  // ...
}

上面的myFunc()函数，既没有返回值，调用时也不需要参数。

函数可以调用自身，这就叫做递归（recursion）。下面是斐波那契数列的例子。

unsigned long Fibonacci(unsigned n) {
  if (n > 2)
    return Fibonacci(n - 1) + Fibonacci(n - 2);
  else
    return 1;
}

上面示例中，函数Fibonacci()调用了自身，大大简化了算法。

main()

C 语言规定，main()是程序的入口函数，即所有的程序一定要包含一个main()函数。程序总是从这个函数开始执行，如果没有该函数，程序就无法启动。其他函数都是通过它引入程序的。

main()的写法与其他函数一样，要给出返回值的类型和参数的类型，就像下面这样。

int main(void) {
  printf("Hello World\n");
  return 0;
}

上面示例中，最后的return 0;表示函数结束运行，返回0。

C 语言约定，返回值0表示函数运行成功，如果返回其他非零整数，就表示运行失败，代码出了问题。系统根据main()的返回值，作为整个程序的返回值，确定程序是否运行成功。

正常情况下，如果main()里面省略return 0这一行，编译器会自动加上，即main()的默认返回值为0。所以，写成下面这样，效果完全一样。

1
2
3

int main(void) {
  printf("Hello World\n");
}

由于 C 语言只会对main()函数默认添加返回值，对其他函数不会这样做，所以建议总是保留return语句，以便形成统一的代码风格。

参数的传值引用

如果函数的参数是一个变量，那么调用时，传入的是这个变量的值的拷贝，而不是变量本身。

void increment(int a) {
  a++;
}

int i = 10;
increment(i);

printf("%d\n", i); // 10

上面示例中，调用increment(i)以后，变量i本身不会发生变化，还是等于10。因为传入函数的是i的拷贝，而不是i本身，拷贝的变化，影响不到原始变量。这就叫做“传值引用”。

所以，如果参数变量发生变化，最好把它作为返回值传出来。

int increment(int a) {
  a++;
  return a;
}

int i = 10;
i = increment(i);

printf("%d\n", i); // 11

再看下面的例子，Swap()函数用来交换两个变量的值，由于传值引用，下面的写法不会生效。

void Swap(int x, int y) {
  int temp;
  temp = x;
  x = y;
  y = temp;
}

int a = 1;
int b = 2;
Swap(a, b); // 无效

上面的写法不会产生交换变量值的效果，因为传入的变量是原始变量a和b的拷贝，不管函数内部怎么操作，都影响不了原始变量。

如果想要传入变量本身，只有一个办法，就是传入变量的地址。

void Swap(int* x, int* y) {
  int temp;
  temp = *x;
  *x = *y;
  *y = temp;
}

int a = 1;
int b = 2;
Swap(&a, &b);

上面示例中，通过传入变量x和y的地址，函数内部就可以直接操作该地址，从而实现交换两个变量的值。

虽然跟传参无关，这里特别提一下，函数不要返回内部变量的指针。

int* f(void) {
  int i;
  // ...
  return &i;
}

上面示例中，函数返回内部变量i的指针，这种写法是错的。因为当函数结束运行时，内部变量就消失了，这时指向内部变量i的内存地址就是无效的，再去使用这个地址是非常危险的。

函数指针

函数本身就是一段内存里面的代码，C 语言允许通过指针获取函数。

void print(int a) {
  printf("%d\n", a);
}

void (*print_ptr)(int) = &print;

上面示例中，变量print_ptr是一个函数指针，它指向函数print()的地址。函数print()的地址可以用&print获得。注意，(*print_ptr)一定要写在圆括号里面，否则函数参数(int)的优先级高于*，整个式子就会变成void* print_ptr(int)。

有了函数指针，通过它也可以调用函数。

1
2
3

(*print_ptr)(10);
// 等同于
print(10);

比较特殊的是，C 语言还规定，函数名本身就是指向函数代码的指针，通过函数名就能获取函数地址。也就是说，print和&print是一回事。

1	if (print == &print) // true

因此，上面代码的print_ptr等同于print。

void (*print_ptr)(int) = &print;
// 或
void (*print_ptr)(int) = print;

if (print_ptr == print) // true

所以，对于任意函数，都有五种调用函数的写法。

// 写法一
print(10)

// 写法二
(*print)(10)

// 写法三
(&print)(10)

// 写法四
(*print_ptr)(10)

// 写法五
print_ptr(10)

为了简洁易读，一般情况下，函数名前面都不加*和&。

这种特性的一个应用是，如果一个函数的参数或返回值，也是一个函数，那么函数原型可以写成下面这样。

1	int compute(int (*myfunc)(int), int, int);

上面示例可以清晰地表明，函数compute()的第一个参数也是一个函数。

函数原型

前面说过，函数必须先声明，后使用。由于程序总是先运行main()函数，导致所有其他函数都必须在main()函数之前声明。

void func1(void) {
}

void func2(void) {
}

int main(void) {
  func1();
  func2();
  return 0;
}

上面代码中，main()函数必须在最后声明，否则编译时会产生警告，找不到func1()或func2()的声明。

但是，main()是整个程序的入口，也是主要逻辑，放在最前面比较好。另一方面，对于函数较多的程序，保证每个函数的顺序正确，会变得很麻烦。

C 语言提供的解决方法是，只要在程序开头处给出函数原型，函数就可以先使用、后声明。所谓函数原型，就是提前告诉编译器，每个函数的返回类型和参数类型。其他信息都不需要，也不用包括函数体，具体的函数实现可以后面再补上。

int twice(int);

int main(int num) {
  return twice(num);
}

int twice(int num) {
  return 2 * num;
}

上面示例中，函数twice()的实现是放在main()后面，但是代码头部先给出了函数原型，所以可以正确编译。只要提前给出函数原型，函数具体的实现放在哪里，就不重要了。

函数原型包括参数名也可以，虽然这样对于编译器是多余的，但是阅读代码的时候，可能有助于理解函数的意图。

int twice(int);

// 等同于
int twice(int num);

上面示例中，twice函数的参数名num，无论是否出现在原型里面，都是可以的。

注意，函数原型必须以分号结尾。

一般来说，每个源码文件的头部，都会给出当前脚本使用的所有函数的原型。

exit()

exit()函数用来终止整个程序的运行。一旦执行到该函数，程序就会立即结束。该函数的原型定义在头文件stdlib.h里面。

exit()可以向程序外部返回一个值，它的参数就是程序的返回值。一般来说，使用两个常量作为它的参数：EXIT_SUCCESS（相当于 0）表示程序运行成功，EXIT_FAILURE（相当于 1）表示程序异常中止。这两个常数也是定义在stdlib.h里面。

// 程序运行成功
// 等同于 exit(0);
exit(EXIT_SUCCESS);

// 程序异常中止
// 等同于 exit(1);
exit(EXIT_FAILURE);

在main()函数里面，exit()等价于使用return语句。其他函数使用exit()，就是终止整个程序的运行，没有其他作用。

C 语言还提供了一个atexit()函数，用来登记exit()执行时额外执行的函数，用来做一些退出程序时的收尾工作。该函数的原型也是定义在头文件stdlib.h。

1	int atexit(void (*func)(void));

atexit()的参数是一个函数指针。注意，它的参数函数（上例的print）不能接受参数，也不能有返回值。

void print(void) {
  printf("something wrong!\n");
}

atexit(print);
exit(EXIT_FAILURE);

上面示例中，exit()执行时会先自动调用atexit()注册的print()函数，然后再终止程序。

函数说明符

C 语言提供了一些函数说明符，让函数用法更加明确。

extern 说明符

对于多文件的项目，源码文件会用到其他文件声明的函数。这时，当前文件里面，需要给出外部函数的原型，并用extern说明该函数的定义来自其他文件。

extern int foo(int arg1, char arg2);

int main(void) {
  int a = foo(2, 3);
  // ...
  return 0;
}

上面示例中，函数foo()定义在其他文件，extern告诉编译器当前文件不包含该函数的定义。

不过，由于函数原型默认就是extern，所以这里不加extern，效果是一样的。

static 说明符

默认情况下，每次调用函数时，函数的内部变量都会重新初始化，不会保留上一次运行的值。static说明符可以改变这种行为。

static用于函数内部声明变量时，表示该变量只需要初始化一次，不需要在每次调用时都进行初始化。也就是说，它的值在两次调用之间保持不变。

#include <stdio.h>

void counter(void) {
  static int count = 1;  // 只初始化一次
  printf("%d\n", count);
  count++;
}

int main(void) {
  counter();  // 1
  counter();  // 2
  counter();  // 3
  counter();  // 4
}

上面示例中，函数counter()的内部变量count，使用static说明符修饰，表明这个变量只初始化一次，以后每次调用时都会使用上一次的值，造成递增的效果。

注意，static修饰的变量初始化时，只能赋值为常量，不能赋值为变量。

1 2	int i = 3; static int j = i; // 错误

上面示例中，j属于静态变量，初始化时不能赋值为另一个变量i。

另外，在块作用域中，static声明的变量有默认值0。

1
2
3

static int foo;
// 等同于
static int foo = 0;

static可以用来修饰函数本身。

static int Twice(int num) {
  int result = num * 2;
  return(result);
}

上面示例中，static关键字表示该函数只能在当前文件里使用，如果没有这个关键字，其他文件也可以使用这个函数（通过声明函数原型）。

static也可以用在参数里面，修饰参数数组。

1
2
3

int sum_array(int a[static 3], int n) {
  // ...
}

上面示例中，static对程序行为不会有任何影响，只是用来告诉编译器，该数组长度至少为3，某些情况下可以加快程序运行速度。另外，需要注意的是，对于多维数组的参数，static仅可用于第一维的说明。

const 说明符

函数参数里面的const说明符，表示函数内部不得修改该参数变量。

1
2
3

void f(int* p) {
  // ...
}

上面示例中，函数f()的参数是一个指针p，函数内部可能会改掉它所指向的值*p，从而影响到函数外部。

为了避免这种情况，可以在声明函数时，在指针参数前面加上const说明符，告诉编译器，函数内部不能修改该参数所指向的值。

1
2
3

void f(const int* p) {
  *p = 0; // 该行报错
}

上面示例中，声明函数时，const指定不能修改指针p指向的值，所以*p = 0就会报错。

但是上面这种写法，只限制修改p所指向的值，而p本身的地址是可以修改的。

void f(const int* p) {
  int x = 13;
  p = &x; // 允许修改
}

上面示例中，p本身是可以修改，const只限定*p不能修改。

如果想限制修改p，可以把const放在p前面。

void f(int* const p) {
  int x = 13;
  p = &x; // 该行报错
}

如果想同时限制修改p和*p，需要使用两个const。

1
2
3

void f(const int* const p) {
  // ...
}

可变参数

有些函数的参数数量是不确定的，声明函数的时候，可以使用省略号...表示可变数量的参数。

1	int printf(const char* format, ...);

上面示例是printf()函数的原型，除了第一个参数，其他参数的数量是可变的，与格式字符串里面的占位符数量有关。这时，就可以用...表示可变数量的参数。

注意，...符号必须放在参数序列的结尾，否则会报错。

头文件stdarg.h定义了一些宏，可以操作可变参数。

（1）va_list：一个数据类型，用来定义一个可变参数对象。它必须在操作可变参数时，首先使用。

（2）va_start：一个函数，用来初始化可变参数对象。它接受两个参数，第一个参数是可变参数对象，第二个参数是原始函数里面，可变参数之前的那个参数，用来为可变参数定位。

（3）va_arg：一个函数，用来取出当前那个可变参数，每次调用后，内部指针就会指向下一个可变参数。它接受两个参数，第一个是可变参数对象，第二个是当前可变参数的类型。

（4）va_end：一个函数，用来清理可变参数对象。

下面是一个例子。

double average(int i, ...) {
  double total = 0;
  va_list ap;
  va_start(ap, i);
  for (int j = 1; j <= i; ++j) {
    total += va_arg(ap, double);
  }
  va_end(ap);
  return total / i;
}

上面示例中，va_list ap定义ap为可变参数对象，va_start(ap, i)将参数i后面的参数统一放入ap，va_arg(ap, double)用来从ap依次取出一个参数，并且指定该参数为 double 类型，va_end(ap)用来清理可变参数对象。

数组

简介

数组是一组相同类型的值，按照顺序储存在一起。数组通过变量名后加方括号表示，方括号里面是数组的成员数量。

1	int scores[100];

上面示例声明了一个数组scores，里面包含100个成员，每个成员都是int类型。

注意，声明数组时，必须给出数组的大小。

数组的成员从0开始编号，所以数组scores[100]就是从第0号成员一直到第99号成员，最后一个成员的编号会比数组长度小1。

数组名后面使用方括号指定编号，就可以引用该成员。也可以通过该方式，对该位置进行赋值。

1 2	scores[0] = 13; scores[99] = 42;

上面示例对数组scores的第一个位置和最后一个位置，进行了赋值。

注意，如果引用不存在的数组成员（即越界访问数组），并不会报错，所以必须非常小心。

1
2
3

int scores[100];

scores[100] = 51;

上面示例中，数组scores只有100个成员，因此scores[100]这个位置是不存在的。但是，引用这个位置并不会报错，会正常运行，使得紧跟在scores后面的那块内存区域被赋值，而那实际上是其他变量的区域，因此不知不觉就更改了其他变量的值。这很容易引发错误，而且难以发现。

数组也可以在声明时，使用大括号，同时对每一个成员赋值。

1	int a[5] = {22, 37, 3490, 18, 95};

注意，使用大括号赋值时，必须在数组声明时赋值，否则编译时会报错。

1 2	int a[5]; a = {22, 37, 3490, 18, 95}; // 报错

上面代码中，数组a声明之后再进行大括号赋值，导致报错。

报错的原因是，C 语言规定，数组变量一旦声明，就不得修改变量指向的地址，具体会在后文解释。由于同样的原因，数组赋值之后，再用大括号修改值，也是不允许的。

1 2	int a[5] = {1, 2, 3, 4, 5}; a = {22, 37, 3490, 18, 95}; // 报错

上面代码中，数组a赋值后，再用大括号重新赋值也是不允许的。

使用大括号赋值时，大括号里面的值不能多于数组的长度，否则编译时会报错。

如果大括号里面的值，少于数组的成员数量，那么未赋值的成员自动初始化为0。

1
2
3

int a[5] = {22, 37, 3490};
// 等同于
int a[5] = {22, 37, 3490, 0, 0};

如果要将整个数组的每一个成员都设置为零，最简单的写法就是下面这样。

1	int a[100] = {0};

数组初始化时，可以指定为哪些位置的成员赋值。

1	int a[15] = {[2] = 29, [9] = 7, [14] = 48};

上面示例中，数组的2号、9号、14号位置被赋值，其他位置的值都自动设为0。

指定位置的赋值可以不按照顺序，下面的写法与上面的例子是等价的。

1	int a[15] = {[9] = 7, [14] = 48, [2] = 29};

指定位置的赋值与顺序赋值，可以结合使用。

1	int a[15] = {1, [5] = 10, 11, [10] = 20, 21}

上面示例中，0号、5号、6号、10号、11号被赋值。

C 语言允许省略方括号里面的数组成员数量，这时将根据大括号里面的值的数量，自动确定数组的长度。

1
2
3

int a[] = {22, 37, 3490};
// 等同于
int a[3] = {22, 37, 3490};

上面示例中，数组a的长度，将根据大括号里面的值的数量，确定为3。

省略成员数量时，如果同时采用指定位置的赋值，那么数组长度将是最大的指定位置再加1。

1	int a[] = {[2] = 6, [9] = 12};

上面示例中，数组a的最大指定位置是9，所以数组的长度是10。

数组长度

sizeof运算符会返回整个数组的字节长度。

1 2	int a[] = {22, 37, 3490}; int arrLen = sizeof(a); // 12

上面示例中，sizeof返回数组a的字节长度是12。

由于数组成员都是同一个类型，每个成员的字节长度都是一样的，所以数组整体的字节长度除以某个数组成员的字节长度，就可以得到数组的成员数量。

1	sizeof(a) / sizeof(a[0])

上面示例中，sizeof(a)是整个数组的字节长度，sizeof(a[0])是数组成员的字节长度，相除就是数组的成员数量。

注意，sizeof返回值的数据类型是size_t，所以sizeof(a) / sizeof(a[0])的数据类型也是size_t。在printf()里面的占位符，要用%zd或%zu。

int x[12];

printf("%zu\n", sizeof(x));     // 48
printf("%zu\n", sizeof(int));  // 4
printf("%zu\n", sizeof(x) / sizeof(int)); // 12

上面示例中，sizeof(x) / sizeof(int)就可以得到数组成员数量12。

多维数组

C 语言允许声明多个维度的数组，有多少个维度，就用多少个方括号，比如二维数组就使用两个方括号。

1	int board[10][10];

上面示例声明了一个二维数组，第一个维度有10个成员，第二个维度也有10个成员。

多维数组可以理解成，上层维度的每个成员本身就是一个数组。比如上例中，第一个维度的每个成员本身就是一个有10个成员的数组，因此整个二维数组共有100个成员（10 x 10 = 100）。

三维数组就使用三个方括号声明，以此类推。

1	int c[4][5][6];

引用二维数组的每个成员时，需要使用两个方括号，同时指定两个维度。

1 2	board[0][0] = 13; board[9][9] = 13;

注意，board[0][0]不能写成board[0, 0]，因为0, 0是一个逗号表达式，返回第二个值，所以board[0, 0]等同于board[0]。

跟一维数组一样，多维数组每个维度的第一个成员也是从0开始编号。

多维数组也可以使用大括号，一次性对所有成员赋值。

int a[2][5] = {
  {0, 1, 2, 3, 4},
  {5, 6, 7, 8, 9}
};

上面示例中，a是一个二维数组，这种赋值写法相当于将第一维的每个成员写成一个数组。这种写法不用为每个成员都赋值，缺少的成员会自动设置为0。

多维数组也可以指定位置，进行初始化赋值。

1	int a[2][2] = {[0][0] = 1, [1][1] = 2};

上面示例中，指定了[0][0]和[1][1]位置的值，其他位置就自动设为0。

不管数组有多少维度，在内存里面都是线性存储，a[0][0]的后面是a[0][1]，a[0][1]的后面是a[1][0]，以此类推。因此，多维数组也可以使用单层大括号赋值，下面的语句是上面的赋值语句是完全等同的。

1	int a[2][2] = {1, 0, 0, 2};

变长数组

数组声明的时候，数组长度除了使用常量，也可以使用变量。这叫做变长数组（variable-length array，简称 VLA）。

1 2	int n = x + y; int arr[n];

上面示例中，数组arr就是变长数组，因为它的长度取决于变量n的值，编译器没法事先确定，只有运行时才能知道n是多少。

变长数组的根本特征，就是数组长度只有运行时才能确定。它的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配精确的长度。

任何长度需要运行时才能确定的数组，都是变长数组。

int i = 10;

int a1[i];
int a2[i + 5];
int a3[i + k];

上面示例中，三个数组的长度都需要运行代码才能知道，编译器并不知道它们的长度，所以它们都是变长数组。

变长数组也可以用于多维数组。

1
2
3

int m = 4;
int n = 5;
int c[m][n];

上面示例中，c[m][n]就是二维变长数组。

数组的地址

数组是一连串连续储存的同类型值，只要获得起始地址（首个成员的内存地址），就能推算出其他成员的地址。请看下面的例子。

int a[5] = {11, 22, 33, 44, 55};
int* p;

p = &a[0];

printf("%d\n", *p);  // Prints "11"

上面示例中，&a[0]就是数组a的首个成员11的内存地址，也是整个数组的起始地址。反过来，从这个地址（*p），可以获得首个成员的值11。

由于数组的起始地址是常用操作，&array[0]的写法有点麻烦，C 语言提供了便利写法，数组名等同于起始地址，也就是说，数组名就是指向第一个成员（array[0]）的指针。

int a[5] = {11, 22, 33, 44, 55};

int* p = &a[0];
// 等同于
int* p = a;

上面示例中，&a[0]和数组名a是等价的。

这样的话，如果把数组名传入一个函数，就等同于传入一个指针变量。在函数内部，就可以通过这个指针变量获得整个数组。

函数接受数组作为参数，函数原型可以写成下面这样。

// 写法一
int sum(int arr[], int len);
// 写法二
int sum(int* arr, int len);

上面示例中，传入一个整数数组，与传入一个整数指针是同一回事，数组符号[]与指针符号*是可以互换的。下一个例子是通过数组指针对成员求和。

int sum(int* arr, int len) {
  int i;
  int total = 0;

  // 假定数组有 10 个成员
  for (i = 0; i < len; i++) {
    total += arr[i];
  }
  return total;
}

上面示例中，传入函数的是一个指针arr（也是数组名）和数组长度，通过指针获取数组的每个成员，从而求和。

*和&运算符也可以用于多维数组。

int a[4][2];

// 取出 a[0][0] 的值
*(a[0]);
// 等同于
**a

上面示例中，由于a[0]本身是一个指针，指向第二维数组的第一个成员a[0][0]。所以，*(a[0])取出的是a[0][0]的值。至于**a，就是对a进行两次*运算，第一次取出的是a[0]，第二次取出的是a[0][0]。同理，二维数组的&a[0][0]等同于*a。

注意，数组名指向的地址是不能更改的。声明数组时，编译器自动为数组分配了内存地址，这个地址与数组名是绑定的，不可更改，下面的代码会报错。

1 2	int ints[100]; ints = NULL; // 报错

上面示例中，重新为数组名赋值，改变原来的内存地址，就会报错。

这也导致不能将一个数组名赋值给另外一个数组名。

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

// 写法一
int b[5] = a; // 报错

// 写法二
int b[5];
b = a; // 报错

上面两种写法都会更改数组b的地址，导致报错。

数组指针的加减法

C 语言里面，数组名可以进行加法和减法运算，等同于在数组成员之间前后移动，即从一个成员的内存地址移动到另一个成员的内存地址。比如，a + 1返回下一个成员的地址，a - 1返回上一个成员的地址。

int a[5] = {11, 22, 33, 44, 55};

for (int i = 0; i < 5; i++) {
  printf("%d\n", *(a + i));
}

上面示例中，通过指针的移动遍历数组，a + i的每轮循环每次都会指向下一个成员的地址，*(a + i)取出该地址的值，等同于a[i]。对于数组的第一个成员，*(a + 0)（即*a）等同于a[0]。

由于数组名与指针是等价的，所以下面的等式总是成立。

1	a[b] == *(a + b)

上面代码给出了数组成员的两种访问方式，一种是使用方括号a[b]，另一种是使用指针*(a + b)。

如果指针变量p指向数组的一个成员，那么p++就相当于指向下一个成员，这种方法常用来遍历数组。

int a[] = {11, 22, 33, 44, 55, 999};

int* p = a;

while (*p != 999) {
  printf("%d\n", *p);
  p++;
}

上面示例中，通过p++让变量p指向下一个成员。

注意，数组名指向的地址是不能变的，所以上例中，不能直接对a进行自增，即a++的写法是错的，必须将a的地址赋值给指针变量p，然后对p进行自增。

遍历数组一般都是通过数组长度的比较来实现，但也可以通过数组起始地址和结束地址的比较来实现。

int sum(int* start, int* end) {
  int total = 0;

  while (start < end) {
    total += *start;
    start++;
  }

  return total;
}

int arr[5] = {20, 10, 5, 39, 4};
printf("%i\n", sum(arr, arr + 5));

上面示例中，arr是数组的起始地址，arr + 5是结束地址。只要起始地址小于结束地址，就表示还没有到达数组尾部。

反过来，通过数组的减法，可以知道两个地址之间有多少个数组成员，请看下面的例子，自己实现一个计算数组长度的函数。

int arr[5] = {20, 10, 5, 39, 88};
int* p = arr;

while (*p != 88)
  p++;

printf("%i\n", p - arr); // 4

上面示例中，将某个数组成员的地址，减去数组起始地址，就可以知道，当前成员与起始地址之间有多少个成员。

对于多维数组，数组指针的加减法对于不同维度，含义是不一样的。

int arr[4][2];

// 指针指向 arr[1]
arr + 1;

// 指针指向 arr[0][1]
arr[0] + 1

上面示例中，arr是一个二维数组，arr + 1是将指针移动到第一维数组的下一个成员，即arr[1]。由于每个第一维的成员，本身都包含另一个数组，即arr[0]是一个指向第二维数组的指针，所以arr[0] + 1的含义是将指针移动到第二维数组的下一个成员，即arr[0][1]。

同一个数组的两个成员的指针相减时，返回它们之间的距离。

int* p = &a[5];
int* q = &a[1];

printf("%d\n", p - q); // 4
printf("%d\n", q - p); // -4

上面示例中，变量p和q分别是数组5号位置和1号位置的指针，它们相减等于4或-4。

数组的复制

由于数组名是指针，所以复制数组不能简单地复制数组名。

int* a;
int b[3] = {1, 2, 3};

a = b;

上面的写法，结果不是将数组b复制给数组a，而是让a和b指向同一个数组。

复制数组最简单的方法，还是使用循环，将数组元素逐个进行复制。

1 2	for (i = 0; i < N; i++) a[i] = b[i];

上面示例中，通过将数组b的成员逐个复制给数组a，从而实现数组的赋值。

另一种方法是使用memcpy()函数（定义在头文件string.h），直接把数组所在的那一段内存，再复制一份。

1	memcpy(a, b, sizeof(b));

上面示例中，将数组b所在的那段内存，复制给数组a。这种方法要比循环复制数组成员要快。

作为函数的参数

声明参数数组

数组作为函数的参数，一般会同时传入数组名和数组长度。

int sum_array(int a[], int n) {
  // ...
}

int a[] = {3, 5, 7, 3};
int sum = sum_array(a, 4);

上面示例中，函数sum_array()的第一个参数是数组本身，也就是数组名，第二个参数是数组长度。

由于数组名就是一个指针，如果只传数组名，那么函数只知道数组开始的地址，不知道结束的地址，所以才需要把数组长度也一起传入。

如果函数的参数是多维数组，那么除了第一维的长度可以当作参数传入函数，其他维的长度需要写入函数的定义。

int sum_array(int a[][4], int n) {
  // ...
}

int a[2][4] = {
  {1, 2, 3, 4},
  {8, 9, 10, 11}
};
int sum = sum_array(a, 2);

上面示例中，函数sum_array()的参数是一个二维数组。第一个参数是数组本身（a[][4]），这时可以不写第一维的长度，因为它作为第二个参数，会传入函数，但是一定要写第二维的长度4。

这是因为函数内部拿到的，只是数组的起始地址a，以及第一维的成员数量2。如果要正确计算数组的结束地址，还必须知道第一维每个成员的字节长度。写成int a[][4]，编译器就知道了，第一维每个成员本身也是一个数组，里面包含了4个整数，所以每个成员的字节长度就是4 * sizeof(int)。

变长数组作为参数

变长数组作为函数参数时，写法略有不同。

int sum_array(int n, int a[n]) {
  // ...
}

int a[] = {3, 5, 7, 3};
int sum = sum_array(4, a);

上面示例中，数组a[n]是一个变长数组，它的长度取决于变量n的值，只有运行时才能知道。所以，变量n作为参数时，顺序一定要在变长数组前面，这样运行时才能确定数组a[n]的长度，否则就会报错。

因为函数原型可以省略参数名，所以变长数组的原型中，可以使用*代替变量名，也可以省略变量名。

1 2	int sum_array(int, int [*]); int sum_array(int, int []);

上面两种变长函数的原型写法，都是合法的。

变长数组作为函数参数有一个好处，就是多维数组的参数声明，可以把后面的维度省掉了。

// 原来的写法
int sum_array(int a[][4], int n);

// 变长数组的写法
int sum_array(int n, int m, int a[n][m]);

上面示例中，函数sum_array()的参数是一个多维数组，按照原来的写法，一定要声明第二维的长度。但是使用变长数组的写法，就不用声明第二维长度了，因为它可以作为参数传入函数。

数组字面量作为参数

C 语言允许将数组字面量作为参数，传入函数。

// 数组变量作为参数
int a[] = {2, 3, 4, 5};
int sum = sum_array(a, 4);

// 数组字面量作为参数
int sum = sum_array((int []){2, 3, 4, 5}, 4);

上面示例中，两种写法是等价的。第二种写法省掉了数组变量的声明，直接将数组字面量传入函数。{2, 3, 4, 5}是数组值的字面量，(int [])类似于强制的类型转换，告诉编译器怎么理解这组值。

字符串

简介

C 语言没有单独的字符串类型，字符串被当作字符数组，即char类型的数组。比如，字符串“Hello”是当作数组{'H', 'e', 'l', 'l', 'o'}处理的。

编译器会给数组分配一段连续内存，所有字符储存在相邻的内存单元之中。在字符串结尾，C 语言会自动添加一个全是二进制0的字节，写作\0字符，表示字符串结束。字符\0不同于字符0，前者的 ASCII 码是0（二进制形式00000000），后者的 ASCII 码是48（二进制形式00110000）。所以，字符串“Hello”实际储存的数组是{'H', 'e', 'l', 'l', 'o', '\0'}。

所有字符串的最后一个字符，都是\0。这样做的好处是，C 语言不需要知道字符串的长度，就可以读取内存里面的字符串，只要发现有一个字符是\0，那么就知道字符串结束了。

1	char localString[10];

上面示例声明了一个10个成员的字符数组，可以当作字符串。由于必须留一个位置给\0，所以最多只能容纳9个字符的字符串。

字符串写成数组的形式，是非常麻烦的。C 语言提供了一种简写法，双引号之中的字符，会被自动视为字符数组。

{'H', 'e', 'l', 'l', 'o', '\0'}

// 等价于
"Hello"

上面两种字符串的写法是等价的，内部存储方式都是一样的。双引号里面的字符串，不用自己添加结尾字符\0，C 语言会自动添加。

注意，双引号里面是字符串，单引号里面是字符，两者不能互换。如果把Hello放在单引号里面，编译器会报错。

1 2	// 报错 'Hello'

另一方面，即使双引号里面只有一个字符（比如"a"），也依然被处理成字符串（存储为2个字节），而不是字符'a'（存储为1个字节）。

如果字符串内部包含双引号，则该双引号需要使用反斜杠转义。

1	"She replied, \"It does.\""

反斜杠还可以表示其他特殊字符，比如换行符（\n）、制表符（\t）等。

1	"Hello, world!\n"

如果字符串过长，可以在需要折行的地方，使用反斜杠（\）结尾，将一行拆成多行。

1 2	"hello \ world"

上面示例中，第一行尾部的反斜杠，将字符串拆成两行。

上面这种写法有一个缺点，就是第二行必须顶格书写，如果想包含缩进，那么缩进也会被计入字符串。为了解决这个问题，C 语言允许合并多个字符串字面量，只要这些字符串之间没有间隔，或者只有空格，C 语言会将它们自动合并。

1
2
3

char greeting[50] = "Hello, ""how are you ""today!";
// 等同于
char greeting[50] = "Hello, how are you today!";

这种新写法支持多行字符串的合并。

1
2
3

char greeting[50] = "Hello, "
  "how are you "
  "today!";

printf()使用占位符%s输出字符串。

1	printf("%s\n", "hello world")

字符串变量的声明

字符串变量可以声明成一个字符数组，也可以声明成一个指针，指向字符数组。

// 写法一
char s[14] = "Hello, world!";

// 写法二
char* s = "Hello, world!";

上面两种写法都声明了一个字符串变量s。如果采用第一种写法，由于字符数组的长度可以让编译器自动计算，所以声明时可以省略字符数组的长度。

1	char s[] = "Hello, world!";

上面示例中，编译器会将数组s的长度指定为14，正好容纳后面的字符串。

字符数组的长度，可以大于字符串的实际长度。

1	char s[50] = "hello";

上面示例中，字符数组s的长度是50，但是字符串“hello”的实际长度只有6（包含结尾符号\0），所以后面空出来的44个位置，都会被初始化为\0。

字符数组的长度，不能小于字符串的实际长度。

1	char s[5] = "hello";

上面示例中，字符串数组s的长度是5，小于字符串“hello”的实际长度6，这时编译器会报错。因为如果只将前5个字符写入，而省略最后的结尾符号\0，这很可能导致后面的字符串相关代码出错。

字符指针和字符数组，这两种声明字符串变量的写法基本是等价的，但是有两个差异。

第一个差异是，指针指向的字符串，在 C 语言内部被当作常量，不能修改字符串本身。

1 2	char* s = "Hello, world!"; s[0] = 'z'; // 错误

上面代码使用指针，声明了一个字符串变量，然后修改了字符串的第一个字符。这种写法是错的，会导致难以预测的后果，执行时很可能会报错。

如果使用数组声明字符串变量，就没有这个问题，可以修改数组的任意成员。

1 2	char s[] = "Hello, world!"; s[0] = 'z';

为什么字符串声明为指针时不能修改，声明为数组时就可以修改？原因是系统会将字符串的字面量保存在内存的常量区，这个区是不允许用户修改的。声明为指针时，指针变量存储的只是一个指向常量区的内存地址，因此用户不能通过这个地址去修改常量区。但是，声明为数组时，编译器会给数组单独分配一段内存，字符串字面量会被编译器解释成字符数组，逐个字符写入这段新分配的内存之中，而这段新内存是允许修改的。

为了提醒用户，字符串声明为指针后不得修改，可以在声明时使用const说明符，保证该字符串是只读的。

1	const char* s = "Hello, world!";

上面字符串声明为指针时，使用了const说明符，就保证了该字符串无法修改。一旦修改，编译器肯定会报错。

第二个差异是，指针变量可以指向其它字符串。

1 2	char* s = "hello"; s = "world";

上面示例中，字符指针可以指向另一个字符串。

但是，字符数组变量不能指向另一个字符串。

1 2	char s[] = "hello"; s = "world"; // 报错

上面示例中，字符数组的数组名，总是指向初始化时的字符串地址，不能修改。

同样的原因，声明字符数组后，不能直接用字符串赋值。

1 2	char s[10]; s = "abc"; // 错误

上面示例中，不能直接把字符串赋值给字符数组变量，会报错。原因是字符数组的变量名，跟所指向的数组是绑定的，不能指向另一个地址。

为什么数组变量不能赋值为另一个数组？原因是数组变量所在的地址无法改变，或者说，编译器一旦为数组变量分配地址后，这个地址就绑定这个数组变量了，这种绑定关系是不变的。C 语言也因此规定，数组变量是一个不可修改的左值，即不能用赋值运算符为它重新赋值。

想要重新赋值，必须使用 C 语言原生提供的strcpy()函数，通过字符串拷贝完成赋值。这样做以后，数组变量的地址还是不变的，即strcpy()只是在原地址写入新的字符串，而不是让数组变量指向新的地址。

1 2	char s[10]; strcpy(s, "abc");

上面示例中，strcpy()函数把字符串abc拷贝给变量s，这个函数的详细用法会在后面介绍。

strlen()

strlen()函数返回字符串的字节长度，不包括末尾的空字符\0。该函数的原型如下。

1 2	// string.h size_t strlen(const char* s);

它的参数是字符串变量，返回的是size_t类型的无符号整数，除非是极长的字符串，一般情况下当作int类型处理即可。下面是一个用法实例。

1 2	char* str = "hello"; int len = strlen(str); // 5

strlen()的原型在标准库的string.h文件中定义，使用时需要加载头文件string.h。

#include <stdio.h>
#include <string.h>

int main(void) {
  char* s = "Hello, world!";
  printf("The string is %zd characters long.\n", strlen(s));
}

注意，字符串长度（strlen()）与字符串变量长度（sizeof()），是两个不同的概念。

1
2
3

char s[50] = "hello";
printf("%d\n", strlen(s));  // 5
printf("%d\n", sizeof(s));  // 50

上面示例中，字符串长度是5，字符串变量长度是50。

如果不使用这个函数，可以通过判断字符串末尾的\0，自己计算字符串长度。

int my_strlen(char *s) {
  int count = 0;
  while (s[count] != '\0')
    count++;
  return count;
}

strcpy()

字符串的复制，不能使用赋值运算符，直接将一个字符串赋值给字符数组变量。

char str1[10];
char str2[10];

str1 = "abc"; // 报错
str2 = str1;  // 报错

上面两种字符串的复制写法，都是错的。因为数组的变量名是一个固定的地址，不能修改，使其指向另一个地址。

如果是字符指针，赋值运算符（=）只是将一个指针的地址复制给另一个指针，而不是复制字符串。

char* s1;
char* s2;

s1 = "abc";
s2 = s1;

上面代码可以运行，结果是两个指针变量s1和s2指向同一字符串，而不是将字符串s2的内容复制给s1。

C 语言提供了strcpy()函数，用于将一个字符串的内容复制到另一个字符串，相当于字符串赋值。该函数的原型定义在string.h头文件里面。

1	strcpy(char dest[], const char source[])

strcpy()接受两个参数，第一个参数是目的字符串数组，第二个参数是源字符串数组。复制字符串之前，必须要保证第一个参数的长度不小于第二个参数，否则虽然不会报错，但会溢出第一个字符串变量的边界，发生难以预料的结果。第二个参数的const说明符，表示这个函数不会修改第二个字符串。

#include <stdio.h>
#include <string.h>

int main(void) {
  char s[] = "Hello, world!";
  char t[100];

  strcpy(t, s);

  t[0] = 'z';
  printf("%s\n", s);  // "Hello, world!"
  printf("%s\n", t);  // "zello, world!"
}

上面示例将变量s的值，拷贝一份放到变量t，变成两个不同的字符串，修改一个不会影响到另一个。另外，变量t的长度大于s，复制后多余的位置（结束标志\0后面的位置）都为随机值。

strcpy()也可以用于字符数组的赋值。

1 2	char str[10]; strcpy(str, "abcd");

上面示例将字符数组变量，赋值为字符串“abcd”。

strcpy()的返回值是一个字符串指针（即char*），指向第一个参数。

char* s1 = "beast";
char s2[40] = "Be the best that you can be.";
char* ps;

ps = strcpy(s2 + 7, s1);

puts(s2); // Be the beast
puts(ps); // beast

上面示例中，从s2的第7个位置开始拷贝字符串beast，前面的位置不变。这导致s2后面的内容都被截去了，因为会连beast结尾的空字符一起拷贝。strcpy()返回的是一个指针，指向拷贝开始的位置。

strcpy()返回值的另一个用途，是连续为多个字符数组赋值。

1	strcpy(str1, strcpy(str2, "abcd"));

上面示例调用两次strcpy()，完成两个字符串变量的赋值。

另外，strcpy()的第一个参数最好是一个已经声明的数组，而不是声明后没有进行初始化的字符指针。

1 2	char* str; strcpy(str, "hello world"); // 错误

上面的代码是有问题的。strcpy()将字符串分配给指针变量str，但是str并没有进行初始化，指向的是一个随机的位置，因此字符串可能被复制到任意地方。

如果不用strcpy()，自己实现字符串的拷贝，可以用下面的代码。

char* strcpy(char* dest, const char* source) {
  char* ptr = dest;
  while (*dest++ = *source++);
  return ptr;
}

int main(void) {
  char str[25];
  strcpy(str, "hello world");
  printf("%s\n", str);
  return 0;
}

上面代码中，关键的一行是while (*dest++ = *source++)，这是一个循环，依次将source的每个字符赋值给dest，然后移向下一个位置，直到遇到\0，循环判断条件不再为真，从而跳出循环。其中，*dest++这个表达式等同于*(dest++)，即先返回dest这个地址，再进行自增运算移向下一个位置，而*dest可以对当前位置赋值。

strcpy()函数有安全风险，因为它并不检查目标字符串的长度，是否足够容纳源字符串的副本，可能导致写入溢出。如果不能保证不会发生溢出，建议使用strncpy()函数代替。

strncpy()

strncpy()跟strcpy()的用法完全一样，只是多了第3个参数，用来指定复制的最大字符数，防止溢出目标字符串变量的边界。

char *strncpy(
  char *dest, 
  char *src, 
  size_t n
);

上面原型中，第三个参数n定义了复制的最大字符数。如果达到最大字符数以后，源字符串仍然没有复制完，就会停止复制，这时目的字符串结尾将没有终止符\0，这一点务必注意。如果源字符串的字符数小于n，则strncpy()的行为与strcpy()完全一致。

1 2	strncpy(str1, str2, sizeof(str1) - 1); str1[sizeof(str1) - 1] = '\0';

上面示例中，字符串str2复制给str1，但是复制长度最多为str1的长度减去1，str1剩下的最后一位用于写入字符串的结尾标志\0。这是因为strncpy()不会自己添加\0，如果复制的字符串片段不包含结尾标志，就需要手动添加。

strncpy()也可以用来拷贝部分字符串。

char s1[40];
char s2[12] = "hello world";

strncpy(s1, s2, 5);
s1[5] = '\0';

printf("%s\n", s1); // hello

上面示例中，指定只拷贝前5个字符。

strcat()

strcat()函数用于连接字符串。它接受两个字符串作为参数，把第二个字符串的副本添加到第一个字符串的末尾。这个函数会改变第一个字符串，但是第二个字符串不变。

该函数的原型定义在string.h头文件里面。

1	char* strcat(char* s1, const char* s2);

strcat()的返回值是一个字符串指针，指向第一个参数。

char s1[12] = "hello";
char s2[6] = "world";

strcat(s1, s2);
puts(s1); // "helloworld"

上面示例中，调用strcat()以后，可以看到字符串s1的值变了。

注意，strcat()的第一个参数的长度，必须足以容纳添加第二个参数字符串。否则，拼接后的字符串会溢出第一个字符串的边界，写入相邻的内存单元，这是很危险的，建议使用下面的strncat()代替。

strncat()

strncat()用于连接两个字符串，用法与strncat()完全一致，只是增加了第三个参数，指定最大添加的字符数。在添加过程中，一旦达到指定的字符数，或者在源字符串中遇到空字符\0，就不再添加了。它的原型定义在string.h头文件里面。

int strncat(
  const char* dest,
  const char* src,
  size_t n
);

strncat()返回第一个参数，即目标字符串指针。

为了保证连接后的字符串，不超过目标字符串的长度，strncat()通常会写成下面这样。

strncat(
  str1, 
  str2, 
  sizeof(str1) - strlen(str1) - 1
);

strncat()总是会在拼接结果的结尾，自动添加空字符\0，所以第三个参数的最大值，应该是str1的变量长度减去str1的字符串长度，再减去1。下面是一个用法实例。

char s1[10] = "Monday";
char s2[8] = "Tuesday";

strncat(s1, s2, 3);
puts(s1); // "MondayTue"

上面示例中，s1的变量长度是10，字符长度是6，两者相减后再减去1，得到3，表明s1最多可以再添加三个字符，所以得到的结果是MondayTue。

strcmp()

如果要比较两个字符串，无法直接比较，只能一个个字符进行比较，C 语言提供了strcmp()函数。

strcmp()函数用于比较两个字符串的内容。该函数的原型如下，定义在string.h头文件里面。

1	int strcmp(const char* s1, const char* s2);

按照字典顺序，如果两个字符串相同，返回值为0；如果s1小于s2，strcmp()返回值小于0；如果s1大于s2，返回值大于0。

下面是一个用法示例。

// s1 = Happy New Year
// s2 = Happy New Year
// s3 = Happy Holidays

strcmp(s1, s2) // 0
strcmp(s1, s3) // 大于 0
strcmp(s3, s1) // 小于 0

注意，strcmp()只用来比较字符串，不用来比较字符。因为字符就是小整数，直接用相等运算符（==）就能比较。所以，不要把字符类型（char）的值，放入strcmp()当作参数。

strncmp()

由于strcmp()比较的是整个字符串，C 语言又提供了strncmp()函数，只比较到指定的位置。

该函数增加了第三个参数，指定了比较的字符数。它的原型定义在string.h头文件里面。

int strncmp(
  const char* s1,
  const char* s2, 
  size_t n
);

它的返回值与strcmp()一样。如果两个字符串相同，返回值为0；如果s1小于s2，strcmp()返回值小于0；如果s1大于s2，返回值大于0。

下面是一个例子。

char s1[12] = "hello world";
char s2[12] = "hello C";

if (strncmp(s1, s2, 5) == 0) {
  printf("They all have hello.\n");
}

上面示例只比较两个字符串的前5个字符。

sprintf()，snprintf()

sprintf()函数跟printf()类似，但是用于将数据写入字符串，而不是输出到显示器。该函数的原型定义在stdio.h头文件里面。

1	int sprintf(char* s, const char* format, ...);

sprintf()的第一个参数是字符串指针变量，其余参数和printf()相同，即第二个参数是格式字符串，后面的参数是待写入的变量列表。

char first[6] = "hello";
char last[6] = "world";
char s[40];

sprintf(s, "%s %s", first, last);

printf("%s\n", s); // hello world

上面示例中，sprintf()将输出内容组合成“hello world”，然后放入了变量s。

sprintf()的返回值是写入变量的字符数量（不计入尾部的空字符\0）。如果遇到错误，返回负值。

sprintf()有严重的安全风险，如果写入的字符串过长，超过了目标字符串的长度，sprintf()依然会将其写入，导致发生溢出。为了控制写入的字符串的长度，C 语言又提供了另一个函数snprintf()。

snprintf()只比sprintf()多了一个参数n，用来控制写入变量的字符串不超过n - 1个字符，剩下一个位置写入空字符\0。下面是它的原型。

1	int snprintf(chars, size_t n, const char format, ...);

snprintf()总是会自动写入字符串结尾的空字符。如果你尝试写入的字符数超过指定的最大字符数，snprintf()会写入 n - 1 个字符，留出最后一个位置写入空字符。

下面是一个例子。

1	snprintf(s, 12, "%s %s", "hello", "world");

上面的例子中，snprintf()的第二个参数是12，表示写入字符串的最大长度不超过12（包括尾部的空字符）。

snprintf()的返回值是写入变量的字符数量（不计入尾部的空字符\0），应该小于n。如果遇到错误，返回负值。

字符串数组

如果一个数组的每个成员都是一个字符串，需要通过二维的字符数组实现。每个字符串本身是一个字符数组，多个字符串再组成一个数组。

char weekdays[7][10] = {
  "Monday",
  "Tuesday",
  "Wednesday",
  "Thursday",
  "Friday",
  "Saturday",
  "Sunday"
};

上面示例就是一个字符串数组，一共包含7个字符串，所以第一维的长度是7。其中，最长的字符串的长度是10（含结尾的终止符\0），所以第二维的长度统一设为10。

因为第一维的长度，编译器可以自动计算，所以可以省略。

char weekdays[][10] = {
  "Monday",
  "Tuesday",
  "Wednesday",
  "Thursday",
  "Friday",
  "Saturday",
  "Sunday"
};

上面示例中，二维数组第一维的长度，可以由编译器根据后面的赋值，自动计算，所以可以不写。

数组的第二维，长度统一定为10，有点浪费空间，因为大多数成员的长度都小于10。解决方法就是把数组的第二维，从字符数组改成字符指针。

char* weekdays[] = {
  "Monday",
  "Tuesday",
  "Wednesday",
  "Thursday",
  "Friday",
  "Saturday",
  "Sunday"
};

上面的字符串数组，其实是一个一维数组，成员就是7个字符指针，每个指针指向一个字符串（字符数组）。

遍历字符串数组的写法如下。

1
2
3

for (int i = 0; i < 7; i++) {
  printf("%s\n", weekdays[i]);
}

C 语言的内存管理

简介

C 语言的内存管理，分成两部分。一部分是系统管理的，另一部分是用户手动管理的。

系统管理的内存，主要是函数内部的变量（局部变量）。这部分变量在函数运行时进入内存，函数运行结束后自动从内存卸载。这些变量存放的区域称为”栈“（stack），”栈“所在的内存是系统自动管理的。

用户手动管理的内存，主要是程序运行的整个过程中都存在的变量（全局变量），这些变量需要用户手动从内存释放。如果使用后忘记释放，它就一直占用内存，直到程序退出，这种情况称为”内存泄漏“（memory leak）。这些变量所在的内存称为”堆“（heap），”堆“所在的内存是用户手动管理的。

void 指针

前面章节已经说过了，每一块内存都有地址，通过指针变量可以获取指定地址的内存块。指针变量必须有类型，否则编译器无法知道，如何解读内存块保存的二进制数据。但是，向系统请求内存的时候，有时不确定会有什么样的数据写入内存，需要先获得内存块，稍后再确定写入的数据类型。

为了满足这种需求，C 语言提供了一种不定类型的指针，叫做 void 指针。它只有内存块的地址信息，没有类型信息，等到使用该块内存的时候，再向编译器补充说明，里面的数据类型是什么。

另一方面，void 指针等同于无类型指针，可以指向任意类型的数据，但是不能解读数据。void 指针与其他所有类型指针之间是互相转换关系，任一类型的指针都可以转为 void 指针，而 void 指针也可以转为任一类型的指针。

int x = 10;

void* p = &x; // 整数指针转为 void 指针
int* q = p; // void 指针转为整数指针

上面示例演示了，整数指针和 void 指针如何互相转换。&x是一个整数指针，p是 void 指针，赋值时&x的地址会自动解释为 void 类型。同样的，p再赋值给整数指针q时，p的地址会自动解释为整数指针。

注意，由于不知道 void 指针指向什么类型的值，所以不能用*运算符取出它指向的值。

char a = 'X';
void* p = &a;

printf("%c\n", *p); // 报错

上面示例中，p是一个 void 指针，所以这时无法用*p取出指针指向的值。

void 指针的重要之处在于，很多内存相关函数的返回值就是 void 指针，只给出内存块的地址信息，所以放在最前面进行介绍。

malloc()

malloc()函数用于分配内存，该函数向系统要求一段内存，系统就在“堆”里面分配一段连续的内存块给它。它的原型定义在头文件stdlib.h。

1	void* malloc(size_t size)

它接受一个非负整数作为参数，表示所要分配的内存字节数，返回一个 void 指针，指向分配好的内存块。这是非常合理的，因为malloc()函数不知道，将要存储在该块内存的数据是什么类型，所以只能返回一个无类型的 void 指针。

可以使用malloc()为任意类型的数据分配内存，常见的做法是先使用sizeof()函数，算出某种数据类型所需的字节长度，然后再将这个长度传给malloc()。

int* p = malloc(sizeof(int));

*p = 12;
printf("%d\n", *p); // 12

上面示例中，先为整数类型分配一段内存，然后将整数12放入这段内存里面。这个例子其实不需要使用malloc()，因为 C 语言会自动为整数（本例是12）提供内存。

有时候为了增加代码的可读性，可以对malloc()返回的指针进行一次强制类型转换。

1	int* p = (int*) malloc(sizeof(int));

上面代码将malloc()返回的 void 指针，强制转换成了整数指针。

由于sizeof()的参数可以是变量，所以上面的例子也可以写成下面这样。

1	int* p = (int) malloc(sizeof(p));

malloc()分配内存有可能分配失败，这时返回常量 NULL。Null 的值为0，是一个无法读写的内存地址，可以理解成一个不指向任何地方的指针。它在包括stdlib.h等多个头文件里面都有定义，所以只要可以使用malloc()，就可以使用NULL。由于存在分配失败的可能，所以最好在使用malloc()之后检查一下，是否分配成功。

int* p = malloc(sizeof(int));

if (p == NULL) {
  // 内存分配失败
}

// or
if (!p) {
  //...
}

上面示例中，通过判断返回的指针p是否为NULL，确定malloc()是否分配成功。

malloc()最常用的场合，就是为数组和自定义数据结构分配内存。

int* p = (int*) malloc(sizeof(int) * 10);

for (int i = 0; i < 10; i++)
  p[i] = i * 5;

上面示例中，p是一个整数指针，指向一段可以放置10个整数的内存，所以可以用作数组。

malloc()用来创建数组，有一个好处，就是它可以创建动态数组，即根据成员数量的不同，而创建长度不同的数组。

1	int* p = (int) malloc(n sizeof(int));

上面示例中，malloc()可以根据变量n的不同，动态为数组分配不同的大小。

注意，malloc()不会对所分配的内存进行初始化，里面还保存着原来的值。如果没有初始化，就使用这段内存，可能从里面读到以前的值。程序员要自己负责初始化，比如，字符串初始化可以使用strcpy()函数。

char* p = malloc(4);
strcpy(p, "abc");

// or
p = "abc";

上面示例中，字符指针p指向一段4个字节的内存，strcpy()将字符串“abc”拷贝放入这段内存，完成了这段内存的初始化。

free()

free()用于释放malloc()函数分配的内存，将这块内存还给系统以便重新使用，否则这个内存块会一直占用到程序运行结束。该函数的原型定义在头文件stdlib.h里面。

1	void free(void* block)

上面代码中，free()的参数是malloc()返回的内存地址。下面就是用法实例。

int* p = (int*) malloc(sizeof(int));

*p = 12;
free(p);

注意，分配的内存块一旦释放，就不应该再次操作已经释放的地址，也不应该再次使用free()对该地址释放第二次。

一个很常见的错误是，在函数内部分配了内存，但是函数调用结束时，没有使用free()释放内存。

void gobble(double arr[], int n) {
  double* temp = (double*) malloc(n * sizeof(double));
  // ...
}

上面示例中，函数gobble()内部分配了内存，但是没有写free(temp)。这会造成函数运行结束后，占用的内存块依然保留，如果多次调用gobble()，就会留下多个内存块。并且，由于指针temp已经消失了，也无法访问这些内存块，再次使用。

calloc()

calloc()函数的作用与malloc()相似，也是分配内存块。该函数的原型定义在头文件stdlib.h。

两者的区别主要有两点：

（1）calloc()接受两个参数，第一个参数是某种数据类型的值的数量，第二个是该数据类型的单位字节长度。

1	void* calloc(size_t n, size_t size);

calloc()的返回值也是一个 void 指针。分配失败时，返回 NULL。

（2）calloc()会将所分配的内存全部初始化为0。malloc()不会对内存进行初始化，如果想要初始化为0，还要额外调用memset()函数。

int* p = calloc(10, sizeof(int));

// 等同于
int* p = malloc(sizeof(int) * 10);
memset(p, 0, sizeof(int) * 10);

上面示例中，calloc()相当于malloc() + memset()。

calloc()分配的内存块，也要使用free()释放。

realloc()

realloc()函数用于修改已经分配的内存块的大小，可以放大也可以缩小，返回一个指向新的内存块的指针。如果分配不成功，返回 NULL。该函数的原型定义在头文件stdlib.h。

1	void* realloc(void* block, size_t size)

它接受两个参数。

block：已经分配好的内存块指针（由malloc()或calloc()或realloc()产生）。
size：该内存块的新大小，单位为字节。

realloc()可能返回一个全新的地址（数据也会自动复制过去），也可能返回跟原来一样的地址。realloc()优先在原有内存块上进行缩减，尽量不移动数据，所以通常是返回原先的地址。如果新内存块小于原来的大小，则丢弃超出的部分；如果大于原来的大小，则不对新增的部分进行初始化（程序员可以自动调用memset()）。

下面是一个例子，b是数组指针，realloc()动态调整它的大小。

int* b;

b = malloc(sizeof(int) * 10);
b = realloc(b, sizeof(int) * 2000);

上面示例中，指针b原来指向10个成员的整数数组，使用realloc()调整为2000个成员的数组。这就是手动分配数组内存的好处，可以在运行时随时调整数组的长度。

realloc()的第一个参数可以是 NULL，这时就相当于新建一个指针。

1
2
3

char* p = realloc(NULL, 3490);
// 等同于
char* p = malloc(3490);

如果realloc()的第二个参数是0，就会释放掉内存块。

由于有分配失败的可能，所以调用realloc()以后，最好检查一下它的返回值是否为 NULL。分配失败时，原有内存块中的数据不会发生改变。

float* new_p = realloc(p, sizeof(*p * 40));

if (new_p == NULL) {
  printf("Error reallocing\n");
  return 1;
}

注意，realloc()不会对内存块进行初始化。

restrict 说明符

声明指针变量时，可以使用restrict说明符，告诉编译器，该块内存区域只有当前指针一种访问方式，其他指针不能读写该块内存。这种指针称为“受限指针”（restrict pointer）。

1 2	int* restrict p; p = malloc(sizeof(int));

上面示例中，声明指针变量p时，加入了restrict说明符，使得p变成了受限指针。后面，当p指向malloc()函数返回的一块内存区域，就味着，该区域只有通过p来访问，不存在其他访问方式。

int* restrict p;
p = malloc(sizeof(int));

int* q = p;
*q = 0; // 未定义行为

上面示例中，另一个指针q与受限指针p指向同一块内存，现在该内存有p和q两种访问方式。这就违反了对编译器的承诺，后面通过*q对该内存区域赋值，会导致未定义行为。

memcpy()

memcpy()用于将一块内存拷贝到另一块内存。该函数的原型定义在头文件string.h。

void* memcpy(
  void* restrict dest, 
  void* restrict source, 
  size_t n
);

上面代码中，dest是目标地址，source是源地址，第三个参数n是要拷贝的字节数n。如果要拷贝10个 double 类型的数组成员，n就等于10 * sizeof(double)，而不是10。该函数会将从source开始的n个字节，拷贝到dest。

dest和source都是 void 指针，表示这里不限制指针类型，各种类型的内存数据都可以拷贝。两者都有 restrict 关键字，表示这两个内存块不应该有互相重叠的区域。

memcpy()的返回值是第一个参数，即目标地址的指针。

因为memcpy()只是将一段内存的值，复制到另一段内存，所以不需要知道内存里面的数据是什么类型。下面是复制字符串的例子。

#include <stdio.h>
#include <string.h>

int main(void) {
  char s[] = "Goats!";
  char t[100];

  memcpy(t, s, sizeof(s));  // 拷贝7个字节，包括终止符

  printf("%s\n", t);  // "Goats!"

  return 0;
}

上面示例中，字符串s所在的内存，被拷贝到字符数组t所在的内存。

memcpy()可以取代strcpy()进行字符串拷贝，而且是更好的方法，不仅更安全，速度也更快，它不检查字符串尾部的\0字符。

char* s = "hello world";

size_t len = strlen(s) + 1;
char *c = malloc(len);

if (c) {
  // strcpy() 的写法
  strcpy(c, s);

  // memcpy() 的写法
  memcpy(c, s, len);
}

上面示例中，两种写法的效果完全一样，但是memcpy()的写法要好于strcpy()。

使用 void 指针，也可以自定义一个复制内存的函数。

void* my_memcpy(void* dest, void* src, int byte_count) {
  char* s = src;
  char* d = dest;

  while (byte_count--) {
    *d++ = *s++;
  }

  return dest;

}

上面示例中，不管传入的dest和src是什么类型的指针，将它们重新定义成一字节的 Char 指针，这样就可以逐字节进行复制。*d++ = *s++语句相当于先执行*d = *s（源字节的值复制给目标字节），然后各自移动到下一个字节。最后，返回复制后的dest指针，便于后续使用。

memmove()

memmove()函数用于将一段内存数据复制到另一段内存。它跟memcpy()的主要区别是，它允许目标区域与源区域有重叠。如果发生重叠，源区域的内容会被更改；如果没有重叠，它与memcpy()行为相同。

该函数的原型定义在头文件string.h。

void* memmove(
  void* dest, 
  void* source, 
  size_t n
);

上面代码中，dest是目标地址，source是源地址，n是要移动的字节数。dest和source都是 void 指针，表示可以移动任何类型的内存数据，两个内存区域可以有重叠。

memmove()返回值是第一个参数，即目标地址的指针。

int a[100];
// ...

memmove(&a[0], &a[1], 99 * sizeof(int));

上面示例中，从数组成员a[1]开始的99个成员，都向前移动一个位置。

下面是另一个例子。

char x[] = "Home Sweet Home";

// 输出 Sweet Home Home
printf("%s\n", (char *) memmove(x, &x[5], 10));

上面示例中，从字符串x的5号位置开始的10个字节，就是“Sweet Home”，memmove()将其前移到0号位置，所以x就变成了“Sweet Home Home”。

memcmp()

memcmp()函数用来比较两个内存区域。它的原型定义在string.h。

int memcmp(
  const void* s1,
  const void* s2,
  size_t n
);

它接受三个参数，前两个参数是用来比较的指针，第三个参数指定比较的字节数。

它的返回值是一个整数。两块内存区域的每个字节以字符形式解读，按照字典顺序进行比较，如果两者相同，返回0；如果s1大于s2，返回大于0的整数；如果s1小于s2，返回小于0的整数。

1
2
3

char* s1 = "abc";
char* s2 = "acd";
int r = memcmp(s1, s2, 3); // 小于 0

上面示例比较s1和s2的前三个字节，由于s1小于s2，所以r是一个小于0的整数，一般为-1。

下面是另一个例子。

char s1[] = {'b', 'i', 'g', '\0', 'c', 'a', 'r'};
char s2[] = {'b', 'i', 'g', '\0', 'c', 'a', 't'};

if (memcmp(s1, s2, 3) == 0) // true
if (memcmp(s1, s2, 4) == 0) // true
if (memcmp(s1, s2, 7) == 0) // false

上面示例展示了，memcmp()可以比较内部带有字符串终止符\0的内存区域。

struct 结构

简介

C 语言内置的数据类型，除了最基本的几种原始类型，只有数组属于复合类型，可以同时包含多个值，但是只能包含相同类型的数据，实际使用中并不够用。

实际使用中，主要有下面两种情况，需要更灵活强大的复合类型。

复杂的物体需要使用多个变量描述，这些变量都是相关的，最好有某种机制将它们联系起来。
某些函数需要传入多个参数，如果一个个按照顺序传入，非常麻烦，最好能组合成一个复合结构传入。

为了解决这些问题，C 语言提供了struct关键字，允许自定义复合数据类型，将不同类型的值组合在一起。这样不仅为编程提供方便，也有利于增强代码的可读性。C 语言没有其他语言的对象（object）和类（class）的概念，struct 结构很大程度上提供了对象和类的功能。

下面是struct自定义数据类型的一个例子。

struct fraction {
  int numerator;
  int denominator;
};

上面示例定义了一个分数的数据类型struct fraction，包含两个属性numerator和denominator。

注意，作为一个自定义的数据类型，它的类型名要包括struct关键字，比如上例是struct fraction，单独的fraction没有任何意义，甚至脚本还可以另外定义名为fraction的变量，虽然这样很容易造成混淆。另外，struct语句结尾的分号不能省略，否则很容易产生错误。

定义了新的数据类型以后，就可以声明该类型的变量，这与声明其他类型变量的写法是一样的。

struct fraction f1;

f1.numerator = 22;
f1.denominator = 7;

上面示例中，先声明了一个struct fraction类型的变量f1，这时编译器就会为f1分配内存，接着就可以为f1的不同属性赋值。可以看到，struct 结构的属性通过点（.）来表示，比如numerator属性要写成f1.numerator。

再提醒一下，声明自定义类型的变量时，类型名前面，不要忘记加上struct关键字。也就是说，必须使用struct fraction f1声明变量，不能写成fraction f1。

除了逐一对属性赋值，也可以使用大括号，一次性对 struct 结构的所有属性赋值。

struct car {
  char* name;
  float price;
  int speed;
};

struct car saturn = {"Saturn SL/2", 16000.99, 175};

上面示例中，变量saturn是struct cat类型，大括号里面同时对它的三个属性赋值。如果大括号里面的值的数量，少于属性的数量，那么缺失的属性自动初始化为0。

注意，大括号里面的值的顺序，必须与 struct 类型声明时属性的顺序一致。否则，必须为每个值指定属性名。

1	struct car saturn = {.speed=172, .name="Saturn SL/2"};

上面示例中，初始化的属性少于声明时的属性，这时剩下的那些属性都会初始化为0。

声明变量以后，可以修改某个属性的值。

1 2	struct car saturn = {.speed=172, .name="Saturn SL/2"}; saturn.speed = 168;

上面示例将speed属性的值改成168。

struct 的数据类型声明语句与变量的声明语句，可以合并为一个语句。

struct book {
  char title[500];
  char author[100];
  float value;
} b1;

上面的语句同时声明了数据类型book和该类型的变量b1。如果类型标识符book只用在这一个地方，后面不再用到，这里可以将类型名省略。

struct {
  char title[500];
  char author[100];
  float value;
} b1;

上面示例中，struct声明了一个匿名数据类型，然后又声明了这个类型的变量b1。

与其他变量声明语句一样，可以在声明变量的同时，对变量赋值。

struct {
  char title[500];
  char author[100];
  float value;
} b1 = {"Harry Potter", "J. K. Rowling", 10.0},
  b2 = {"Cancer Ward", "Aleksandr Solzhenitsyn", 7.85};

上面示例中，在声明变量b1和b2的同时，为它们赋值。

下一章介绍的typedef命令可以为 struct 结构指定一个别名，这样使用起来更简洁。

typedef struct cell_phone {
  int cell_no;
  float minutes_of_charge;
} phone;

phone p = {5551234, 5};

上面示例中，phone就是struct cell_phone的别名。

指针变量也可以指向struct结构。

struct book {
  char title[500];
  char author[100];
  float value;
}* b1;

// 或者写成两个语句
struct book {
  char title[500];
  char author[100];
  float value;
};
struct book* b1;

上面示例中，变量b1是一个指针，指向的数据是struct book类型的实例。

struct 结构也可以作为数组成员。

struct fraction numbers[1000];

numbers[0].numerator = 22;
numbers[0].denominator = 7;

上面示例声明了一个有1000个成员的数组numbers，每个成员都是自定义类型fraction的实例。

struct 结构占用的存储空间，不是各个属性存储空间的总和。因为为了计算效率，C 语言的内存占用空间一般来说，都必须是int类型存储空间的倍数。如果int类型的存储是4字节，那么 struct 类型的存储空间就总是4的倍数。

1 2	struct { char a; int b; } s; printf("%d\n", sizeof(s)); // 8

上面示例中，如果按照属性占据的空间相加，变量s的存储空间应该是5个字节。但是，struct 结构的存储空间是int类型的倍数，所以最后的结果是占据8个字节，a属性与b属性之间有3个字节的“空洞”。

struct 的复制

struct 变量可以使用赋值运算符（=），复制给另一个变量，这时会生成一个全新的副本。系统会分配一块新的内存空间，大小与原来的变量相同，把每个属性都复制过去，即原样生成了一份数据。这一点跟数组的复制不一样，务必小心。

struct cat { char name[30]; short age; } a, b;

strcpy(a.name, "Hula");
a.age = 3;

b = a;
b.name[0] = 'M';

printf("%s\n", a.name); // Hula
printf("%s\n", b.name); // Mula

上面示例中，变量b是变量a的副本，两个变量的值是各自独立的，修改掉b.name不影响a.name。

上面这个示例是有前提的，就是 struct 结构的属性必须定义成字符数组，才能复制数据。如果稍作修改，属性定义成字符指针，结果就不一样。

struct cat { char* name; short age; } a, b;

a.name = "Hula";
a.age = 3;

b = a;

上面示例中，name属性变成了一个字符指针，这时a赋值给b，导致b.name也是同样的字符指针，指向同一个地址，也就是说两个属性共享同一个地址。因为这时，struct 结构内部保存的是一个指针，而不是上一个例子的数组，这时复制的就不是字符串本身，而是它的指针。并且，这个时候也没法修改字符串，因为字符指针指向的字符串是不能修改的。

总结一下，赋值运算符（=）可以将 struct 结构每个属性的值，一模一样复制一份，拷贝给另一个 struct 变量。这一点跟数组完全不同，使用赋值运算符复制数组，不会复制数据，只会共享地址。

注意，这种赋值要求两个变量是同一个类型，不同类型的 struct 变量无法互相赋值。

另外，C 语言没有提供比较两个自定义数据结构是否相等的方法，无法用比较运算符（比如==和!=）比较两个数据结构是否相等或不等。

struct 指针

如果将 struct 变量传入函数，函数内部得到的是一个原始值的副本。

#include <stdio.h>

struct turtle {
  char* name;
  char* species;
  int age;
};

void happy(struct turtle t) {
  t.age = t.age + 1;
}

int main() {
  struct turtle myTurtle = {"MyTurtle", "sea turtle", 99};
  happy(myTurtle);
  printf("Age is %i\n", myTurtle.age); // 输出 99
  return 0;
}

上面示例中，函数happy()传入的是一个 struct 变量myTurtle，函数内部有一个自增操作。但是，执行完happy()以后，函数外部的age属性值根本没变。原因就是函数内部得到的是 struct 变量的副本，改变副本影响不到函数外部的原始数据。

通常情况下，开发者希望传入函数的是同一份数据，函数内部修改数据以后，会反映在函数外部。而且，传入的是同一份数据，也有利于提高程序性能。这时就需要将 struct 变量的指针传入函数，通过指针来修改 struct 属性，就可以影响到函数外部。

struct 指针传入函数的写法如下。

void happy(struct turtle* t) {
}

happy(&myTurtle);

上面代码中，t是 struct 结构的指针，调用函数时传入的是指针。struct 类型跟数组不一样，类型标识符本身并不是指针，所以传入时，指针必须写成&myTurtle。

函数内部也必须使用(*t).age的写法，从指针拿到 struct 结构本身。

1
2
3

void happy(struct turtle* t) {
  (*t).age = (*t).age + 1;
}

上面示例中，(*t).age不能写成*t.age，因为点运算符.的优先级高于*。*t.age这种写法会将t.age看成一个指针，然后取它对应的值，会出现无法预料的结果。

现在，重新编译执行上面的整个示例，happy()内部对 struct 结构的操作，就会反映到函数外部。

(*t).age这样的写法很麻烦。C 语言就引入了一个新的箭头运算符（->），可以从 struct 指针上直接获取属性，大大增强了代码的可读性。

1
2
3

void happy(struct turtle* t) {
  t->age = t->age + 1;
}

总结一下，对于 struct 变量名，使用点运算符（.）获取属性；对于 struct 变量指针，使用箭头运算符（->）获取属性。以变量myStruct为例，假设ptr是它的指针，那么下面三种写法是同一回事。

1 2	// ptr == &myStruct myStruct.prop == (*ptr).prop == ptr->prop

struct 的嵌套

struct 结构的成员可以是另一个 struct 结构。

struct species {
  char* name;
  int kinds;
};

struct fish {
  char* name;
  int age;
  struct species breed;
};

上面示例中，fish的属性breed是另一个 struct 结构species。

赋值的时候有多种写法。

// 写法一
struct fish shark = {"shark", 9, {"Selachimorpha", 500}};

// 写法二
struct species myBreed = {"Selachimorpha", 500};
struct fish shark = {"shark", 9, myBreed};

// 写法三
struct fish shark = {
  .name="shark",
  .age=9,
  .breed={"Selachimorpha", 500}
};

// 写法四
struct fish shark = {
  .name="shark",
  .age=9,
  .breed.name="Selachimorpha",
  .breed.kinds=500
};

printf("Shark's species is %s", shark.breed.name);

上面示例展示了嵌套 Struct 结构的四种赋值写法。另外，引用breed属性的内部属性，要使用两次点运算符（shark.breed.name）。

下面是另一个嵌套 struct 的例子。

struct name {
  char first[50];
  char last[50];
};

struct student {
  struct name name;
  short age;
  char sex;
} student1;

strcpy(student1.name.first, "Harry");
strcpy(student1.name.last, "Potter");

// or
struct name myname = {"Harry", "Potter"};
student1.name = myname;

上面示例中，自定义类型student的name属性是另一个自定义类型，如果要引用后者的属性，就必须使用两个.运算符，比如student1.name.first。另外，对字符数组属性赋值，要使用strcpy()函数，不能直接赋值，因为直接改掉字符数组名的地址会报错。

struct 结构内部不仅可以引用其他结构，还可以自我引用，即结构内部引用当前结构。比如，链表结构的节点就可以写成下面这样。

struct node {
  int data;
  struct node* next;
};

上面示例中，node结构的next属性，就是指向另一个node实例的指针。下面，使用这个结构自定义一个数据链表。

struct node {
  int data;
  struct node* next;
};

struct node* head;

// 生成一个三个节点的列表 (11)->(22)->(33)
head = malloc(sizeof(struct node));

head->data = 11;
head->next = malloc(sizeof(struct node));

head->next->data = 22;
head->next->next = malloc(sizeof(struct node));

head->next->next->data = 33;
head->next->next->next = NULL;

// 遍历这个列表
for (struct node *cur = head; cur != NULL; cur = cur->next) {
  printf("%d\n", cur->data);
}

上面示例是链表结构的最简单实现，通过for循环可以对其进行遍历。

位字段

struct 还可以用来定义二进制位组成的数据结构，称为“位字段”（bit field），这对于操作底层的二进制数据非常有用。

typedef struct {
  unsigned int ab:1;
  unsigned int cd:1;
  unsigned int ef:1;
  unsigned int gh:1;
} synth;

synth.ab = 0;
synth.cd = 1;

上面示例中，每个属性后面的:1，表示指定这些属性只占用一个二进制位，所以这个数据结构一共是4个二进制位。

注意，定义二进制位时，结构内部的各个属性只能是整数类型。

实际存储的时候，C 语言会按照int类型占用的字节数，存储一个位字段结构。如果有剩余的二进制位，可以使用未命名属性，填满那些位。也可以使用宽度为0的属性，表示占满当前字节剩余的二进制位，迫使下一个属性存储在下一个字节。

struct {
  unsigned int field1 : 1;
  unsigned int        : 2;
  unsigned int field2 : 1;
  unsigned int        : 0;
  unsigned int field3 : 1;
} stuff;

上面示例中，stuff.field1与stuff.field2之间，有一个宽度为两个二进制位的未命名属性。stuff.field3将存储在下一个字节。

弹性数组成员

很多时候，不能事先确定数组到底有多少个成员。如果声明数组的时候，事先给出一个很大的成员数，就会很浪费空间。C 语言提供了一个解决方法，叫做弹性数组成员（flexible array member）。

如果不能事先确定数组成员的数量时，可以定义一个 struct 结构。

struct vstring {
  int len;
  char chars[];
};

上面示例中，struct vstring结构有两个属性。len属性用来记录数组chars的长度，chars属性是一个数组，但是没有给出成员数量。

chars数组到底有多少个成员，可以在为vstring分配内存时确定。

1 2	struct vstring* str = malloc(sizeof(struct vstring) + n * sizeof(char)); str->len = n;

上面示例中，假定chars数组的成员数量是n，只有在运行时才能知道n到底是多少。然后，就为struct vstring分配它需要的内存：它本身占用的内存长度，再加上n个数组成员占用的内存长度。最后，len属性记录一下n是多少。

这样就可以让数组chars有n个成员，不用事先确定，可以跟运行时的需要保持一致。

弹性数组成员有一些专门的规则。首先，弹性成员的数组，必须是 struct 结构的最后一个属性。另外，除了弹性数组成员，struct 结构必须至少还有一个其他属性。

typedef 命令

简介

typedef命令用来为某个类型起别名。

1	typedef type name;

上面代码中，type代表类型名，name代表别名。

1
2
3

typedef unsigned char BYTE;

BYTE c = 'z';

上面示例中，typedef命令为类型unsign char起别名BYTE，然后就可以使用BYTE声明变量。

typedef 可以一次指定多个别名。

1	typedef int antelope, bagel, mushroom;

上面示例中，一次性为int类型起了三个别名。

typedef 可以为指针起别名。

typedef int* intptr;

int a = 10;
intptr x = &a;

上面示例中，intptr是int*的别名。不过，使用的时候要小心，这样不容易看出来，变量x是一个指针类型。

typedef 也可以用来为数组类型起别名。

1
2
3

typedef int five_ints[5];

five_ints x = {11, 22, 33, 44, 55};

上面示例中，five_ints是一个数组类型，包含5个整数的

typedef 为函数起别名的写法如下。

1	typedef signed char (*fp)(void);

上面示例中，类型别名fp是一个指针，代表函数signed char (*)(void)。

主要好处

typedef为类型起别名的好处，主要有下面几点。

（1）更好的代码可读性。

1
2
3

typedef char* STRING;

STRING name;

上面示例为字符指针起别名为STRING，以后使用STRING声明变量时，就可以轻易辨别该变量是字符串。

（2）为 struct、union、enum 等命令定义的复杂数据结构创建别名，从而便于引用。

struct treenode {
  // ...
};

typedef struct treenode* Tree;

上面示例中，Tree为struct treenode*的别名。

typedef 也可以与 struct 定义数据类型的命令写在一起。

typedef struct animal {
  char* name;
  int leg_count, speed;
} animal;

上面示例中，自定义数据类型时，同时使用typedef命令，为struct animal起了一个别名animal。

这种情况下，C 语言允许省略 struct 命令后面的类型名。

typedef struct {
  char *name;
  int leg_count, speed;
} animal;

上面示例相当于为一个匿名的数据类型起了别名animal。

（3）typedef 方便以后为变量改类型。

1
2
3

typedef float app_float;

app_float f1, f2, f3;

上面示例中，变量f1、f2、f3的类型都是float。如果以后需要为它们改类型，只需要修改typedef语句即可。

1	typedef long double app_float;

上面命令将变量f1、f2、f3的类型都改为long double。

（4）可移植性

某一个值在不同计算机上的类型，可能是不一样的。

1	int i = 100000;

上面代码在32位整数的计算机没有问题，但是在16位整数的计算机就会出错。

C 语言的解决办法，就是提供了类型别名，在不同计算机上会解释成不同类型，比如int32_t。

1	int32_t i = 100000;

上面示例将变量i声明成int32_t类型，保证它在不同计算机上都是32位宽度，移植代码时就不会出错。

这一类的类型别名都是用 typedef 定义的。下面是类似的例子。

1
2
3

typedef long int ptrdiff_t;
typedef unsigned long int size_t;
typedef int wchar_t;

这些整数类型别名都放在头文件stdint.h，不同架构的计算机只需修改这个头文件即可，而无需修改代码。

因此，typedef有助于提高代码的可移植性，使其能适配不同架构的计算机。

（5）简化类型声明

C 语言有些类型声明相当复杂，比如下面这个。

1	char ((x(void))[5])(void);

typedef 可以简化复杂的类型声明，使其更容易理解。首先，最外面一层起一个类型别名。

1 2	typedef char (Func)(void); Func (x(void))[5];

这个看起来还是有点复杂，就为里面一层也定义一个别名。

1
2
3

typedef char (*Func)(void);
typedef Func Arr[5];
Arr* x(void);

上面代码就比较容易解读了。

x是一个函数，返回一个指向 Arr 类型的指针。
Arr是一个数组，有5个成员，每个成员是Func类型。
Func是一个函数指针，指向一个无参数、返回字符值的函数。

Union 结构

有时需要一种数据结构，不同的场合表示不同的数据类型。比如，如果只用一种数据结构表示水果的“量”，这种结构就需要有时是整数（6个苹果），有时是浮点数（1.5公斤草莓）。

C 语言提供了 Union 结构，用来自定义可以灵活变更的数据结构。它内部可以包含各种属性，但同一时间只能有一个属性，因为所有属性都保存在同一个内存地址，后面写入的属性会覆盖前面的属性。这样做的最大好处是节省空间。

union quantity {
  short count;
  float weight;
  float volume;
};

上面示例中，union命令定义了一个包含三个属性的数据类型quantity。虽然包含三个属性，但是同一时间只能取到一个属性。最后赋值的属性，就是可以取到值的那个属性。

使用时，声明一个该类型的变量。

// 写法一
union quantity q;
q.count = 4;

// 写法二
union quantity q = {.count=4};

// 写法三
union quantity q = {4};

上面代码展示了为 Union 结构赋值的三种写法。最后一种写法不指定属性名，就会赋值给第一个属性。

执行完上面的代码以后，q.count可以取到值，另外两个属性取不到值。

1 2	printf("count is %i\n", q.count); // count is 4 printf("weight is %f\n", q.weight); // 未定义行为

如果要让q.weight属性可以取到值，就要先为它赋值。

1 2	q.weight = 0.5; printf("weight is %f\n", q.weight); // weight is 0.5

一旦为其他属性赋值，原先可以取到值的q.count属性就不再有效了。除了这一点，Union 结构的其他用法与 Struct 结构，基本上是一致的。

Union 结构也支持指针运算符->。

union quantity {
  short count;
  float weight;
  float volume;
};

union quantity q;
q.count = 4;

union quantity* ptr;
ptr = &q;

printf("%d\n", ptr->count); // 4

上面示例中，ptr是q的指针，那么ptr->count等同于q.count。

Union 结构指针与它的属性有关，当前哪个属性能够取到值，它的指针就是对应的数据类型。

union foo {
  int a;
  float b;
} x;

int* foo_int_p = (int *)&x;
float* foo_float_p = (float *)&x;

x.a = 12;
printf("%d\n", x.a);           // 12
printf("%d\n", *foo_int_p);    // 12

x.b = 3.141592;
printf("%f\n", x.b);           // 3.141592
printf("%f\n", *foo_float_p);  // 3.141592

上面示例中，&x是 foo 结构的指针，它的数据类型完全由当前赋值的属性决定。

typedef 命令可以为 Union 数据类型起别名。

typedef union {
  short count;
  float weight;
  float volume;
} quantity;

上面示例中，union命令定义了一个包含三个属性的数据类型，typedef命令为它起别名为quantity。

Union 结构的好处，主要是节省空间。它将一段内存空间，重用于不同类型的数据。定义了三个属性，但同一时间只用到一个，使用 Union 结构就可以节省另外两个属性的空间。Union 结构占用的内存长度，等于它内部最长属性的长度。

Enum 类型

如果一种数据类型的取值只有少数几种可能，并且每种取值都有自己的含义，为了提高代码的可读性，可以将它们定义为 Enum 类型，中文名为枚举。

enum colors {RED, GREEN, BLUE};

printf("%d\n", RED); // 0
printf("%d\n", GREEN);  // 1
printf("%d\n", BLUE);  // 2

上面示例中，假定程序里面需要三种颜色，就可以使用enum命令，把这三种颜色定义成一种枚举类型colors，它只有三种取值可能RED、GREEN、BLUE。这时，这三个名字自动成为整数常量，编译器默认将它们的值设为数字0、1、2。相比之下，RED要比0的可读性好了许多。

注意，Enum 内部的常量名，遵守标识符的命名规范，但是通常都使用大写。

使用时，可以将变量声明为 Enum 类型。

1	enum colors color;

上面代码将变量color声明为enum colors类型。这个变量的值就是常量RED、GREEN、BLUE之中的一个。

1 2	color = BLUE; printf("%i\n", color); // 2

上面代码将变量color的值设为BLUE，这里BLUE就是一个常量，值等于2。

typedef 命令可以为 Enum 类型起别名。

typedef enum {
  SHEEP,
  WHEAT,
  WOOD,
  BRICK,
  ORE
} RESOURCE;

RESOURCE r;

上面示例中，RESOURCE是 Enum 类型的别名。声明变量时，使用这个别名即可。

还有一种不常见的写法，就是声明 Enum 类型时，在同一行里面为变量赋值。

enum {
  SHEEP,
  WHEAT,
  WOOD,
  BRICK,
  ORE
} r = BRICK, s = WOOD;

上面示例中，r的值是3，s的值是2。

由于 Enum 的属性会自动声明为常量，所以有时候使用 Enum 的目的，不是为了自定义一种数据类型，而是为了声明一组常量。这时就可以使用下面这种写法，比较简单。

1
2
3

enum { ONE, TWO };

printf("%d %d", ONE, TWO);  // 0 1

上面示例中，enum是一个关键字，后面跟着一个代码块，常量就在代码内声明。ONE和TWO就是两个 Enum 常量。

常量之间使用逗号分隔。最后一个常量后面的尾逗号，可以省略，也可以保留。

1	enum { ONE, TWO, };

由于Enum 会自动编号，因此可以不必为常量赋值。C 语言会自动从0开始递增，为常量赋值。但是，C 语言也允许为 ENUM 常量指定值，不过只能指定为整数，不能是其他类型。因此，任何可以使用整数的场合，都可以使用 Enum 常量。

1
2
3

enum { ONE = 1, TWO = 2 };

printf("%d %d", ONE, TWO);  // 1 2

Enum 常量可以是不连续的值。

1	enum { X = 2, Y = 18, Z = -2 };

Enum 常量也可以是同一个值。

1	enum { X = 2, Y = 2, Z = 2 };

如果一组常量之中，有些指定了值，有些没有指定。那么，没有指定值的常量会从上一个指定了值的常量，开始自动递增赋值。

enum {
  A,    // 0
  B,    // 1
  C = 4,  // 4
  D,    // 5
  E,    // 6
  F = 3   // 3
  G,    // 4
  H     // 5
}

Enum 的作用域与变量相同。如果是在顶层声明，那么在整个文件内都有效；如果是在代码块内部声明，则只对该代码块有效。如果与使用int声明的常量相比，Enum 的好处是更清晰地表示代码意图。

预处理器（Preprocessor）

简介

C 语言编译器在编译程序之前，会先使用预处理器（preprocessor）处理代码。

预处理器首先会清理代码，进行删除注释、多行的语句合成一个逻辑行等等。然后，执行#开头的预处理指令。本章介绍 C 语言的预处理指令。

预处理指令可以出现在程序的任何地方，但是习惯上，往往放在代码的开头部分。

每个预处理指令都以#开头，放在一行的行首，指令前面可以有空白字符（比如空格或制表符）。#和指令的其余部分之间也可以有空格，但是为了兼容老的编译器，一般不留空格。

所有预处理指令都是一行的，除非在行尾使用反斜杠，将其折行。指令结尾处不需要分号。

#define

#define是最常见的预处理指令，用来将指定的词替换成另一个词。它的参数分成两个部分，第一个参数就是要被替换的部分，其余参数是替换后的内容。每条替换规则，称为一个宏（macro）。

1	#define MAX 100

上面示例中，#define指定将源码里面的MAX，全部替换成100。MAX就称为一个宏。

宏的名称不允许有空格，而且必须遵守 C 语言的变量命名规则，只能使用字母、数字与下划线（_），且首字符不能是数字。

宏是原样替换，指定什么内容，就一模一样替换成什么内容。

#define HELLO "Hello, world"

// 相当于 printf("%s", "Hello, world");
printf("%s", HELLO);

上面示例中，宏HELLO会被原样替换成"Hello, world"。

#define指令可以出现在源码文件的任何地方，从指令出现的地方到该文件末尾都有效。习惯上，会将#define放在源码文件的头部。它的主要好处是，会使得程序的可读性更好，也更容易修改。

#define指令从#开始，一直到换行符为止。如果整条指令过长，可以在折行处使用反斜杠，延续到下一行。

1 2	#define OW "C programming language is invented \ in 1970s."

上面示例中，第一行结尾的反斜杠将#define指令拆成两行。

#define允许多重替换，即一个宏可以包含另一个宏。

1 2	#define TWO 2 #define FOUR TWO*TWO

上面示例中，FOUR会被替换成2*2。

注意，如果宏出现在字符串里面（即出现在双引号中），或者是其他标识符的一部分，就会失效，并不会发生替换。

#define TWO 2

// 输出 TWO
printf("TWO\n");

// 输出 22
const TWOs = 22;
printf("%d\n", TWOs);

上面示例中，双引号里面的TWO，以及标识符TWOs，都不会被替换。

同名的宏可以重复定义，只要定义是相同的，就没有问题。如果定义不同，就会报错。

// 正确
#define FOO hello
#define FOO hello

// 报错
#define BAR hello
#define BAR world

上面示例中，宏FOO没有变化，所以可以重复定义，宏BAR发生了变化，就报错了。

带参数的宏

基本用法

宏的强大之处在于，它的名称后面可以使用括号，指定接受一个或多个参数。

1	#define SQUARE(X) X*X

上面示例中，宏SQUARE可以接受一个参数X，替换成X*X。

注意，宏的名称与左边圆括号之间，不能有空格。

这个宏的用法如下。

1 2	// 替换成 z = 2*2; z = SQUARE(2);

这种写法很像函数，但又不是函数，而是完全原样的替换，会跟函数有不一样的行为。

#define SQUARE(X) X*X

// 输出19
printf("%d\n", SQUARE(3 + 4));

上面示例中，SQUARE(3 + 4)如果是函数，输出的应该是49（7*7）；宏是原样替换，所以替换成3 + 4*3 + 4，最后输出19。

可以看到，原样替换可能导致意料之外的行为。解决办法就是在定义宏的时候，尽量多使用圆括号，这样可以避免很多意外。

1	#define SQUARE(X) ((X) * (X))

上面示例中，SQUARE(X)替换后的形式，有两层圆括号，就可以避免很多错误的发生。

宏的参数也可以是空的。

1	#define getchar() getc(stdin)

上面示例中，宏getchar()的参数就是空的。这种情况其实可以省略圆括号，但是加上了，会让它看上去更像函数。

一般来说，带参数的宏都是一行的。下面是两个例子。

1 2	#define MAX(x, y) ((x)>(y)?(x):(y)) #define IS_EVEN(n) ((n)%2==0)

如果宏的长度过长，可以使用反斜杠（\）折行，将宏写成多行。

#define PRINT_NUMS_TO_PRODUCT(a, b) { \
  int product = (a) * (b); \
  for (int i = 0; i < product; i++) { \
    printf("%d\n", i); \
  } \
}

上面示例中，替换文本放在大括号里面，这是为了创造一个块作用域，避免宏内部的变量污染外部。

带参数的宏也可以嵌套，一个宏里面包含另一个宏。

1
2
3

#define QUADP(a, b, c) ((-(b) + sqrt((b) * (b) - 4 * (a) * (c))) / (2 * (a)))
#define QUADM(a, b, c) ((-(b) - sqrt((b) * (b) - 4 * (a) * (c))) / (2 * (a)))
#define QUAD(a, b, c) QUADP(a, b, c), QUADM(a, b, c)

上面示例是一元二次方程组求解的宏，由于存在正负两个解，所以宏QUAD先替换成另外两个宏QUADP和QUADM，后者再各自替换成一个解。

那么，什么时候使用带参数的宏，什么时候使用函数呢？

一般来说，应该首先使用函数，它的功能更强、更容易理解。宏有时候会产生意想不到的替换结果，而且往往只能写成一行，除非对换行符进行转义，但是可读性就变得很差。

宏的优点是相对简单，本质上是字符串替换，不涉及数据类型，不像函数必须定义数据类型。而且，宏将每一处都替换成实际的代码，省掉了函数调用的开销，所以性能会好一些。另外，以前的代码大量使用宏，尤其是简单的数学运算，为了读懂前人的代码，需要对它有所了解。

`#`运算符，`##`运算符

由于宏不涉及数据类型，所以替换以后可能为各种类型的值。如果希望替换后的值为字符串，可以在替换文本的参数前面加上#。

#define STR(x) #x

// 等同于 printf("%s\n", "3.14159");
printf("%s\n", STR(3.14159));

上面示例中，STR(3.14159)会被替换成3.14159。如果x前面没有#，这会被解释成一个浮点数，有了#以后，就会被转换成字符串。

下面是另一个例子。

#define XNAME(n) "x"#n

// 输出 x4
printf("%s\n", XNAME(4));

上面示例中，#n指定参数输出为字符串，再跟前面的字符串结合，最终输出为"x4"。如果不加#，这里实现起来就很麻烦了。

如果替换后的文本里面，参数需要跟其他标识符连在一起，组成一个新的标识符，可以使用##运算符。它起到粘合作用，将参数“嵌入”一个标识符之中。

1	#define MK_ID(n) i##n

上面示例中，n是宏MK_ID的参数，这个参数需要跟标识符i粘合在一起，这时i和n之间就要使用##运算符。下面是这个宏的用法示例。

1
2
3

int MK_ID(1), MK_ID(2), MK_ID(3);
// 替换成
int i1, i2, i3;

上面示例中，替换后的文本i1、i2、i3是三个标识符，参数n是标识符的一部分。从这个例子可以看到，##运算符的一个主要用途是批量生成变量名和标识符。

不定参数的宏

宏的参数还可以是不定数量的（即不确定有多少个参数），...表示剩余的参数。

1	#define X(a, b, ...) (10(a) + 20(b)), __VA_ARGS__

上面示例中，X(a, b, ...)表示X()至少有两个参数，多余的参数使用...表示。在替换文本中，__VA_ARGS__代表多余的参数（每个参数之间使用逗号分隔）。下面是用法示例。

1
2
3

X(5, 4, 3.14, "Hi!", 12)
// 替换成
(10*(5) + 20*(4)), 3.14, "Hi!", 12

注意，...只能替代宏的尾部参数，不能写成下面这样。

1 2	// 报错 #define WRONG(X, ..., Y) #X #__CA_ARGS__ #Y

上面示例中，...替代中间部分的参数，这是不允许的，会报错。

__VA_ARGS__前面加上一个#号，可以让输出变成一个字符串。

1
2
3

#define X(...) #__VA_ARGS__

printf("%s\n", X(1,2,3));  // Prints "1, 2, 3"

#undef

#undef指令用来取消已经使用#define定义的宏。

1 2	#define LIMIT 400 #undef LIMIT

上面示例的undef指令取消已经定义的宏LIMIT，后面就可以重新用 LIMIT 定义一个宏。

有时候想重新定义一个宏，但不确定是否以前定义过，就可以先用#undef取消，然后再定义。因为同名的宏如果两次定义不一样，会报错，而#undef的参数如果是不存在的宏，并不会报错。

GCC 的-U选项可以在命令行取消宏的定义，相当于#undef。

1	gcc -ULIMIT foo.c

上面示例中的-U参数，取消了宏LIMIT，相当于源文件里面的#undef LIMIT。

#include

#include指令用于编译时将其他源码文件，加载进入当前文件。它有两种形式。

// 形式一
#include <foo.h> // 加载系统提供的文件

// 形式二
#include "foo.h" // 加载用户提供的文件

形式一，文件名写在尖括号里面，表示该文件是系统提供的，通常是标准库的库文件，不需要写路径。因为编译器会到系统指定的安装目录里面，去寻找这些文件。

形式二，文件名写在双引号里面，表示该文件由用户提供，具体的路径取决于编译器的设置，可能是当前目录，也可能是项目的工作目录。如果所要包含的文件在其他位置，就需要指定路径，下面是一个例子。

1	#include "/usr/local/lib/foo.h"

GCC 编译器的-I参数，也可以用来指定include命令中用户文件的加载路径。

1	gcc -Iinclude/ -o code code.c

上面命令中，-Iinclude/指定从当前目录的include子目录里面，加载用户自己的文件。

#include最常见的用途，就是用来加载包含函数原型的头文件（后缀名为.h），参见《多文件编译》一章。多个#include指令的顺序无关紧要，多次包含同一个头文件也是合法的。

#if…#endif

#if...#endif指令用于预处理器的条件判断，满足条件时，内部的行会被编译，否则就被编译器忽略。

1
2
3

#if 0
  const double pi = 3.1415; // 不会执行
#endif

上面示例中，#if后面的0，表示判断条件不成立。所以，内部的变量定义语句会被编译器忽略。#if 0这种写法常用来当作注释使用，不需要的代码就放在#if 0里面。

#if后面的判断条件，通常是一个表达式。如果表达式的值不等于0，就表示判断条件为真，编译内部的语句；如果表达式的值等于0，表示判断条件为伪，则忽略内部的语句。

#if...#endif之间还可以加入#else指令，用于指定判断条件不成立时，需要编译的语句。

#define FOO 1

#if FOO
  printf("defined\n");
#else
  printf("not defined\n");
#endif

上面示例中，宏FOO如果定义过，会被替换成1，从而输出defined，否则输出not defined。

如果有多个判断条件，还可以加入#elif命令。

#if HAPPY_FACTOR == 0
  printf("I'm not happy!\n");
#elif HAPPY_FACTOR == 1
  printf("I'm just regular\n");
#else
  printf("I'm extra happy!\n");
#endif

上面示例中，通过#elif指定了第二重判断。注意，#elif的位置必须在#else之前。如果多个判断条件皆不满足，则执行#else的部分。

没有定义过的宏，等同于0。因此如果UNDEFINED是一个没有定义过的宏，那么#if UNDEFINED为伪，而#if !UNDEFINED为真。

#if的常见应用就是打开（或关闭）调试模式。

#define DEBUG 1

#if DEBUG
printf("value of i : %d\n", i);
printf("value of j : %d\n", j);
#endif

上面示例中，通过将DEBUG设为1，就打开了调试模式，可以输出调试信息。

GCC 的-D参数可以在编译时指定宏的值，因此可以很方便地打开调试开关。

1	gcc -DDEBUG=1 foo.c

上面示例中，-D参数指定宏DEBUG为1，相当于在代码中指定#define DEBUG 1。

#ifdef…#endif

#ifdef...#endif指令用于判断某个宏是否定义过。

有时源码文件可能会重复加载某个库，为了避免这种情况，可以在库文件里使用#define定义一个空的宏。通过这个宏，判断库文件是否被加载了。

1	#define EXTRA_HAPPY

上面示例中，EXTRA_HAPPY就是一个空的宏。

然后，源码文件使用#ifdef...#endif检查这个宏是否定义过。

1
2
3

#ifdef EXTRA_HAPPY
  printf("I'm extra happy!\n");
#endif

上面示例中，#ifdef检查宏EXTRA_HAPPY是否定义过。如果已经存在，表示加载过库文件，就会打印一行提示。

#ifdef可以与#else指令配合使用。

#ifdef EXTRA_HAPPY
  printf("I'm extra happy!\n");
#else
  printf("I'm just regular\n");
#endif

上面示例中，如果宏EXTRA_HAPPY没有定义过，就会执行#else的部分。

#ifdef...#else...#endif可以用来实现条件加载。

#ifdef MAVIS
  #include "foo.h"
  #define STABLES 1
#else
  #include "bar.h"
  #define STABLES 2
#endif

上面示例中，通过判断宏MAVIS是否定义过，实现加载不同的头文件。

defined 运算符

上一节的#ifdef指令，等同于#if defined。

1
2
3

#ifdef FOO
// 等同于
#if defined FOO

上面示例中，defined是一个预处理运算符，如果它的参数是一个定义过的宏，就会返回1，否则返回0。

使用这种语法，可以完成多重判断。

#if defined FOO
  x = 2;
#elif defined BAR
  x = 3;
#endif

这个运算符的一个应用，就是对于不同架构的系统，加载不同的头文件。

#if defined IBMPC
  #include "ibmpc.h"
#elif defined MAC
  #include "mac.h"
#else
  #include "general.h"
#endif

上面示例中，不同架构的系统需要定义对应的宏。代码根据不同的宏，加载对应的头文件。

#ifndef…#endif

#ifndef...#endif指令跟#ifdef...#endif正好相反。它用来判断，如果某个宏没有被定义过，则执行指定的操作。

#ifdef EXTRA_HAPPY
  printf("I'm extra happy!\n");
#endif

#ifndef EXTRA_HAPPY
  printf("I'm just regular\n");
#endif

上面示例中，针对宏EXTRA_HAPPY是否被定义过，#ifdef和#ifndef分别指定了两种情况各自需要编译的代码。

#ifndef常用于防止重复加载。举例来说，为了防止头文件myheader.h被重复加载，可以把它放在#ifndef...#endif里面加载。

#ifndef MYHEADER_H
  #define MYHEADER_H
  #include "myheader.h"
#endif

上面示例中，宏MYHEADER_H对应文件名myheader.h的大写。只要#ifndef发现这个宏没有被定义过，就说明该头文件没有加载过，从而加载内部的代码，并会定义宏MYHEADER_H，防止被再次加载。

#ifndef等同于#if !defined。

1
2
3

#ifndef FOO
// 等同于
#if !defined FOO

预定义宏

C 语言提供一些预定义的宏，可以直接使用。

__DATE__：编译日期，格式为“Mmm dd yyyy”的字符串（比如 Nov 23 2021）。
__TIME__：编译时间，格式为“hh:mm:ss”。
__FILE__：当前文件名。
__LINE__：当前行号。
__func__：当前正在执行的函数名。该预定义宏必须在函数作用域使用。
__STDC__：如果被设为1，表示当前编译器遵循 C 标准。
__STDC_HOSTED__：如果被设为1，表示当前编译器可以提供完整的标准库；否则被设为0（嵌入式系统的标准库常常是不完整的）。
__STDC_VERSION__：编译所使用的 C 语言版本，是一个格式为yyyymmL的长整数，C99 版本为“199901L”，C11 版本为“201112L”，C17 版本为“201710L”。

下面示例打印这些预定义宏的值。

#include <stdio.h>

int main(void) {
  printf("This function: %s\n", __func__);
  printf("This file: %s\n", __FILE__);
  printf("This line: %d\n", __LINE__);
  printf("Compiled on: %s %s\n", __DATE__, __TIME__);
  printf("C Version: %ld\n", __STDC_VERSION__);
}

/* 输出如下

This function: main
This file: test.c
This line: 7
Compiled on: Mar 29 2021 19:19:37
C Version: 201710

*/

#line

#line指令用于覆盖预定义宏__LINE__，将其改为自定义的行号。后面的行将从__LINE__的新值开始计数。

1 2	// 将下一行的行号重置为 300 #line 300

上面示例中，紧跟在#line 300后面一行的行号，将被改成300，其后的行会在300的基础上递增编号。

#line还可以改掉预定义宏__FILE__，将其改为自定义的文件名。

1	#line 300 "newfilename"

上面示例中，下一行的行号重置为300，文件名重置为newfilename。

#error

#error指令用于让预处理器抛出一个错误，终止编译。

1
2
3

#if __STDC_VERSION__ != 201112L
  #error Not C11
#endif

上面示例指定，如果编译器不使用 C11 标准，就中止编译。GCC 编译器会像下面这样报错。

1 2	$ gcc -std=c99 newish.c newish.c:14:2: error: #error Not C11

上面示例中，GCC 使用 C99 标准编译，就报错了。

1
2
3

#if INT_MAX < 100000
  #error int type is too small
#endif

上面示例中，编译器一旦发现INT类型的最大值小于100,000，就会停止编译。

#error指令也可以用在#if...#elif...#else的部分。

#if defined WIN32
  // ...
#elif defined MAC_OS
  // ...
#elif defined LINUX
  // ...
#else
  #error NOT support the operating system
#endif

#pragma

#pragma指令用来修改编译器属性。

1 2	// 使用 C99 标准 #pragma c9x on

上面示例让编译器以 C99 标准进行编译。

I/O 函数

C 语言提供了一些函数，用于与外部设备通信，称为输入输出函数，简称 I/O 函数。输入（import）指的是获取外部数据，输出（export）指的是向外部传递数据。

缓存和字节流

严格地说，输入输出函数并不是直接与外部设备通信，而是通过缓存（buffer）进行间接通信。这个小节介绍缓存是什么。

普通文件一般都保存在磁盘上面，跟 CPU 相比，磁盘读取或写入数据是一个很慢的操作。所以，程序直接读写磁盘是不可行的，可能每执行一行命令，都必须等半天。C 语言的解决方案，就是只要打开一个文件，就在内存里面为这个文件设置一个缓存区。

程序向文件写入数据时，程序先把数据放入缓存，等到缓存满了，再把里面的数据会一次性写入磁盘文件。这时，缓存区就空了，程序再把新的数据放入缓存，重复整个过程。

程序从文件读取数据时，文件先把一部分数据放到缓存里面，然后程序从缓存获取数据，等到缓存空了，磁盘文件再把新的数据放入缓存，重复整个过程。

内存的读写速度比磁盘快得多，缓存的设计减少了读写磁盘的次数，大大提高了程序的执行效率。另外，一次性移动大块数据，要比多次移动小块数据快得多。

这种读写模式，对于程序来说，就有点像水流（stream），不是一次性读取或写入所有数据，而是一个持续不断的过程。先操作一部分数据，等到缓存吞吐完这部分数据，再操作下一部分数据。这个过程就叫做字节流操作。

由于缓存读完就空了，所以字节流读取都是只能读一次，第二次就读不到了。这跟读取文件很不一样。

C 语言的输入输出函数，凡是涉及读写文件，都是属于字节流操作。输入函数从文件获取数据，操作的是输入流；输出函数向文件写入数据，操作的是输出流。

printf()

printf()是最常用的输出函数，用于屏幕输出，原型定义在头文件stdio.h，详见《基本语法》一章。

scanf()

基本用法

scanf()函数用于读取用户的键盘输入。程序运行到这个语句时，会停下来，等待用户从键盘输入。用户输入数据、按下回车键后，scanf()就会处理用户的输入，将其存入变量。它的原型定义在头文件stdio.h。

scanf()的语法跟printf()类似。

1	scanf("%d", &i);

它的第一个参数是一个格式字符串，里面会放置占位符（与printf()的占位符基本一致），告诉编译器如何解读用户的输入，需要提取的数据是什么类型。这是因为 C 语言的数据都是有类型的，scanf()必须提前知道用户输入的数据类型，才能处理数据。它的其余参数就是存放用户输入的变量，格式字符串里面有多少个占位符，就有多少个变量。

上面示例中，scanf()的第一个参数%d，表示用户输入的应该是一个整数。%d就是一个占位符，%是占位符的标志，d表示整数。第二个参数&i表示，将用户从键盘输入的整数存入变量i。

注意，变量前面必须加上&运算符（指针变量除外），因为scanf()传递的不是值，而是地址，即将变量i的地址指向用户输入的值。如果这里的变量是指针变量（比如字符串变量），那就不用加&运算符。

下面是一次将键盘输入读入多个变量的例子。

1	scanf("%d%d%f%f", &i, &j, &x, &y);

上面示例中，格式字符串%d%d%f%f，表示用户输入的前两个是整数，后两个是浮点数，比如1 -20 3.4 -4.0e3。这四个值依次放入i、j、x、y四个变量。

scanf()处理数值占位符时，会自动过滤空白字符，包括空格、制表符、换行符等。所以，用户输入的数据之间，有一个或多个空格不影响scanf()解读数据。另外，用户使用回车键，将输入分成几行，也不影响解读。

1
-20
3.4
-4.0e3

上面示例中，用户分成四行输入，得到的结果与一行输入是完全一样的。每次按下回车键以后，scanf()就会开始解读，如果第一行匹配第一个占位符，那么下次按下回车键时，就会从第二个占位符开始解读。

scanf()处理用户输入的原理是，用户的输入先放入缓存，等到按下回车键后，按照占位符对缓存进行解读。解读用户输入时，会从上一次解读遗留的第一个字符开始，直到读完缓存，或者遇到第一个不符合条件的字符为止。

int x;
float y;

// 用户输入 "    -13.45e12## 0"
scanf("%d", &x);
scanf("%f", &y);

上面示例中，scanf()读取用户输入时，%d占位符会忽略起首的空格，从-处开始获取数据，读取到-13停下来，因为后面的.不属于整数的有效字符。这就是说，占位符%d会读到-13。

第二次调用scanf()时，就会从上一次停止解读的地方，继续往下读取。这一次读取的首字符是.，由于对应的占位符是%f，会读取到.45e12，这是采用科学计数法的浮点数格式。后面的#不属于浮点数的有效字符，所以会停在这里。

由于scanf()可以连续处理多个占位符，所以上面的例子也可以写成下面这样。

1	scanf("%d%f", &x, &y);

scanf()的返回值是一个整数，表示成功读取的变量个数。如果没有读取任何项，或者匹配失败，则返回0。如果读取到文件结尾，则返回常量 EOF。

占位符

scanf()常用的占位符如下，与printf()的占位符基本一致。

%c：字符。
%d：整数。
%f：float类型浮点数。
%lf：double类型浮点数。
%Lf：long double类型浮点数。
%s：字符串。
%[]：在方括号中指定一组匹配的字符（比如%[0-9]），遇到不在集合之中的字符，匹配将会停止。

上面所有占位符之中，除了%c以外，都会自动忽略起首的空白字符。%c不忽略空白字符，总是返回当前第一个字符，无论该字符是否为空格。如果要强制跳过字符前的空白字符，可以写成scanf(" %c", &ch)，即%c前加上一个空格，表示跳过零个或多个空白字符。

下面要特别说一下占位符%s，它其实不能简单地等同于字符串。它的规则是，从当前第一个非空白字符开始读起，直到遇到空白字符（即空格、换行符、制表符等）为止。因为%s不会包含空白字符，所以无法用来读取多个单词，除非多个%s一起使用。这也意味着，scanf()不适合读取可能包含空格的字符串，比如书名或歌曲名。另外，scanf()遇到%s占位符，会在字符串变量末尾存储一个空字符\0。

scanf()将字符串读入字符数组时，不会检测字符串是否超过了数组长度。所以，储存字符串时，很可能会超过数组的边界，导致预想不到的结果。为了防止这种情况，使用%s占位符时，应该指定读入字符串的最长长度，即写成%[m]s，其中的[m]是一个整数，表示读取字符串的最大长度，后面的字符将被丢弃。

1 2	char name[11]; scanf("%10s", name);

上面示例中，name是一个长度为11的字符数组，scanf()的占位符%10s表示最多读取用户输入的10个字符，后面的字符将被丢弃，这样就不会有数组溢出的风险了。

赋值忽略符

有时，用户的输入可能不符合预定的格式。

1	scanf("%d-%d-%d", &year, &month, &day);

上面示例中，如果用户输入2020-01-01，就会正确解读出年、月、日。问题是用户可能输入其他格式，比如2020/01/01，这种情况下，scanf()解析数据就会失败。

为了避免这种情况，scanf()提供了一个赋值忽略符（assignment suppression character）*。只要把*加在任何占位符的百分号后面，该占位符就不会返回值，解析后将被丢弃。

1	scanf("%d%c%d%c%d", &year, &month, &day);

上面示例中，%*c就是在占位符的百分号后面，加入了赋值忽略符*，表示这个占位符没有对应的变量，解读后不必返回。

sscanf()

sscanf()函数与scanf()很类似，不同之处是sscanf()从字符串里面，而不是从用户输入获取数据。它的原型定义在头文件stdio.h里面。

1	int sscanf(const char* s, const char* format, ...);

sscanf()的第一个参数是一个字符串指针，用来从其中获取数据。其他参数都与scanf()相同。

sscanf()主要用来处理其他输入函数读入的字符串，从其中提取数据。

1 2	fgets(str, sizeof(str), stdin); sscanf(str, "%d%d", &i, &j);

上面示例中，fgets()先从标准输入获取了一行数据（fgets()的介绍详见下一章），存入字符数组str。然后，sscanf()再从字符串str里面提取两个整数，放入变量i和j。

sscanf()的一个好处是，它的数据来源不是流数据，所以可以反复使用，不像scanf()的数据来源是流数据，只能读取一次。

sscanf()的返回值是成功赋值的变量的数量，如果提取失败，返回常量 EOF。

getchar()，putchar()

（1）getchar()

getchar()函数返回用户从键盘输入的一个字符，使用时不带有任何参数。程序运行到这个命令就会暂停，等待用户从键盘输入，等同于使用scanf()方法读取一个字符。它的原型定义在头文件stdio.h。

char ch;
ch = getchar();

// 等同于
scanf("%c", &ch);

getchar()不会忽略起首的空白字符，总是返回当前读取的第一个字符，无论是否为空格。如果读取失败，返回常量 EOF，由于 EOF 通常是-1，所以返回值的类型要设为 int，而不是 char。

由于getchar()返回读取的字符，所以可以用在循环条件之中。

1 2	while (getchar() != '\n') ;

上面示例中，只有读到的字符等于换行符（\n），才会退出循环，常用来跳过某行。while循环的循环体没有任何语句，表示对该行不执行任何操作。

下面的例子是计算某一行的字符长度。

1
2
3

int len = 0;
while(getchar() != '\n')
  len++;

上面示例中，getchar()每读取一个字符，长度变量len就会加1，直到读取到换行符为止，这时len就是该行的字符长度。

下面的例子是跳过空格字符。

1 2	while ((ch = getchar()) == ' ') ;

上面示例中，结束循环后，变量ch等于第一个非空格字符。

（2）putchar()

putchar()函数将它的参数字符输出到屏幕，等同于使用printf()输出一个字符。它的原型定义在头文件stdio.h。

1
2
3

putchar(ch);
// 等同于
printf("%c", ch);

操作成功时，putchar()返回输出的字符，否则返回常量 EOF。

（3）小结

由于getchar()和putchar()这两个函数的用法，要比scanf()和printf()更简单，而且通常是用宏来实现，所以要比scanf()和printf()更快。如果操作单个字符，建议优先使用这两个函数。

puts()

puts()函数用于将参数字符串显示在屏幕（stdout）上，并且自动在字符串末尾添加换行符。它的原型定义在头文件stdio.h。

1 2	puts("Here are some messages:"); puts("Hello World");

上面示例中，puts()在屏幕上输出两行内容。

写入成功时，puts()返回一个非负整数，否则返回常量 EOF。

gets()

gets()函数以前用于从stdin读取整行输入，现在已经被废除了，仍然放在这里介绍一下。

该函数读取用户的一行输入，不会跳过起始处的空白字符，直到遇到换行符为止。这个函数会丢弃换行符，将其余字符放入参数变量，并在这些字符的末尾添加一个空字符\0，使其成为一个字符串。

它经常与puts()配合使用。

char words[81];

puts("Enter a string, please");
gets(words);

上面示例使用puts()在屏幕上输出提示，然后使用gets()获取用户的输入。

由于gets()获取的字符串，可能超过字符数组变量的最大长度，有安全风险，建议不要使用，改为使用fgets()。

文件操作

本章介绍 C 语言如何操作文件。

文件指针

C 语言提供了一个 FILE 数据结构，记录了操作一个文件所需要的信息。该结构定义在头文件stdio.h，所有文件操作函数都要通过这个数据结构，获取文件信息。

开始操作一个文件之前，就要定义一个指向该文件的 FILE 指针，相当于获取一块内存区域，用来保存文件信息。

FILE* fp;

上面示例定义了一个 FILE 指针fp。

下面是一个读取文件的完整示例。

#include <stdio.h>

int main(void) {
  FILE* fp;
  char c;

  fp = fopen("hello.txt", "r");
  if (fp == NULL) {
    return -1;
  }

  c = fgetc(fp);
  printf("%c\n", c);

  fclose(fp);

  return 0;
}

上面示例中，新建文件指针fp以后，依次使用了下面三个文件操作函数，分成三个步骤。其他的文件操作，大致上也是这样的步骤。

第一步，使用fopen()打开指定文件，返回一个 File 指针。如果出错，返回 NULL。

它相当于将指定文件的信息与新建的文件指针fp相关联，在 FILE 结构内部记录了这样一些信息：文件内部的当前读写位置、读写报错的记录、文件结尾指示器、缓冲区开始位置的指针、文件标识符、一个计数器（统计拷贝进缓冲区的字节数）等等。后继的操作就可以使用这个指针（而不是文件名）来处理指定文件。

同时，它还为文件建立一个缓存区。由于存在缓存区，也可以说fopen()函数“打开一个了流”，后继的读写文件都是流模式。

第二步，使用读写函数，从文件读取数据，或者向文件写入数据。上例使用了fgetc()函数，从已经打开的文件里面，读取一个字符。

fgetc()一调用，文件的数据块先拷贝到缓冲区。不同的计算机有不同的缓冲区大小，一般是512字节或是它的倍数，如4096或16384。随着计算机硬盘容量越来越大，缓冲区也越来越大。

fgetc()从缓冲区读取数据，同时将文件指针内部的读写位置指示器，指向所读取字符的下一个字符。所有的文件读取函数都使用相同的缓冲区，后面再调用任何一个读取函数，都将从指示器指向的位置，即上一次读取函数停止的位置开始读取。

当读取函数发现已读完缓冲区里面的所有字符时，会请求把下一个缓冲区大小的数据块，从文件拷贝到缓冲区中。读取函数就以这种方式，读完文件的所有内容，直到文件结尾。不过，上例是只从缓存区读取一个字符。当函数在缓冲区里面，读完文件的最后一个字符时，就把 FILE 结构里面的文件结尾指示器设置为真。于是，下一次再调用读取函数时，会返回常量 EOF。EOF 是一个整数值，代表文件结尾，一般是-1。

第三步，fclose()关闭文件，同时清空缓存区。

上面是文件读取的过程，文件写入也是类似的方式，先把数据写入缓冲区，当缓冲区填满后，缓存区的数据将被转移到文件中。

fopen()

fopen()函数用来打开文件。所有文件操作的第一步，都是使用fopen()打开指定文件。这个函数的原型定义在头文件stdio.h。

1	FILE* fopen(char* filename, char* mode);

它接受两个参数。第一个参数是文件名(可以包含路径)，第二个参数是模式字符串，指定对文件执行的操作，比如下面的例子中，r表示以读取模式打开文件。

1	fp = fopen("in.dat", "r");

成功打开文件以后，fopen()返回一个 FILE 指针，其他函数可以用这个指针操作文件。如果无法打开文件（比如文件不存在或没有权限），会返回空指针 NULL。所以，执行fopen()以后，最好判断一下，有没有打开成功。

fp = fopen("hello.txt", "r");

if (fp == NULL) {
  printf("Can't open file!\n");
  exit(EXIT_FAILURE);
}

上面示例中，如果fopen()返回一个空指针，程序就会报错。

fopen()的模式字符串有以下几种。

r：读模式，只用来读取数据。如果文件不存在，返回 NULL 指针。
w：写模式，只用来写入数据。如果文件存在，文件长度会被截为0，然后再写入；如果文件不存在，则创建该文件。
a：写模式，只用来在文件尾部追加数据。如果文件不存在，则创建该文件。
r+：读写模式。如果文件存在，指针指向文件开始处，可以在文件头部添加数据。如果文件不存在，返回 NULL 指针。
w+：读写模式。如果文件存在，文件长度会被截为0，然后再写入数据。这种模式实际上读不到数据，反而会擦掉数据。如果文件不存在，则创建该文件。
a+：读写模式。如果文件存在，指针指向文件结尾，可以在现有文件末尾添加内容。如果文件不存在，则创建该文件。

上一小节说过，fopen()函数会为打开的文件创建一个缓冲区。读模式下，创建的是读缓存区；写模式下，创建的是写缓存区；读写模式下，会同时创建两个缓冲区。C 语言通过缓存区，以流的形式，向文件读写数据。

数据在文件里面，都是以二进制形式存储。但是，读取的时候，有不同的解读方法：以原本的二进制形式解读，叫做“二进制流”；将二进制数据转成文本，以文本形式解读，叫做“文本流”。写入操作也是如此，分成以二进制写入和以文本写入，后者会多一个文本转二进制的步骤。

fopen()的模式字符串，默认是以文本流读写。如果添加b后缀（表示 binary），就会以“二进制流”进行读写。比如，rb是读取二进制数据模式，wb是写入二进制数据模式。

模式字符串还有一个x后缀，表示独占模式（exclusive）。如果文件已经存在，则打开文件失败；如果文件不存在，则新建文件，打开后不再允许其他程序或线程访问当前文件。比如，wx表示以独占模式写入文件，如果文件已经存在，就会打开失败。

标准流

Linux 系统默认提供三个已经打开的文件，它们的文件指针如下。

stdin（标准输入）：默认来源为键盘，文件指针编号为0。
stdout（标准输出）：默认目的地为显示器，文件指针编号为1。
stderr（标准错误）：默认目的地为显示器，文件指针编号为2。

Linux 系统的文件，不一定是数据文件，也可以是设备文件，即文件代表一个可以读或写的设备。文件指针stdin默认是把键盘看作一个文件，读取这个文件，就能获取用户的键盘输入。同理，stdout和stderr默认是把显示器看作一个文件，将程序的运行结果写入这个文件，用户就能看到运行结果了。它们的区别是，stdout写入的是程序的正常运行结果，stderr写入的是程序的报错信息。

这三个输入和输出渠道，是 Linux 默认提供的，所以分别称为标准输入（stdin）、标准输出（stdout）和标准错误（stderr）。因为它们的实现是一样的，都是文件流，所以合称为“标准流”。

Linux 允许改变这三个文件指针（文件流）指向的文件，这称为重定向（redirection）。

如果标准输入不绑定键盘，而是绑定其他文件，可以在文件名前面加上小于号<，跟在程序名后面。这叫做“输入重定向”（input redirection）。

1	demo < in.dat

上面示例中，demo程序代码里面的stdin，将指向文件in.dat，即从in.dat获取数据。

如果标准输出绑定其他文件，而不是显示器，可以在文件名前加上大于号>，跟在程序名后面。这叫做“输出重定向”（output redirection）。

1	demo > out.dat

上面示例中，demo程序代码里面的stdout，将指向文件out.dat，即向out.dat写入数据。

输出重定向>会先擦去out.dat的所有原有的内容，然后再写入。如果希望写入的信息追加在out.dat的结尾，可以使用>>符号。

1	demo >> out.dat

上面示例中，demo程序代码里面的stdout，将向文件out.dat写入数据。与>不同的是，写入的开始位置是out.dat的文件结尾。

标准错误的重定向符号是2>。其中的2代表文件指针的编号，即2>表示将2号文件指针的写入，重定向到err.txt。2号文件指针就是标准错误stderr。

1	demo > out.dat 2> err.txt

上面示例中，demo程序代码里面的stderr，会向文件err.txt写入报错信息。而stdout向文件out.dat写入。

输入重定向和输出重定向，也可以结合在一条命令里面。

$ demo < in.dat > out.dat

// or
$ demo > out.dat < in.dat

重定向还有另一种情况，就是将一个程序的标准输出stdout，指向另一个程序的标准输入stdin，这时要使用|符号。

1	random \| sum

上面示例中，random程序代码里面的stdout的写入，会从sum程序代码里面的stdin被读取。

fclose()

fclose()用来关闭已经使用fopen()打开的文件。它的原型定义在stdin.h。

1	int fclose(FILE* stream);

它接受一个文件指针fp作为参数。如果成功关闭文件，fclose()函数返回整数0；如果操作失败（比如磁盘已满，或者出现 I/O 错误），则返回一个特殊值 EOF（详见下一小节）。

1 2	if (fclose(fp) != 0) printf("Something wrong.");

不再使用的文件，都应该使用fclose()关闭，否则无法释放资源。一般来说，系统对同时打开的文件数量有限制，及时关闭文件可以避免超过这个限制。

EOF

C 语言的文件操作函数的设计是，如果遇到文件结尾，就返回一个特殊值。程序接收到这个特殊值，就知道已经到达文件结尾了。

头文件stdio.h为这个特殊值定义了一个宏EOF（end of file 的缩写），它的值一般是-1。这是因为从文件读取的二进制值，不管作为无符号数字解释，还是作为 ASCII 码解释，都不可能是负值，所以可以很安全地返回-1，不会跟文件本身的数据相冲突。

需要注意的是，不像字符串结尾真的存储了\0这个值，EOF并不存储在文件结尾，文件中并不存在这个值，完全是文件操作函数发现到达了文件结尾，而返回这个值。

freopen()

freopen()用于新打开一个文件，直接关联到某个已经打开的文件指针。这样可以复用文件指针。它的原型定义在头文件stdio.h。

1	FILE* freopen(char* filename, char* mode, FILE stream);

它跟fopen()相比，就是多出了第三个参数，表示要复用的文件指针。其他两个参数都一样，分别是文件名和打开模式。

1 2	freopen("output.txt", "w", stdout); printf("hello");

上面示例将文件output.txt关联到stdout，此后向stdout写入的内容，都会写入output.txt。由于printf()默认就是输出到stdout，所以运行上面的代码以后，文件output.txt会被写入hello。

freopen()的返回值是它的第三个参数（文件指针）。如果打开失败（比如文件不存在），会返回空指针 NULL。

freopen()会自动关闭原先已经打开的文件，如果文件指针并没有指向已经打开的文件，则freopen()等同于fopen()。

下面是freopen()关联scanf()的例子。

int i, i2;

scanf("%d", &i); 

freopen("someints.txt", "r", stdin);
scanf("%d", &i2);

上面例子中，一共调用了两次scanf()，第一次调用是从键盘读取，然后使用freopen()将stdin指针关联到某个文件，第二次调用就会从该文件读取。

某些系统允许使用freopen()，改变文件的打开模式。这时，freopen()的第一个参数应该是 NULL。

1	freopen(NULL, "wb", stdout);

上面示例将stdout的打开模式从w改成了wb。

fgetc()，getc()

fgetc()和getc()用于从文件读取一个字符。它们的用法跟getchar()类似，区别是getchar()只用来从stdin读取，而这两个函数是从任意指定的文件读取。它们的原型定义在头文件stdio.h。

1 2	int fgetc(FILE stream) int getc(FILE stream);

fgetc()与getc()的用法是一样的，都只有文件指针一个参数。两者的区别是，getc()一般用宏来实现，而fgetc()是函数实现，所以前者的性能可能更好一些。注意，虽然这两个函数返回的是一个字符，但是它们的返回值类型却不是char，而是int，这是因为读取失败的情况下，它们会返回 EOF，这个值一般是-1。

#include <stdio.h>

int main(void) {
  FILE *fp;
  fp = fopen("hello.txt", "r");

  int c;
  while ((c = getc(fp)) != EOF)
    printf("%c", c);

  fclose(fp);
}

上面示例中，getc()依次读取文件的每个字符，将其放入变量c，直到读到文件结尾，返回 EOF，循环终止。变量c的类型是int，而不是char，因为有可能等于负值，所以设为int更好一些。

fputc()，putc()

fputc()和putc()用于向文件写入一个字符。它们的用法跟putchar()类似，区别是putchar()是向stdout写入，而这两个函数是向文件写入。它们的原型定义在头文件stdio.h。

1 2	int fputc(int char, FILE stream); int putc(int char, FILE stream);

fputc()与putc()的用法是一样，都接受两个参数，第一个参数是待写入的字符，第二个参数是文件指针。它们的区别是，putc()通常是使用宏来实现，而fputc()只作为函数来实现，所以理论上，putc()的性能会好一点。

写入成功时，它们返回写入的字符；写入失败时，返回 EOF。

fprintf()

fprintf()用于向文件写入格式化字符串，用法与printf()类似。区别是printf()总是写入stdout，而fprintf()则是写入指定的文件，它的第一个参数必须是一个文件指针。它的原型定义在头文件stdio.h。

1	int fprintf(FILE* stream, const char* format, ...)

fprintf()可以替代printf()。

1 2	printf("Hello, world!\n"); fprintf(stdout, "Hello, world!\n");

上面例子中，指定fprintf()写入stdout，结果就等同于调用printf()。

1	fprintf(fp, "Sum: %d\n", sum);

上面示例是向文件指针fp写入指定格式的字符串。

下面是向stderr输出错误信息的例子。

1	fprintf(stderr, "Something number.\n");

fscanf()

fscanf()用于按照给定的模式，从文件中读取内容，用法跟scanf()类似。区别是scanf()总是从stdin读取数据，而fscanf()是从文件读入数据，它的原型定义在头文件stdio.h，第一个参数必须是文件指针。

1	int fscanf(FILE* stream, const char* format, ...);

下面是一个例子。

1	fscanf(fp, "%d%d", &i, &j);

上面示例中，fscanf()从文件fp里面，读取两个整数，放入变量i和j。

使用fscanf()的前提是知道文件的结构，它的占位符解析规则与scanf()完全一致。由于fscanf()可以连续读取，直到读到文件尾，或者发生错误（读取失败、匹配失败），才会停止读取，所以fscanf()通常放在循环里面。

1 2	while(fscanf(fp, "%s", words) == 1) puts(words);

上面示例中，fscanf()依次读取文件的每个词，将它们一行打印一个，直到文件结束。

fscanf()的返回值是赋值成功的变量数量，如果赋值失败会返回 EOF。

fgets()

fgets()用于从文件读取指定长度的字符串，它名字的第一个字符是f，就代表file。它的原型定义在头文件stdio.h。

1	char* fgets(char* str, int STRLEN, File* fp);

它的第一个参数str是一个字符串指针，用于存放读取的内容。第二个参数STRLEN指定读取的长度，第三个参数是一个 FILE 指针，指向要读取的文件。

fgets()读取 STRLEN - 1 个字符之后，或者遇到换行符与文件结尾，就会停止读取，然后在已经读取的内容末尾添加一个空字符\0，使之成为一个字符串。注意，fgets()会将换行符（\n）存储进字符串。

如果fgets的第三个参数是stdin，就可以读取标准输入，等同于scanf()。

1	fgets(str, sizeof(str), stdin);

读取成功时，fgets()的返回值是它的第一个参数，即指向字符串的指针，否则返回空指针 NULL。

fgets()可以用来读取文件的每一行，下面是读取文件所有行的例子。

#include <stdio.h>

int main(void) {
  FILE* fp;
  char s[1024];  // 数组必须足够大，足以放下一行
  int linecount = 0;

  fp = fopen("hello.txt", "r");

  while (fgets(s, sizeof s, fp) != NULL)
    printf("%d: %s", ++linecount, s);

  fclose(fp);
}

上面示例中，每读取一行，都会输出行号和该行的内容。

下面的例子是循环读取用户的输入。

char words[10];

puts("Enter strings (q to quit):");

while (fgets(words, 10, stdin) != NULL) {
  if (words[0] == 'q' && words[1] == '\n')
    break;

  puts(words);
}

puts("Done.");

上面的示例中，如果用户输入的字符串大于9个字符，fgets()会多次读取。直到遇到q + 回车键，才会退出循环。

fputs()

fputs()函数用于向文件写入字符串，和puts()函数只有一点不同，那就是它不会在字符串末尾添加换行符。这是因为fgets()保留了换行符，所以fputs()就不添加了。fputs()函数通常与fgets()配对使用。

它的原型定义在stdio.h。

1	int fputs(const char* str, FILE* stream);

它接受两个参数，第一个参数是字符串指针，第二个参数是要写入的文件指针。如果第二个参数为stdout（标准输出），就是将内容输出到计算机屏幕，等同于printf()。

char words[14];

puts("Enter a string, please.");
fgets(words, 14, stdin);

puts("This is your string:");
fputs(words, stdout);

上面示例中，先用fgets()从stdin读取用户输入，然后用fputs()输出到stdout。

写入成功时，fputs()返回一个非负整数，否则返回 EOF。

fwrite()

fwrite()用来一次性写入较大的数据块，主要用途是将数组数据一次性写入文件，适合写入二进制数据。它的原型定义在stdio.h。

size_t fwrite(
  const void* ptr,
  size_t size,
  size_t nmemb,
  FILE* fp
);

它接受四个参数。

ptr：数组指针。
size：每个数组成员的大小，单位字节。
nmemb：数组成员的数量。
fp：要写入的文件指针。

注意，fwrite()原型的第一个参数类型是void*，这是一个无类型指针，编译器会自动将参数指针转成void*类型。正是由于fwrite()不知道数组成员的类型，所以才需要知道每个成员的大小（第二个参数）和成员数量（第三个参数）。

fwrite()函数的返回值是成功写入的数组成员的数量（注意不是字节数）。正常情况下，该返回值就是第三个参数nmemb，但如果出现写入错误，只写入了一部分成员，返回值会比nmemb小。

要将整个数组arr写入文件，可以采用下面的写法。

fwrite(
  arr,
  sizeof(arr[0]),
  sizeof(arr) / sizeof(arr[0]),
  fp
);

上面示例中，sizeof(a[0])是每个数组成员占用的字节，sizeof(a) / sizeof(a[0])是整个数组的成员数量。

下面的例子是将一个大小为256字节的字符串写入文件。

1
2
3

char buffer[256];

fwrite(buffer, 1, 256, fp);

上面示例中，数组buffer每个成员是1个字节，一共有256个成员。由于fwrite()是连续内存复制，所以写成fwrite(buffer, 256, 1, fp)也能达到目的。

fwrite()没有规定一定要写入整个数组，只写入数组的一部分也是可以的。

任何类型的数据都可以看成是1字节数据组成的数组，或者是一个成员的数组，所以fwrite()实际上可以写入任何类型的数据，而不仅仅是数组。比如，fwrite()可以将一个 Struct 结构写入文件保存。

1	fwrite(&s, sizeof(s), 1, fp);

上面示例中，s是一个 Struct 结构指针，可以看成是一个成员的数组。注意，如果s的属性包含指针，存储时需要小心，因为保存指针可能没意义，还原出来的时候，并不能保证指针指向的数据还存在。

fwrite()以及后面要介绍的fread()，比较适合读写二进制数据，因为它们不会对写入的数据进行解读。二进制数据可能包含空字符\0，这是 C 语言的字符串结尾标记，所以读写二进制文件，不适合使用文本读写函数（比如fprintf()等）。

下面是一个写入二进制文件的例子。

#include <stdio.h>

int main(void) {
  FILE* fp;
  unsigned char bytes[] = {5, 37, 0, 88, 255, 12};

  fp = fopen("output.bin", "wb");
  fwrite(bytes, sizeof(char), sizeof(bytes), fp);
  fclose(fp);
  return 0;
}

上面示例中，写入二进制文件时，fopen()要使用wb模式打开，表示二进制写入。fwrite()可以把数据解释成单字节数组，因此它的第二个参数是sizeof(char)，第三个参数是数组的总字节数sizeof(bytes)。

上面例子写入的文件output.bin，使用十六进制编辑器打开，会是下面的内容。

1	05 25 00 58 ff 0c

fwrite()还可以连续向一个文件写入数据。

struct clientData myClient = {1, 'foo bar'};

for (int i = 1; i <= 100; i++) {
  fwrite(&myClient, sizeof(struct clientData), 1, cfPtr);
}

上面示例中，fwrite()连续将100条数据写入文件。

fread()

fread()函数用于一次性从文件读取较大的数据块，主要用途是将文件内容读入一个数组，适合读取二进制数据。它的原型定义在头文件stdio.h。

size_t fread(
  void* ptr,
  size_t size,
  size_t nmemb,
  FILE* fp
);

它接受四个参数，与fwrite()完全相同。

ptr：数组地址。
size：数组的成员数量。
nmemb：每个数组成员的大小。
fp：文件指针。

要将文件内容读入数组arr，可以采用下面的写法。

fread(
  arr,
  sizeof(arr[0]),
  sizeof(arr) / sizeof(arr[0]),
  fp
);

上面示例中，数组长度（第二个参数）和每个成员的大小（第三个参数）的乘积，就是数组占用的内存空间的大小。fread()会从文件（第四个参数）里面读取相同大小的内容，然后将ptr（第一个参数）指向这些内容的内存地址。

下面的例子是将文件内容读入一个10个成员的双精度浮点数数组。

1 2	double earnings[10]; fread(earnings, sizeof(double), 10, fp);

上面示例中，每个数组成员的大小是sizeof(double)，一个有10个成员，就会从文件fp读取sizeof(double) * 10大小的内容。

fread()函数的返回值是成功读取的数组成员的数量。正常情况下，该返回值就是第三个参数nmemb，但如果出现读取错误或读到文件结尾，该返回值就会比nmemb小。所以，检查fread()的返回值是非常重要的。

fread()和fwrite()可以配合使用。在程序终止之前，使用fwrite()将数据保存进文件，下次运行时再用fread()将数据还原进入内存。

下面是读取上一节生成的二进制文件output.bin的例子。

#include <stdio.h>

int main(void) {
  FILE* fp;
  unsigned char c;

  fp = fopen("output.bin", "rb");
  while (fread(&c, sizeof(char), 1, fp) > 0)
    printf("%d\n", c);
  return 0;
}

运行后，得到如下结果。

feof()

feof()函数判断文件的内部指针是否指向文件结尾。它的原型定义在头文件stdio.h。

1	int feof(FILE *fp);

feof()接受一个文件指针作为参数。如果已经到达文件结尾，会返回一个非零值（表示 true），否则返回0（表示 false）。

诸如fgetc()这样的文件读取函数，如果返回 EOF，有两种可能，一种可能是已读取到文件结尾，另一种可能是出现读取错误。feof()可以用来判断到底是那一种情况。

下面是通过feof()判断是否到达文件结尾，从而循环读取整个文件的例子。

int num;
char name[50];

FILE* cfPtr = fopen("clients.txt", "r");

while (!feof(cfPtr)) {
  fscanf(cfPtr, "%d%s\n", &num, name);
  printf("%d %s\n", num, name);
}

fclose(cfPtr);

上面示例通过循环判断feof()是否读到文件结尾，从而实现读出整个文件内容。

feof()为真时，可以通过fseek()、rewind()、fsetpos()函数改变文件内部读写位置的指示器，从而清除这个函数的状态。

fseek()

每个文件指针都有一个内部指示器（内部指针），记录当前打开的文件的读写位置（file position），即下一次读写从哪里开始。文件操作函数（比如getc()、fgets()、fscanf()和fread()等）都从这个指示器指定的位置开始按顺序读写文件。

如果希望改变这个指示器，将它移到文件的指定位置，可以使用fseek()函数。它的原型定义在头文件stdio.h。

1	int fseek(FILE* stream, long int offset, int whence);

fseek()接受3个参数。

stream：文件指针。
offset：距离基准（第三个参数）的字节数。类型为 long int，可以为正值（向文件末尾移动）、负值（向文件开始处移动）或 0（保持不动）。
whence：位置基准，用来确定计算起点。它的值是以下三个宏（定义在stdio.h）：SEEK_SET（文件开始处）、SEEK_CUR（内部指针的当前位置）、SEEK_END（文件末尾）

请看下面的例子。

// 定位到文件开始处
fseek(fp, 0L, SEEK_SET);

// 定位到文件末尾
fseek(fp, 0L, SEEK_END);

// 从当前位置前移2个字节
fseek(fp, 2L, SEEK_CUR);

// 定位到文件第10个字节
fseek(fp, 10L, SEEK_SET);

// 定位到文件倒数第10个字节
fseek(fp, -10L, SEEK_END);

上面示例中，fseek()的第二个参数为 long 类型，所以移动距离必须加上后缀L，将其转为 long 类型。

下面的示例逆向输出文件的所有字节。

for (count = 1L; count <= size; count++) {
  fseek(fp, -count, SEEK_END);
  ch = getc(fp);
}

注意，fseek()最好只用来操作二进制文件，不要用来读取文本文件。因为文本文件的字符有不同的编码，某个位置的准确字节位置不容易确定。

正常情况下，fseek()的返回值为0。如果发生错误（如移动的距离超出文件的范围），返回值为非零值（比如-1)。

ftell()

ftell()函数返回文件内部指示器的当前位置。它的原型定义在头文件stdio.h。

1	long int ftell(FILE* stream);

它接受一个文件指针作为参数。返回值是一个 long 类型的整数，表示内部指示器的当前位置，即文件开始处到当前位置的字节数，0表示文件开始处。如果发生错误，ftell()返回-1L。

ftell()可以跟fseek()配合使用，先记录内部指针的位置，一系列操作过后，再用fseek()返回原来的位置。

long file_pos = ftell(fp);

// 一系列文件操作之后
fseek(fp, file_pos, SEEK_SET);

下面的例子先将指示器定位到文件结尾，然后得到文件开始处到结尾的字节数。

1 2	fseek(fp, 0L, SEEK_END); size = ftell(fp);

rewind()

rewind()函数可以让文件的内部指示器回到文件开始处。它的原型定义在stdio.h。

1	void rewind(file* stream);

它接受一个文件指针作为参数。

rewind(fp)基本等价于fseek(fp, 0l, seek_set)，唯一的区别是rewind()没有返回值，而且会清除当前文件的错误指示器。

fgetpos()，fsetpos()

fseek()和ftell()有一个潜在的问题，那就是它们都把文件大小限制在 long int 类型能表示的范围内。这看起来相当大，但是在32位计算机上，long int 的长度为4个字节，能够表示的范围最大为 4GB。随着存储设备的容量迅猛增长，文件也越来越大，往往会超出这个范围。鉴于此，C 语言新增了两个处理大文件的新定位函数：fgetpos()和fsetpos()。

它们的原型都定义在头文件stdio.h。

1 2	int fgetpos(FILE* stream, fpos_t* pos); int fsetpos(FILE* stream, const fpos_t* pos);

fgetpos()函数会将文件内部指示器的当前位置，存储在指针变量pos。该函数接受两个参数，第一个是文件指针，第二个存储指示器位置的变量。

fsetpos()函数会将文件内部指示器的位置，移动到指针变量pos指定的地址。注意，变量pos必须是通过调用fgetpos()方法获得的。fsetpos()的两个参数与fgetpos()必须是一样的。

记录文件内部指示器位置的指针变量pos，类型为fpos_t*（file position type 的缩写，意为文件定位类型）。它不一定是整数，也可能是一个 Struct 结构。

下面是用法示例。

fpos_t file_pos;
fgetpos(fp, &file_pos);

// 一系列文件操作之后
fsetpos(fp, &file_pos);

上面示例中，先用fgetpos()获取内部指针的位置，后面再用fsetpos()恢复指针的位置。

执行成功时，fgetpos()和fsetpos()都会返回0，否则返回非零值。

ferror()，clearerr()

所有的文件操作函数如果执行失败，都会在文件指针里面记录错误状态。后面的操作只要读取错误指示器，就知道前面的操作出错了。

ferror()函数用来返回错误指示器的状态。可以通过这个函数，判断前面的文件操作是否成功。它的原型定义在头文件stdio.h。

1	int ferror(FILE *stream);

它接受一个文件指针作为参数。如果前面的操作出现错误，ferror()就会返回一个非零整数（表示 true），否则返回0。

clearerr()函数用来重置出错指示器。它的原型定义在头文件stdio.h。

1	void clearerr(FILE* fp);

它接受一个文件指针作为参数，没有返回值。

下面是一个例子。

FILE* fp = fopen("file.txt", "w");
char c = fgetc(fp);

if (ferror(fp)) {
  printf("读取文件：file.txt 时发生错误\n");
}

clearerr(fp);

上面示例中，fgetc()尝试读取一个以”写模式“打开的文件，读取失败就会返回 EOF。这时调用ferror()就可以知道上一步操作出错了。处理完以后，再用clearerr()清除出错状态。

文件操作函数如果正常执行，ferror()和feof()都会返回零。如果执行不正常，就要判断到底是哪里出了问题。

if (fscanf(fp, "%d", &n) != 1) {
  if (ferror(fp)) {
    printf("io error\n");
  }
  if (feof(fp)) {
    printf("end of file\n");
  }

  clearerr(fp);

  fclose(fp);
}

上面示例中，当fscanf()函数报错时，通过检查ferror()和feof()，确定到底发生什么问题。这两个指示器改变状态后，会保持不变，所以要用clearerr()清除它们，clearerr()可以同时清除两个指示器。

remove()

remove()函数用于删除指定文件。它的原型定义在头文件stdio.h。

1	int remove(const char* filename);

它接受文件名作为参数。如果删除成功，remove()返回0，否则返回非零值。

1	remove("foo.txt");

上面示例删除了foo.txt文件。

注意，删除文件必须是在文件关闭的状态下。如果是用fopen()打开的文件，必须先用fclose()关闭后再删除。

rename()

rename()函数用于文件改名，也用于移动文件。它的原型定义在头文件stdio.h。

1	int rename(const char* old_filename, const char* new_filename);

它接受两个参数，第一个参数是现在的文件名，第二个参数是新的文件名。如果改名成功，rename()返回0，否则返回非零值。

1	rename("foo.txt", "bar.txt");

上面示例将foo.txt改名为bar.txt。

注意，改名后的文件不能与现有文件同名。另外，如果要改名的文件已经打开了，必须先关闭，然后再改名，对打开的文件进行改名会失败。

下面是移动文件的例子。

1	rename("/tmp/evidence.txt", "/home/beej/nothing.txt");

变量说明符

C 语言允许声明变量的时候，加上一些特定的说明符（specifier），为编译器提供变量行为的额外信息。它的主要作用是帮助编译器优化代码，有时会对程序行为产生影响。

const

const说明符表示变量是只读的，不得被修改。

1 2	const double PI = 3.14159; PI = 3; // 报错

上面示例里面的const，表示变量PI的值不应改变。如果改变的话，编译器会报错。

对于数组，const表示数组成员不能修改。

1 2	const int arr[] = {1, 2, 3, 4}; arr[0] = 5; // 报错

上面示例中，const使得数组arr的成员无法修改。

对于指针变量，const有两种写法，含义是不一样的。如果const在*前面，表示指针指向的值不可修改。

// const 表示指向的值 *x 不能修改
int const * x
// 或者
const int * x

下面示例中，对x指向的值进行修改导致报错。

int p = 1
const int* x = &p;

(*x)++; // 报错

如果const在*后面，表示指针包含的地址不可修改。

1 2	// const 表示地址 x 不能修改 int* const x

下面示例中，对x进行修改导致报错。

int p = 1
int* const x = &p;

x++; // 报错

这两者可以结合起来。

1	const char* const x;

上面示例中，指针变量x指向一个字符串。两个const意味着，x包含的内存地址以及x指向的字符串，都不能修改。

const的一个用途，就是防止函数体内修改函数参数。如果某个参数在函数体内不会被修改，可以在函数声明时，对该参数添加const说明符。这样的话，使用这个函数的人看到原型里面的const，就知道调用函数前后，参数数组保持不变。

1	void find(const int* arr, int n);

上面示例中，函数find的参数数组arr有const说明符，就说明该数组在函数内部将保持不变。

有一种情况需要注意，如果一个指针变量指向const变量，那么该指针变量也不应该被修改。

1
2
3

const int i = 1;
int* j = &i;
*j = 2; // 报错

上面示例中，j是一个指针变量，指向变量i，即j和i指向同一个地址。j本身没有const说明符，但是i有。这种情况下，j指向的值也不能被修改。

static

static说明符对于全局变量和局部变量有不同的含义。

（1）用于局部变量（位于块作用域内部）。

static用于函数内部声明的局部变量时，表示该变量的值会在函数每次执行后得到保留，下次执行时不会进行初始化，就类似于一个只用于函数内部的全局变量。由于不必每次执行函数时，都对该变量进行初始化，这样可以提高函数的执行速度，详见《函数》一章。

（2）用于全局变量（位于块作用域外部）。

static用于函数外部声明的全局变量时，表示该变量只用于当前文件，其他源码文件不可以引用该变量，即该变量不会被链接（link）。

static修饰的变量，初始化时，值不能等于变量，必须是常量。

1 2	int n = 10; static m = n; // 报错

上面示例中，变量m有static修饰，它的值如果等于变量n，就会报错，必须等于常量。

只在当前文件里面使用的函数，也可以声明为static，表明该函数只在当前文件使用，其他文件可以定义同名函数。

1	static int g(int i);

auto

auto说明符表示该变量的存储，由编译器自主分配内存空间，且只存在于定义时所在的作用域，退出作用域时会自动释放。

由于只要不是extern的变量（外部变量），都是由编译器自主分配内存空间的，这属于默认行为，所以该说明符没有实际作用，一般都省略不写。

1
2
3

auto int a;
// 等同于
int a;

extern

extern说明符表示，该变量在其他文件里面声明，没有必要在当前文件里面为它分配空间。通常用来表示，该变量是多个文件共享的。

1	extern int a;

上面代码中，a是extern变量，表示该变量在其他文件里面定义和初始化，当前文件不必为它分配存储空间。

但是，变量声明时，同时进行初始化，extern就会无效。

// extern 无效
extern int i = 0;

// 等同于
int i = 0;

上面代码中，extern对变量初始化的声明是无效的。这是为了防止多个extern对同一个变量进行多次初始化。

函数内部使用extern声明变量，就相当于该变量是静态存储，每次执行时都要从外部获取它的值。

函数本身默认是extern，即该函数可以被外部文件共享，通常省略extern不写。如果只希望函数在当前文件可用，那就需要在函数前面加上static。

1
2
3

extern int f(int i);
// 等同于
int f(int i);

register

register说明符向编译器表示，该变量是经常使用的，应该提供最快的读取速度，所以应该放进寄存器。但是，编译器可以忽略这个说明符，不一定按照这个指示行事。

1	register int a;

上面示例中，register提示编译器，变量a会经常用到，要为它提供最快的读取速度。

register只对声明在代码块内部的变量有效。

设为register的变量，不能获取它的地址。

1 2	register int a; int *p = &a; // 编译器报错

上面示例中，&a会报错，因为变量a可能放在寄存器里面，无法获取内存地址。

如果数组设为register，也不能获取整个数组或任一个数组成员的地址。

register int a[] = {11, 22, 33, 44, 55};

int p = a;  // 报错
int a = *(a + 2); // 报错

历史上，CPU 内部的缓存，称为寄存器（register）。与内存相比，寄存器的访问速度快得多，所以使用它们可以提高速度。但是它们不在内存之中，所以没有内存地址，这就是为什么不能获取指向它们的指针地址。现代编译器已经有巨大的进步，不管是否使用register关键字，都会尽可能使用寄存器，所以不保证一定会把这些变量放到寄存器。

volatile

volatile说明符表示所声明的变量，可能会预想不到地发生变化（即其他程序可能会更改它的值），不受当前程序控制，因此编译器不要对这类变量进行优化，每次使用时都应该查询一下它的值。硬件设备的编程中，这个说明符很常用。

1 2	volatile int foo; volatile int* bar;

volatile的目的是阻止编译器对变量行为进行优化，请看下面的例子。

1
2
3

int foo = x;
// 其他语句，假设没有改变 x 的值
int bar = x;

上面代码中，由于变量foo和bar都等于x，而且x的值也没有发生变化，所以编译器可能会把x放入缓存，直接从缓存读取值（而不是从 x 的原始内存位置读取），然后对foo和bar进行赋值。如果x被设定为volatile，编译器就不会把它放入缓存，每次都从原始位置去取x的值，因为在两次读取之间，其他程序可能会改变x。

restrict

restrict说明符允许编译器优化某些代码。它只能用于指针，表明该指针是访问数据的唯一方式。

1	int* restrict pt = (int) malloc(10 sizeof(int));

上面示例中，restrict表示变量pt是访问 malloc 所分配内存的唯一方式。

下面例子的变量foo，就不能使用restrict修饰符。

1 2	int foo[10]; int* bar = foo;

上面示例中，变量foo指向的内存，可以用foo访问，也可以用bar访问，因此就不能将foo设为 restrict。

如果编译器知道某块内存只能用一个方式访问，可能可以更好地优化代码，因为不用担心其他地方会修改值。

restrict用于函数参数时，表示参数的内存地址之间没有重叠。

void swap(int* restrict a, int* restrict b) {
  int t;
  t = *a;
  *a = *b;
  *b = t;
}

上面示例中，函数参数声明里的restrict表示，参数a和参数b的内存地址没有重叠。

多文件项目

简介

一个软件项目往往包含多个源码文件，编译时需要将这些文件一起编译，生成一个可执行文件。

假定一个项目有两个源码文件foo.c和bar.c，其中foo.c是主文件，bar.c是库文件。所谓“主文件”，就是包含了main()函数的项目入口文件，里面会引用库文件定义的各种函数。

// File foo.c
#include <stdio.h>

int main(void) {
  printf("%d\n", add(2, 3));  // 5!
}

上面代码中，主文件foo.c调用了函数add()，这个函数是在库文件bar.c里面定义的。

// File bar.c

int add(int x, int y) {
  return x + y;
}

现在，将这两个文件一起编译。

$ gcc -o foo foo.c bar.c

## 更省事的写法
$ gcc -o foo *.c

上面命令中，gcc 的-o参数指定生成的二进制可执行文件的文件名，本例是foo。

这个命令运行后，编译器会发出警告，原因是在编译foo.c的过程中，编译器发现一个不认识的函数add()，foo.c里面没有这个函数的原型或者定义。因此，最好修改一下foo.c，在文件头部加入add()的原型。

// File foo.c
#include <stdio.h>

int add(int, int);

int main(void) {
  printf("%d\n", add(2, 3));  // 5!
}

现在再编译就没有警告了。

你可能马上就会想到，如果有多个文件都使用这个函数add()，那么每个文件都需要加入函数原型。一旦需要修改函数add()（比如改变参数的数量），就会非常麻烦，需要每个文件逐一改动。所以，通常的做法是新建一个专门的头文件bar.h，放置所有在bar.c里面定义的函数的原型。

1
2
3

// File bar.h

int add(int, int);

然后使用include命令，在用到这个函数的源码文件里面加载这个头文件bar.h。

// File foo.c

#include <stdio.h>
#include "bar.h"

int main(void) {
  printf("%d\n", add(2, 3));  // 5!
}

上面代码中，#include "bar.h"表示加入头文件bar.h。这个文件没有放在尖括号里面，表示它是用户提供的；它没有写路径，就表示与当前源码文件在同一个目录。

然后，最好在bar.c里面也加载这个头文件，这样可以让编译器验证，函数原型与函数定义是否一致。

// File bar.c
#include "bar.h"

int add(int a, int b) {
  return a + b;
}

现在重新编译，就可以顺利得到二进制可执行文件。

1	gcc -o foo foo.c bar.c

重复加载

头文件里面还可以加载其他头文件，因此有可能产生重复加载。比如，a.h和b.h都加载了c.h，然后foo.c同时加载了a.h和b.h，这意味着foo.c会编译两次c.h。

最好避免这种重复加载，虽然多次定义同一个函数原型并不会报错，但是有些语句重复使用会报错，比如多次重复定义同一个 Struct 数据结构。解决重复加载的常见方法是，在头文件里面设置一个专门的宏，加载时一旦发现这个宏存在，就不再继续加载当前文件了。

// File bar.h
#ifndef BAR_H
  #define BAR_H
  int add(int, int);
#endif

上面示例中，头文件bar.h使用#ifndef和#endif设置了一个条件判断。每当加载这个头文件时，就会执行这个判断，查看有没有设置过宏BAR_H。如果设置过了，表明这个头文件已经加载过了，就不再重复加载了，反之就先设置一下这个宏，然后加载函数原型。

extern 说明符

当前文件还可以使用其他文件定义的变量，这时要使用extern说明符，在当前文件中声明，这个变量是其他文件定义的。

1	extern int myVar;

上面示例中，extern说明符告诉编译器，变量myvar是其他脚本文件声明的，不需要在这里为它分配内存空间。

由于不需要分配内存空间，所以extern声明数组时，不需要给出数组长度。

1	extern int a[];

这种共享变量的声明，可以直接写在源码文件里面，也可以放在头文件中，通过#include指令加载。

static 说明符

正常情况下，当前文件内部的全局变量，可以被其他文件使用。有时候，不希望发生这种情况，而是希望某个变量只局限在当前文件内部使用，不要被其他文件引用。

这时可以在声明变量的时候，使用static关键字，使得该变量变成当前文件的私有变量。

1	static int foo = 3;

上面示例中，变量foo只能在当前文件里面使用，其他文件不能引用。

编译策略

多个源码文件的项目，编译时需要所有文件一起编译。哪怕只是修改了一行，也需要从头编译，非常耗费时间。

为了节省时间，通常的做法是将编译拆分成两个步骤。第一步，使用 GCC 的-c参数，将每个源码文件单独编译为对象文件（object file）。第二步，将所有对象文件链接在一起，合并生成一个二进制可执行文件。

$ gcc -c foo.c ## 生成 foo.o
$ gcc -c bar.c ## 生成 bar.o

## 更省事的写法
$ gcc -c *.c

上面命令为源码文件foo.c和bar.c，分别生成对象文件foo.o和bar.o。

对象文件不是可执行文件，只是编译过程中的一个阶段性产物，文件名与源码文件相同，但是后缀名变成了.o。

得到所有的对象文件以后，再次使用gcc命令，将它们通过链接，合并生成一个可执行文件。

$ gcc -o foo foo.o bar.o

## 更省事的写法
$ gcc -o foo *.o

以后，修改了哪一个源文件，就将这个文件重新编译成对象文件，其他文件不用重新编译，可以继续使用原来的对象文件，最后再将所有对象文件重新链接一次就可以了。由于链接的耗时大大短于编译，这样做就节省了大量时间。

make 命令

大型项目的编译，如果全部手动完成，是非常麻烦的，容易出错。一般会使用专门的自动化编译工具，比如 make。

make 是一个命令行工具，使用时会自动在当前目录下搜索配置文件 makefile（也可以写成 Makefile）。该文件定义了所有的编译规则，每个编译规则对应一个编译产物。为了得到这个编译产物，它需要知道两件事。

依赖项（生成该编译产物，需要用到哪些文件）
生成命令（生成该编译产物的命令）

比如，对象文件foo.o是一个编译产物，它的依赖项是foo.c，生成命令是gcc -c foo.c。对应的编译规则如下：

1 2	foo.o: foo.c gcc -c foo.c

上面示例中，编译规则由两行组成。第一行首先是编译产物，冒号后面是它的依赖项，第二行则是生成命令。

注意，第二行的缩进必须使用 Tab 键，如果使用空格键会报错。

完整的配置文件 makefile 由多个编译规则组成，可能是下面的样子。

foo: foo.o bar.o
  gcc -o foo foo.o bar.o

foo.o: bar.h foo.c
  gcc -c foo.c

bar.o: bar.h bar.c
  gcc -c bar.c

上面是 makefile 的一个示例文件。它包含三个编译规则，对应三个编译产物（foo.o、bar.o和foo），每个编译规则之间使用空行分隔。

有了 makefile，编译时，只要在 make 命令后面指定编译目标（编译产物的名字），就会自动调用对应的编译规则。

$ make foo.o

## or
$ make bar.o

## or
$ make foo

上面示例中，make 命令会根据不同的命令，生成不同的编译产物。

如果省略了编译目标，make命令会执行第一条编译规则，构建相应的产物。

make

上面示例中，make后面没有编译目标，所以会执行 makefile 的第一条编译规则，本例是make foo。由于用户期望执行make后得到最终的可执行文件，所以建议总是把最终可执行文件的编译规则，放在 makefile 文件的第一条。makefile 本身对编译规则没有顺序要求。

make 命令的强大之处在于，它不是每次执行命令，都会进行编译，而是会检查是否有必要重新编译。具体方法是，通过检查每个源码文件的时间戳，确定在上次编译之后，哪些文件发生过变动。然后，重新编译那些受到影响的编译产物（即编译产物直接或间接依赖于那些发生变动的源码文件），不受影响的编译产物，就不会重新编译。

举例来说，上次编译之后，修改了foo.c，没有修改bar.c和bar.h。于是，重新运行make foo命令时，Make 就会发现bar.c和bar.h没有变动过，因此不用重新编译bar.o，只需要重新编译foo.o。有了新的foo.o以后，再跟bar.o一起，重新编译成新的可执行文件foo。

Make 这样设计的最大好处，就是自动处理编译过程，只重新编译变动过的文件，因此大大节省了时间。

命令行环境

命令行参数

C 语言程序可以从命令行接收参数。

1	./foo hello world

上面示例中，程序foo接收了两个命令行参数hello和world。

程序内部怎么拿到命令行参数呢？C 语言会把命令行输入的内容，放在一个数组里面。main()函数的参数可以接收到这个数组。

#include <stdio.h>

int main(int argc, char* argv[]) {
  for (int i = 0; i < argc; i++) {
    printf("arg %d: %s\n", i, argv[i]);
  }
}

上面示例中，main()函数有两个参数argc（argument count）和argv（argument variable）。这两个参数的名字可以任意取，但是一般来说，约定俗成就是使用这两个词。

第一个参数argc是命令行参数的数量，由于程序名也被计算在内，所以严格地说argc是参数数量 + 1。

第二个参数argv是一个数组，保存了所有的命令行输入，它的每个成员是一个字符串指针。

以./foo hello world为例，argc是3，表示命令行输入有三个组成部分：./foo、hello、world。数组argv用来获取这些输入，argv[0]是程序名./foo，argv[1]是hello，argv[2]是world。一般来说，argv[1]到argv[argc - 1]依次是命令行的所有参数。argv[argc]则是一个空指针 NULL。

由于字符串指针可以看成是字符数组，所以下面三种写法是等价的。

// 写法一
int main(int argc, char* argv[])

// 写法二
int main(int argc, char** argv)

// 写法三
int main(int argc, char argv[][])

另一方面，每个命令行参数既可以写成数组形式argv[i]，也可以写成指针形式*(argv + i)。

利用argc，可以限定函数只能有多少个参数。

#include <stdio.h>

int main(int argc, char** argv) {
  if (argc != 3) {
     printf("usage: mult x y\n");
     return 1;
  }

  printf("%d\n", atoi(argv[1]) * atoi(argv[2]));
  return 0;
}

上面示例中，argc不等于3就会报错，这样就限定了程序必须有两个参数，才能运行。

另外，argv数组的最后一个成员是 NULL 指针（argv[argc] == NULL）。所以，参数的遍历也可以写成下面这样。

1
2
3

for (char** p = argv; *p != NULL; p++) {
  printf("arg: %s\n", *p);
}

上面示例中，指针p依次移动，指向argv的每个成员，一旦移到空指针 NULL，就表示遍历结束。由于argv的地址是固定的，不能执行自增运算（argv++），所以必须通过一个中间变量p，完成遍历操作。

退出状态

C 语言规定，如果main()函数没有return语句，那么结束运行的时候，默认会添加一句return 0，即返回整数0。这就是为什么main()语句通常约定返回一个整数值，并且返回整数0表示程序运行成功。如果返回非零值，就表示程序运行出了问题。

Bash 的环境变量$?可以用来读取上一个命令的返回值，从而知道是否运行成功。

1
2
3

$ ./foo hello world
$ echo $?
0

上面示例中，echo $?用来打印环境变量$?的值，该值为0，就表示上一条命令运行成功，否则就是运行失败。

注意，只有main()会默认添加return 0，其他函数都没有这个机制。

环境变量

C 语言提供了getenv()函数（原型在stdlib.h）用来读取命令行环境变量。

#include <stdio.h>
#include <stdlib.h>

int main(void) {
  char* val = getenv("HOME");

  if (val == NULL) {
    printf("Cannot find the HOME environment variable\n");
    return 1;
  }

  printf("Value: %s\n", val);
  return 0;
}

上面示例中，getenv("HOME")用来获取命令行的环境变量$HOME，如果这个变量为空（NULL），则程序报错返回。

多字节字符

本章介绍 C 语言如何处理非英语字符。

Unicode 简介

C 语言诞生时，只考虑了英语字符，使用7位的 ASCII 码表示所有字符。ASCII 码的范围是0到127，也就是100多个字符，所以char类型只占用一个字节，

但是，如果处理非英语字符，一个字节就不够了，单单是中文，就至少有几万个字符，字符集就势必使用多个字节表示。

最初，不同国家有自己的字符编码方式，这样不便于多种字符的混用。因此，后来就逐渐统一到 Unicode 编码，将所有字符放入一个字符集。

Unicode 为每个字符提供一个号码，称为码点（code point），其中0到127的部分，跟 ASCII 码是重合的。通常使用“U+十六进制码点”表示一个字符，比如U+0041表示字母A。

Unicode 编码目前一共包含了100多万个字符，码点范围是 U+0000 到 U+10FFFF。完整表达整个 Unicode 字符集，至少需要三个字节。但是，并不是所有文档都需要那么多字符，比如对于 ASCII 码就够用的英语文档，如果每个字符使用三个字节表示，就会比单字节表示的文件体积大出三倍。

为了适应不同的使用需求，Unicode 标准委员会提供了三种不同的表示方法，表示 Unicode 码点。

UTF-8：使用1个到4个字节，表示一个码点。不同的字符占用的字节数不一样。
UTF-16：对于U+0000 到 U+FFFF 的字符（称为基本平面），使用2个字节表示一个码点。其他字符使用4个字节。
UTF-32：统一使用4个字节，表示一个码点。

其中，UTF-8 的使用最为广泛，因为对于 ASCII 字符（U+0000 到 U+007F），它只使用一个字节表示，这就跟 ASCII 的编码方式完全一样。

C 语言提供了两个宏，表示当前系统支持的编码字节长度。这两个宏都定义在头文件limits.h。

MB_LEN_MAX：任意支持地区的最大字节长度，定义在limits.h。
MB_CUR_MAX：当前语言的最大字节长度，总是小于或等于MB_LEN_MAX，定义在stdlib.h。

字符的表示方法

字符表示法的本质，是将每个字符映射为一个整数，然后从编码表获得该整数对应的字符。

C 语言提供了不同的写法，用来表示字符的整数号码。

\123：以八进制值表示一个字符，斜杠后面需要三个数字。
\x4D：以十六进制表示一个字符，\x后面是十六进制整数。
\u2620：以 Unicode 码点表示一个字符（不适用于 ASCII 字符），码点以十六进制表示，\u后面需要4个字符。
\U0001243F：以 Unicode 码点表示一个字符（不适用于 ASCII 字符），码点以十六进制表示，\U后面需要8个字符。

1
2
3

printf("ABC\n");
printf("\101\102\103\n");
printf("\x41\x42\x43\n");

上面三行都会输出“ABC”。

1 2	printf("\u2022 Bullet 1\n"); printf("\U00002022 Bullet 1\n");

上面两行都会输出“• Bullet 1”。

多字节字符的表示

C 语言预设只有基本字符，才能使用字面量表示，其它字符都应该使用码点表示，并且当前系统还必须支持该码点的编码方法。

所谓基本字符，指的是所有可打印的 ASCII 字符，但是有三个字符除外：@、$、`。

因此，遇到非英语字符，应该将其写成 Unicode 码点形式。

1 2	char* s = "\u6625\u5929"; printf("%s\n", s); // 春天

上面代码会输出中文“春天”。

如果当前系统是 UTF-8 编码，可以直接用字面量表示多字节字符。

1 2	char* s = "春天"; printf("%s\n", s);

注意，\u + 码点和\U + 码点的写法，不能用来表示 ASCII 码字符（码点小于0xA0的字符），只有三个字符除外：0x24（$），0x40（@）和0x60（`）。

1 2	char* s = "\u0024\u0040\u0060"; printf("%s\n", s); // @$`

上面代码会输出三个 Unicode 字符“@$`”，但是其它 ASCII 字符都不能用这种表示法表示。

为了保证程序执行时，字符能够正确解读，最好将程序环境切换到本地化环境。

1	set_locale(LC_ALL, "");

上面代码中，使用set_locale()切换到执行环境切换到系统的本地化语言。set_locale()的原型定义在头文件locale.h，详见标准库部分的《locale.h》章节。

像下面这样，指定编码语言也可以。

1	setlocale(LC_ALL, "zh_CN.UTF-8");

上面代码将程序执行环境，切换到中文环境的 UTF-8 编码。

C 语言允许使用u8前缀，对多字节字符串指定编码方式为 UTF-8。

1 2	char* s = u8"春天"; printf("%s\n", s);

一旦字符串里面包含多字节字符，就意味着字符串的字节数与字符数不再一一对应了。比如，字符串的长度为10字节，就不再是包含10个字符，而可能只包含7个字符、5个字符等等。

set_locale(LC_ALL, "");

char* s = "春天";
printf("%d\n", strlen(s)); // 6

上面示例中，字符串s只包含两个字符，但是strlen()返回的结果却是6，表示这两个字符一共占据了6个字节。

C 语言的字符串函数只针对单字节字符有效，对于多字节字符都会失效，比如strtok()、strchr()、strspn()、toupper()、tolower()、isalpha()等不会得到正确结果。

宽字符

上一小节的多字节字符串，每个字符的字节宽度是可变的。这种编码方式虽然使用起来方便，但是很不利于字符串处理，因此必须逐一检查每个字符占用的字节数。所以除了这种方式，C 语言还提供了确定宽度的多字节字符存储方式，称为宽字符（wide character）。

所谓“宽字符”，就是每个字符占用的字节数是固定的，要么是2个字节，要么是4个字节。这样的话，就很容易快速处理。

宽字符有一个单独的数据类型 wchar_t，每个宽字符都是这个类型。它属于整数类型的别名，可能是有符号的，也可能是无符号的，由当前实现决定。该类型的长度为16位（2个字节）或32位（4个字节），足以容纳当前系统的所有字符。它定义在头文件wchar.h里面。

宽字符的字面量必须加上前缀“L”，否则 C 语言会把字面量当作窄字符类型处理。

set_locale(LC_ALL, "");

wchar_t c = L'牛'；
printf("%lc\n", c);

wchar_t* s = L"春天";
printf("%ls\n", s);

上面示例中，前缀“L”在单引号前面，表示宽字符，对应printf()的占位符为%lc；在双引号前面，表示宽字符串，对应printf()的占位符为%ls。

宽字符串的结尾也有一个空字符，不过是宽空字符，占用多个字节。

处理宽字符，需要使用宽字符专用的函数，绝大部分都定义在头文件wchar.h。

多字节字符处理函数

mblen()

mblen()函数返回一个多字节字符占用的字符数。它的原型定义在头文件stdlib.h。

1	int mblen(const char* mbstr, size_t n);

它接受两个参数，第一个参数是多字节字符串指针，一般会检查该字符串的第一个字符；第二个参数是需要检查的字节数，这个数字不能大于当前系统单个字符占用的最大字节，一般使用MB_CUR_MAX。

它的返回值是该字符占用的字节数。如果当前字符是空的宽字符，则返回0；如果当前字符不是有效的多字节字符，则返回-1。

setlocale(LC_ALL, "");

char* mbs1 = "春天";
printf("%d\n", mblen(mbs1, MB_CUR_MAX)); // 3

char* mbs2 = "abc";
printf("%d\n", mblen(mbs2, MB_CUR_MAX)); // 1

上面示例中，字符串“春天”的第一个字符“春”，占用3个字节；字符串“abc”的第一个字符“a”，占用1个字节。

wctomb()

wctomb()函数（wide character to multibyte）用于将宽字符转为多字节字符。它的原型定义在头文件stdlib.h。

1	int wctomb(char* s, wchar_t wc);

wctomb()接受两个参数，第一个参数是作为目标的多字节字符数组，第二个参数是需要转换的一个宽字符。它的返回值是多字节字符存储占用的字节数量，如果无法转换，则返回-1。

setlocale(LC_ALL, "");

wchar_t wc = L'牛';
char mbStr[10] = "";

int nBytes = 0;
nBytes = wctomb(mbStr, wc);

printf("%s\n", mbStr);  // 牛
printf("%d\n", nBytes);  // 3

上面示例中，wctomb()将宽字符“牛”转为多字节字符，wctomb()的返回值表示转换后的多字节字符占用3个字节。

mbtowc()

mbtowc()用于将多字节字符转为宽字符。它的原型定义在头文件stdlib.h。

int mbtowc(
   wchar_t* wchar,
   const char* mbchar,
   size_t count
);

它接受3个参数，第一个参数是作为目标的宽字符指针，第二个参数是待转换的多字节字符指针，第三个参数是多字节字符的字节数。

它的返回值是多字节字符的字节数，如果转换失败，则返回-1。

setlocale(LC_ALL, "");

char* mbchar = "牛";
wchar_t wc;
wchar_t* pwc = &wc;

int nBytes = 0;
nBytes = mbtowc(pwc, mbchar, 3);

printf("%d\n", nBytes); // 3
printf("%lc\n", *pwc);  // 牛

上面示例中，mbtowc()将多字节字符“牛”转为宽字符wc，返回值是mbchar占用的字节数（占用3个字节）。

wcstombs()

wcstombs()用来将宽字符串转换为多字节字符串。它的原型定义在头文件stdlib.h。

size_t wcstombs(
   char* mbstr,
   const wchar_t* wcstr,
   size_t count
);

它接受三个参数，第一个参数mbstr是目标的多字节字符串指针，第二个参数wcstr是待转换的宽字符串指针，第三个参数count是用来存储多字节字符串的最大字节数。

如果转换成功，它的返回值是成功转换后的多字节字符串的字节数，不包括尾部的字符串终止符；如果转换失败，则返回-1。

下面是一个例子。

setlocale(LC_ALL, "");

char mbs[20];
wchar_t* wcs = L"春天";

int nBytes = 0;
nBytes = wcstombs(mbs, wcs, 20);

printf("%s\n", mbs); // 春天
printf("%d\n", nBytes); // 6

上面示例中，wcstombs()将宽字符串wcs转为多字节字符串mbs，返回值6表示写入mbs的字符串占用6个字节，不包括尾部的字符串终止符。

如果wcstombs()的第一个参数是 NULL，则返回转换成功所需要的目标字符串的字节数。

mbstowcs()

mbstowcs()用来将多字节字符串转换为宽字符串。它的原型定义在头文件stdlib.h。

size_t mbstowcs(
  wchar_t* wcstr,
  const char* mbstr,
  size_t count
);

它接受三个参数，第一个参数wcstr是目标宽字符串，第二个参数mbstr是待转换的多字节字符串，第三个参数是待转换的多字节字符串的最大字符数。

转换成功时，它的返回值是成功转换的多字节字符的数量；转换失败时，返回-1。如果返回值与第三个参数相同，那么转换后的宽字符串不是以 NULL 结尾的。

下面是一个例子。

setlocale(LC_ALL, "");

char* mbs = "天气不错";
wchar_t wcs[20];

int nBytes = 0;
nBytes = mbstowcs(wcs, mbs, 20);

printf("%ls\n", wcs); // 天气不错
printf("%d\n", nBytes); // 4

上面示例中，多字节字符串mbs被mbstowcs()转为宽字符串，成功转换了4个字符，所以该函数的返回值为4。

如果mbstowcs()的第一个参数为NULL，则返回目标宽字符串会包含的字符数量。

assert.h

assert()

assert.h头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。

1	assert(PI > 3);

上面代码在程序运行到这一行语句时，验证变量是否PI大于3。如果确实大于3，程序继续运行，否则就会终止运行，并且给出报错信息提示。

assert()宏接受一个表达式作为参数，如果表达式的返回值非零，assert()就会报错，在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。最后，调用abort()函数终止程序（abort()函数的原型在stdlib.h头文件中）。

1 2	z = x * x - y * y; assert(z >= 0);

上面的assert()语句类似于下面的代码。

if (z < 0) {
  puts("z less than 0");
  abort();
}

如果断言失败，程序会中断执行，会显示下面的提示。

1	Assertion failed: (z >= 0), function main, file /Users/assert.c, line 14.

上面报错的格式如下。

1	Assertion failed: [expression], function [abc], file [xyz], line [nnn].

上面代码中，方括号的部分使用实际数据替换掉。

使用 assert() 有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断言，就在#include <assert.h>语句的前面，定义一个宏NDEBUG。

1 2	#define NDEBUG #include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的 assert() 语句。如果程序又出现问题，可以移除这条#define NDBUG指令（或者把它注释掉），再次编译，这样就重新启用了 assert() 语句。

assert() 的缺点是，因为引入了额外的检查，增加了程序的运行时间。

static_assert()

C11 引入了静态断言static_assert()，用于在编译阶段进行断言判断。

1	static_assert(constant-expression, string-literal);

static_assert()接受两个参数，第一个参数constant-expression是一个常量表达式，第二个参数string-literal是一个提示字符串。如果第一个参数的值为false，会产生一条编译错误，第二个参数就是错误提示信息。

1	static_assert(sizeof(int) == 4, "64-bit code generation is not supported.");

上面代码的意思是，如果当前计算机的int类型不等于4个字节，就会编译报错。

注意，static_assert()只在编译阶段运行，无法获得变量的值。如果对变量进行静态断言，就会导致编译错误。

int positive(const int n) {
  static_assert(n > 0, "value must > 0");
  return 0;
}

上面代码会导致编译报错，因为编译时无法知道变量n的值。

static_assert()的好处是，尽量在编译阶段发现错误，避免运行时再报错，节省开发时间。另外，有些assert()断言位于函数之中，如果不执行该函数，就不会报错，而static_assert()不管函数是否执行，都会进行断言判断。最后，static_assert()不会生成可执行代码，所以不会造成任何运行时的性能损失。

ctype.h

ctype.h头文件定义了一系列字符处理函数的原型。

字符测试函数

这些函数用来判断字符是否属于某种类型。

isalnum()：是否为字母数字
isalpha()：是否为字母
isdigit()：是否为数字
isxdigit()：是否为十六进制数字符
islower()：是否为小写字母
isupper()：是否为大写字母
isblank()：是否为标准的空白字符（包含空格、水平制表符或换行符）
isspace()：是否为空白字符（空格、换行符、换页符、回车符、垂直制表符、水平制表符等）
iscntrl()：是否为控制字符，比如 Ctrl + B
isprint()：是否为可打印字符
isgraph()：是否为空格以外的任意可打印字符
ispunct()：是否为标点符号（除了空格、字母、数字以外的可打印字符）

它们接受一个待测试的字符作为参数。注意，参数类型为int，而不是char，因为它们允许 EOF 作为参数。

如果参数字符属于指定类型，就返回一个非零整数（通常是1，表示为真），否则返回0（表示为伪）。

下面是一个例子，用户输入一个字符，程序判断是否为英文字母。

#include <stdio.h>
#include <ctype.h>

int main(void) {
  char ch = getchar();

  if (isalpha(ch))
    printf("it is an alpha character.\n");
  else
    printf("it is not an alpha character.\n");

  return 0;
}

字符映射函数

这一类函数返回字符的某种对应形式，主要有两个函数。

tolower()：如果参数是大写字符，返回小写字符，否则返回原始参数。
toupper()：如果参数是小写字符，返回大写字符，否则返回原始参数。

1 2	// 将字符转为大写 ch = toupper(ch);

注意，这两个函数不会改变原始字符。

errno.h

errno 变量

errno.h声明了一个 int 类型的 errno 变量，用来存储错误码（正整数）。

如果这个变量有非零值，表示已经执行的程序发生了错误。

int x = -1;

errno = 0;

int y = sqrt(x);

if (errno != 0) {
  fprintf(stderr, "sqrt error; program terminated.\n");
  exit(EXIT_FAILURE);
}

上面示例中，计算一个负值的平方根是不允许的，会导致errno不等于0。

如果要检查某个函数是否发生错误，必须在即将调用该函数之前，将errno的值置为0，防止其他函数改变errno的值。

宏

变量errno的值通常是两个宏EDOM或ERANGE。这两个宏都定义在errno.h。它们表示调用数学函数时，可能发生的两种错误。

定义域错误（EDOM）：传递给函数的一个参数超出了函数的定义域。例如，负数传入sqrt()作为参数。
取值范围错误（ERANGE）：函数的返回值太大，无法用返回类型表示。例如，1000 传入exp()作为参数，因为 e^1000 太大，无法使用 double 类型表示。

使用数学函数时，可以将errno的值与 EDOM 和 ERANGE 比较，用来确定到底发生了哪一类错误。

float.h

float.h定义了浮点数类型 float、double、long double 的一些宏，规定了这些类型的范围和精度。

(1) FLT_ROUNDS

宏FLT_ROUNDS表示当前浮点数加法的四舍五入方向。

它有以下可能的值。

-1：不确定。
0：向零舍入。
1：向最近的整数舍入。
2：向正无穷方向舍入。
3：向负无穷方向舍入。

（2）FLT_RADIX

宏FLT_RADIX表示科学计数法的指数部分的底（base），一般总是2。

（3）浮点数类型的最大值

FLT_MAX
DBL_MAX
LDBL_MAX

（4）浮点数类型的最小正值

FLT_MIN
DBL_MIN
LDBL_MIN

（5）两个同类型浮点数之间可表示的最小差值（最小精度）

FLT_EPSILON
DBL_EPSILON
LDBL_EPSILON

（6）DECIMAL_DIG

宏DECIMAL_DIG表示十进制有效位数。

（7）FLT_EVAL_METHOD

宏FLT_EVAL_METHOD表示浮点数运算时的类型转换。

它可能有以下值。

-1：不确定。
0：在当前类型中运算。
1：float 和 double 类型的运算使用 double 类型的范围和精度求值。
2：所有浮点数类型的运算使用 long double 类型的范围和精度求值。

（8）浮点数尾数部分的个数

FLT_MANT_DIG
DBL_MANT_DIG
LDBL_MANT_DIG

（9）浮点数指数部分有效数字的个数（十进制）

FLT_DIG
DBL_DIG
LDBL_DIG

（10）科学计数法的指数部分的最小次幂（负数）

FLT_MIN_EXP
DBL_MIN_EXP
LDBL_MIN_EXP

（11）科学计数法的指数部分的十进制最小次幂（负数）

FLT_MIN_10_EXP
DBL_MIN_10_EXP
LDBL_MIN_10_EXP

（12）科学计数法的指数部分的最大次幂

FLT_MAX_EXP
DBL_MAX_EXP
LDBL_MAX_EXP

科学计数法的指数部分的十进制最大次幂

FLT_MAX_10_EXP
DBL_MAX_10_EXP
LDBL_MAX_10_EXP

inttypes.h

C 语言还在头文件 inttypes.h 里面，为 stdint.h 定义的四类整数类型，提供了printf()和scanf()的占位符。

固定宽度整数类型，比如 int8_t。
最小宽度整数类型，比如 int_least8_t。
最快最小宽度整数类型，比如 int_fast8_t。
最大宽度整数类型，比如 intmax_t。

printf()的占位符采用PRI + 原始占位符 + 类型关键字/宽度的形式构成。举例来说，原始占位符为%d，则对应的占位符如下。

PRIdn （固定宽度类型）
PRIdLEASTn （最小宽度类型）
PRIdFASTn （最快最小宽度类型）
PRIdMAX （最大宽度类型）

上面占位符中的n，可以用8、16、32、64代入。

下面是用法示例。

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
  int_least16_t x = 3490;
  printf("The value is %" PRIdLEAST16 "!\n", x);
}

上面示例中，PRIdLEAST16对应的整数类型为 int_least16_t，原始占位符为%d。另外，printf()的第一个参数用到了多个字符串自动合并的写法。

下面是其它的原始占位符对应的占位符。

%i：PRIin PRIiLEASTn PRIiFASTn PRIiMAX
%o：PRIon PRIoLEASTn PRIoFASTn PRIoMAX
%u：PRIun PRIuLEASTn PRIuFASTn PRIuMAX
%x：PRIxn PRIxLEASTn PRIxFASTn PRIxMAX
%X：PRIXn PRIXLEASTn PRIXFASTn PRIXMAX

scanf()的占位符规则也与之类似。

%d：SCNdn SCNdLEASTn SCNdFASTn SCNdMAX
%i：SCNin SCNiLEASTn SCNiFASTn SCNiMAX
%o：SCNon SCNoLEASTn SCNoFASTn SCNoMAX
%u：SCNun SCNuLEASTn SCNuFASTn SCNuMAX
%x：SCNxn SCNxLEASTn SCNxFASTn SCNxMAX

iso646.h

iso646.h头文件指定了一些常见运算符的替代拼写。比如，它用关键字and代替逻辑运算符&&。

1
2
3

if (x > 6 and x < 12)
// 等同于
if (x > 6 && x < 12)

它定义的替代拼写如下。

and 替代 &&
and_eq 替代 &=
bitand 替代 &
bitor 替代 |
compl 替代 ~
not 替代 !
not_eq 替代 !=
or 替代 ||
or_eq 替代 |=
xor 替代 ^
xor_eq 替代 ^=

limits.h

limits.h提供了用来定义各种整数类型（包括字符类型）取值范围的宏。

CHAR_BIT：每个字符包含的二进制位数。
SCHAR_MIN：signed char 类型的最小值。
SCHAR_MAX：signed char 类型的最大值。
UCHAR_MAX：unsiged char 类型的最大值。
CHAR_MIN：char 类型的最小值。
CHAR_MAX：char 类型的最大值。
MB_LEN_MAX：多字节字符最多包含的字节数。
SHRT_MIN：short int 类型的最小值。
SHRT_MAX：short int 类型的最大值。
USHRT_MAX：unsigned short int 类型的最大值。
INT_MIN：int 类型的最小值。
INT_MAX：int 类型的最大值。
UINT_MAX：unsigned int 类型的最大值。
LONG_MIN：long int 类型的最小值。
LONG_MAX：long int 类型的最大值。
ULONG_MAX：unsigned long int 类型的最大值。
LLONG_MIN：long long int 类型的最小值。
LLONG_MAX：long long int 类型的最大值。
ULLONG_MAX：unsigned long long int 类型的最大值。

下面的示例是使用预处理指令判断，int 类型是否可以用来存储大于 100000 的数。

1
2
3

#if INT_MAX < 100000
  #error int type is too small
#endif

上面示例中，如果 int 类型太小，预处理器会显示一条出错消息。

可以使用limit.h里面的宏，为类型别名选择正确的底层类型。

#if INT_MAX >= 100000
  typedef int Quantity;
#else
  typedef long int Quantity;
#endif

上面示例中，如果整数类型的最大值（INT_MAX）不小于100000，那么类型别名Quantity指向int，否则就指向long int。

locale.h

简介

locale.h是程序的本地化设置，主要影响以下的行为。

数字格式
货币格式
字符集
日期和时间格式

它设置了以下几个宏。

LC_COLLATE：影响字符串比较函数strcoll()和strxfrm()。
LC_CTYPE：影响字符处理函数的行为。
LC_MONETARY：影响货币格式。
LC_NUMERIC：影响printf()的数字格式。
LC_TIME：影响时间格式strftime()和wcsftime()。
LC_ALL：将以上所有类别设置为给定的语言环境。

setlocale()

setlocale()用来设置当前的地区。

1	char* setlocal(int category, const char* locale);

它接受两个参数。第一个参数表示影响范围，如果值为前面五个表示类别的宏之一，则只影响该宏对应的类别，如果值为LC_ALL，则影响所有类别。第二个参数通常只为"C"（正常模式）或""（本地模式）。

任意程序开始时，都隐含下面的调用。

1	setlocale(LC_ALL, "C");

下面的语句将格式本地化。

1	set_locale(LC_ALL, "");

上面示例中，第二个参数为空字符，表示使用当前环境提供的本地化设置。

理论上，第二个参数也可以设为当前系统支持的某种格式。

1	setlocale(LC_ALL, "en_US.UTF-8");

但是这样的话，程序的可移植性就变差了，因为无法保证其他系统也会支持那种格式。所以，通常都将第二个参数设为空字符串，使用操作系统的当前设置。

setlocale()的返回值是一个字符串指针，表示已经设置好的格式。如果调用失败，则返回空指针 NULL。

setlocale()可以用来查询当前地区，这时第二个参数设为 NULL 就可以了。

char *loc;

loc = setlocale(LC_ALL, NULL);

// 输出 Starting locale: C
printf("Starting locale: %s\n", loc);

loc = setlocale(LC_ALL, "");

// 输出 Native locale: en_US.UTF-8    
printf("Native locale: %s\n", loc);

localeconv()

localeconv()用来获取当前格式的详细信息。

1	struct lconv* localeconv(void);

该函数返回一个 Struct 结构指针，该结构里面包含了格式信息，它的主要属性如下。

char* mon_decimal_point：货币的十进制小数点字符，比如.。
char* mon_thousands_sep：货币的千位分隔符，比如,。
char* mon_grouping：货币的分组描述符。
char* positive_sign：货币的正值符号，比如+或为空字符串。
char* negative_sign：货币的负值符号，比如-。
char* currency_symbol：货币符号，比如$。
char frac_digits：打印货币金额时，十进制小数点后面输出几位小数，比如设为2。
char p_cs_precedes：设为1时，货币符号currency_symbol出现在非负金额前面。设为0时，出现在后面。
char n_cs_precedes：设为1时，货币符号currency_symbol出现在负的货币金额前面。设为0时，出现在后面。
char p_sep_by_space：决定了非负的货币金额与货币符号之间的分隔字符。
char n_sep_by_space：决定了负的货币金额与货币符号之间的分隔字符。
char p_sign_posn：决定了非负值的正值符号的位置。
char n_sign_posn：决定了负值的负值符号的位置。
char* int_curr_symbol：货币的国际符号，比如USD。
char int_frac_digits：使用国际符号时，frac_digits的值。
char int_p_cs_precedes：使用国际符号时，p_cs_precedes的值。
char int_n_cs_precedes：使用国际符号时，n_cs_precedes的值。
char int_p_sep_by_space：使用国际符号时，p_sep_by_space的值。
char int_n_sep_by_space：使用国际符号时，n_sep_by_space的值。
char int_p_sign_posn：使用国际符号时，p_sign_posn的值。
char int_n_sign_posn：使用国际符号时，n_sign_posn的值。

下面程序打印当前系统的属性值。

#include <stdio.h>
#include <locale.h>
#include <string.h>

int main ()
{
    setlocale (LC_ALL,"zh_CN");
    struct lconv * lc;
    lc=localeconv();
    printf ("decimal_point: %s\n",lc->decimal_point);
    printf ("thousands_sep: %s\n",lc->thousands_sep);
    printf ("grouping: %s\n",lc->grouping);
    printf ("int_curr_symbol: %s\n",lc->int_curr_symbol);
    printf ("currency_symbol: %s\n",lc->currency_symbol);
    printf ("mon_decimal_point: %s\n",lc->mon_decimal_point);
    printf ("mon_thousands_sep: %s\n",lc->mon_thousands_sep);
    printf ("mon_grouping: %s\n",lc->mon_grouping);
    printf ("positive_sign: %s\n",lc->positive_sign);
    printf ("negative_sign: %s\n",lc->negative_sign);
    printf ("frac_digits: %d\n",lc->frac_digits);
    printf ("p_cs_precedes: %d\n",lc->p_cs_precedes);
    printf ("n_cs_precedes: %d\n",lc->n_cs_precedes);
    printf ("p_sep_by_space: %d\n",lc->p_sep_by_space);
    printf ("n_sep_by_space: %d\n",lc->n_sep_by_space);
    printf ("p_sign_posn: %d\n",lc->p_sign_posn);
    printf ("n_sign_posn: %d\n",lc->n_sign_posn);
    printf ("int_frac_digits: %d\n",lc->int_frac_digits);
    printf ("int_p_cs_precedes: %d\n",lc->int_p_cs_precedes);
    printf ("int_n_cs_precedes: %d\n",lc->int_n_cs_precedes);
    printf ("int_p_sep_by_space: %d\n",lc->int_p_sep_by_space);
    printf ("int_n_sep_by_space: %d\n",lc->int_n_sep_by_space);
    printf ("int_p_sign_posn: %d\n",lc->int_p_sign_posn);
    printf ("int_n_sign_posn: %d\n",lc->int_n_sign_posn);
   
    return 0;
}

math.h

math.h头文件提供了很多数学函数。

很多数学函数的返回值是 double 类型，但是同时提供 float 类型与 long double 类型的版本，比如pow()函数就还有powf()和powl()版本。

1
2
3

double      pow(double x, double y); 
float       powf(float x, float y);
long double powl(long double x, long double y);

为了简洁，下面就略去了函数的f后缀（float 类型）和l后缀（long double）版本。

类型和宏

math.h 新定义了两个类型别名。

float_t：（当前系统）最有效执行 float 运算的类型，宽度至少与 float 一样。
double_t`：（当前系统）最有效执行 double 运算的类型，宽度至少与 double 一样。

它们的具体类型可以通过宏FLT_EVAL_METHOD来了解。

FLT_EVAL_METHOD 的值	float_t 对应的类型	double_t 对应的类型
0	float	double
1	double	double
2	long double	long double
其他	由实现决定	由实现决定

math.h 还定义了一些宏。

INFINITY：表示正无穷，返回一个 float 类型的值。
NAN：表示非数字（Not-A-Number），返回一个 float 类型的值。

错误类型

数学函数的报错有以下类型。

Range errors：运算结果不能用函数返回类型表示。
Domain errors：函数参数不适用当前函数。
Pole errors：参数导致函数的极限值变成无限。
Overflow errors：运算结果太大，导致溢出。
Underflow errors：运算结果太小，导致溢出。

变量math_errhandling提示了当前系统如何处理数学运算错误。

math_errhandling 的值	描述
MATH_ERRNO	系统使用 errno 表示数学错误
MATH_ERREXCEPT	系统使用异常表示数学错误
MATH_ERRNO	MATH_ERREXCEPT

数值类型

数学函数的参数可以分成以下几类：正常值，无限值，有限值和非数字。

下面的函数用来判断一个值的类型。

fpclassify()：返回给定浮点数的分类。
isfinite()：如果参数不是无限或 NaN，则为真。
isinf()：如果参数是无限的，则为真。
isnan()：如果参数不是数字，则为真。
isnormal()：如果参数是正常数字，则为真。

下面是一个例子。

isfinite(1.23)    // 1
isinf(1/tan(0))   // 1
isnan(sqrt(-1))   // 1
isnormal(1e-310)) // 0

signbit()

signbit()判断参数是否带有符号。如果参数为负值，则返回1，否则返回0。

1 2	signbit(3490.0) // 0 signbit(-37.0) // 1

三角函数

以下是三角函数，参数为弧度值。

acos()：反余弦。
asin()：反正弦。
atan()：反正切
atan2()：反正切。
cos()：余弦。
sin()：正弦。
tan()：正切。

不要忘了，上面所有函数都有 float 版本（函数名加上 f 后缀）和 long double 版本（函数名加上 l 后缀）。

下面是一个例子。

1	cos(PI/4) // 0.707107

双曲函数

以下是双曲函数，参数都为浮点数。

acosh()：反双曲余弦。
asinh()：反双曲正弦。
atanh()：反双曲正切。
cosh()：双曲余弦。
tanh()：双曲正切。
sinh()：双曲正弦。

指数函数和对数函数

以下是指数函数和对数函数，它们的返回值都是 double 类型。

exp()：计算欧拉数 e 的乘方，即 e^x。
exp2()：计算 2 的乘方，即 2^x。
expm1()：计算 e^x - 1。
log()：计算自然对数，exp()的逆运算。
log2()：计算以2为底的对数。
log10()：计算以10为底的对数。
logp1()：计算一个数加 1 的自然对数，即ln(x + 1)。
logb()：计算以宏FLT_RADIX（一般为2）为底的对数，但只返回整数部分。

下面是一些例子。

1
2
3

exp(3.0) // 20.085500
log(20.0855) // 3.000000
log10(10000) // 3.000000

如果结果值超出了 C 语言可以表示的最大值，函数将返回HUGE_VAL，它是一个在math.h中定义的 double 类型的值。

如果结果值太小，无法用 double 值表示，函数将返回0。以上这两种情况都属于出错。

frexp()

frexp()将参数分解成浮点数和指数部分（2为底数），比如 1234.56 可以写成 0.6028125 * 2¹¹，这个函数就能分解出 0.6028125 和 11。

1	double frexp(double value, int* exp);

它接受两个参数，第一个参数是用来分解的浮点数，第二个参数是一个整数变量指针。

它返回小数部分，并将指数部分放入变量exp。如果参数为0，则返回的小数部分和指数部分都为0。

下面是一个例子。

double frac;
int expt;

// expt 的值是 11
frac = frexp(1234.56, &expt);

// 输出 1234.56 = 0.6028125 x 2^11
printf("1234.56 = %.7f x 2^%d\n", frac, expt);

ilogb()

ilogb()返回一个浮点数的指数部分，指数的基数是宏FLT_RADIX（一般是2）。

1	int ilogb(double x);

它的参数为x，返回值是 log_r|x|，其中r为宏FLT_RADIX。

下面是用法示例。

1
2
3

ilogb(257) // 8
ilogb(256) // 8
ilogb(255) // 7

ldexp()

ldexp()将一个数乘以2的乘方。它可以看成是frexp()的逆运算，将小数部分和指数部分合成一个f * 2^n形式的浮点数。

1	double ldexp(double x, int exp);

它接受两个参数，第一个参数是乘数x，第二个参数是2的指数部分exp，返回“x * 2^exp”。

ldexp(1, 10) // 1024.000000
ldexp(3, 2) // 12.000000
ldexp(0.75, 4) // 12.000000
ldexp(0.5, -1) // 0.250000

modf()

modf()函数提取一个数的整数部分和小数部分。

1	double modf(double value, double* iptr);

它接受两个参数，第一个参数value表示待分解的数值，第二个参数是浮点数变量iptr。返回值是value的小数部分，整数部分放入变量double。

下面是一个例子。

1 2	// int_part 的值是 3.0 modf(3.14159, &int_part); // 返回 0.14159

scalbn()

scalbn()用来计算“x * rⁿ”，其中r是宏FLT_RADIX。

1	double scalbn(double x, int n);

它接受两个参数，第一个参数x是乘数部分，第二个参数n是指数部分，返回值是“x * rⁿ”。

下面是一些例子。

1	scalbn(2, 8) // 512.000000

这个函数有多个版本。

scalbn()：指数 n 是 int 类型。
scalbnf()：float 版本的 scalbn()。
scalbnl()：long double 版本的 scalbn()。
scalbln()：指数 n 是 long int 类型。
scalblnf()：float 版本的 scalbln()。
scalblnl()：long double 版本的 scalbln()。

round()

round()函数以传统方式进行四舍五入，比如1.5舍入到2，-1.5舍入到-2。

1	double round(double x);

它返回一个浮点数。

下面是一些例子。

round(3.14)  // 3.000000
round(3.5)   // 4.000000
round(-1.5)  // -2.000000
round(-1.14) // -1.000000

它还有一些其他版本。

lround()：返回值是 long int 类型。
llround()：返回值是 long long int 类型。

trunc()

trunc()用来截去一个浮点数的小数部分，将剩下的整数部分以浮点数的形式返回。

1	double trunc(double x);

下面是一些例子。

trunc(3.14)  // 3.000000
trunc(3.8)   // 3.000000
trunc(-1.5)  // -1.000000
trunc(-1.14) // -1.000000

ceil()

ceil()返回不小于其参数的最小整数（double 类型），属于“向上舍入”。

1	double ceil(double x);

下面是一些例子。

ceil(7.1) // 8.0
ceil(7.9) // 8.0
ceil(-7.1) // -7.0
ceil(-7.9) // -7.0

floor()

floor()返回不大于其参数的最大整数，属于“向下舍入”。

1	double floor(double x);

下面是一些例子。

floor(7.1) // 7.0
floor(7.9) // 7.0
floor(-7.1) // -8.0
floor(-7.9) // -8.0

下面的函数可以实现“四舍五入”。

1
2
3

double round_nearest(double x) {
  return x < 0.0 ? ceil(x - 0.5) : floor(x + 0.5);
}

fmod()

fmod()返回第一个参数除以第二个参数的余数，就是余值运算符%的浮点数版本，因为%只能用于整数运算。

1	double fmod(double x, double y);

它在幕后执行的计算是x - trunc(x / y) * y，返回值的符号与x的符号相同。

1
2
3

fmod(5.5, 2.2)  //  1.100000
fmod(-9.2, 5.1) // -4.100000
fmod(9.2, 5.1)  //  4.100000

浮点数比较函数

以下函数用于两个浮点数的比较，返回值的类型是整数。

isgreater()：返回x > y的结果。
isgreaterequal()：返回x >= y的结果。
isless()：返回x < y的结果。
islessequal()：返回x <= y的结果。
islessgreater()：返回(x < y) || (x > y)的结果。

下面是一些例子。

isgreater(10.0, 3.0)   // 1
isgreaterequal(10.0, 10.0)   // 1
isless(10.0, 3.0)  // 0
islessequal(10.0, 3.0)   // 0
islessgreater(10.0, 3.0)   // 1
islessgreater(10.0, 30.0)   // 1
islessgreater(10.0, 10.0)   // 0

isunordered()

isunordered()返回两个参数之中，是否存在 NAN。

1	int isunordered(any_floating_type x, any_floating_type y);

下面是一些例子。

isunordered(1.0, 2.0)    // 0
isunordered(1.0, sqrt(-1))  // 1
isunordered(NAN, 30.0)  // 1
isunordered(NAN, NAN)   // 1

其他函数

下面是 math.h 包含的其它函数。

pow()：计算参数x的y次方。
sqrt()：计算一个数的平方根。
cbrt()：计算立方根。
fabs()：计算绝对值。
hypot()：根据直角三角形的两条直角边，计算斜边。
fmax()：返回两个参数之中的最大值。
fmin()：返回两个参数之中的最小值。
remainder()：返回 IEC 60559 标准的余数，类似于fmod()，但是余数范围是从-y/2到y/2，而不是从0到y。
remquo()：同时返回余数和商，余数的计算方法与remainder()相同。
copysign()：返回一个大小等于第一个参数、符号等于第二个参数的值。
nan()：返回 NAN。
nextafter()：获取下一个（或者上一个，具体方向取决于第二个参数y）当前系统可以表示的浮点值。
nextoward()：与nextafter()相同，除了第二个参数是 long double 类型。
fdim()：如果第一个参数减去第二个参数大于0，则返回差值，否则返回0。
fma()：以快速计算的方式，返回x * y + z的结果。
nearbyint()：在当前舍入方向上，舍入到最接近的整数。当前舍入方向可以使用fesetround()函数设定。
rint()：在当前舍入方向上，舍入到最接近的整数，与nearbyint()相同。不同之处是，它会触发浮点数的INEXACT异常。
lrint()：在当前舍入方向上，舍入到最接近的整数，与rint()相同。不同之处是，返回值是一个整数，而不是浮点数。
erf()：计算一个值的误差函数。
erfc()：计算一个值的互补误差函数。
tgamma()：计算 Gamma 函数。
lgamma()：计算 Gamma 函数绝对值的自然对数。

下面是一些例子。

pow(3, 4) // 81.000000
sqrt(3.0) // 1.73205
cbrt(1729.03) // 12.002384
fabs(-3490.0) // 3490.000000
hypot(3, 4) // 5.000000
fmax(3.0, 10.0) // 10.000000
fmin(10.0, 3.0) //  3.000000

signal.h

简介

signal.h提供了信号（即异常情况）的处理工具。所谓“信号”（signal），可以理解成系统与程序之间的短消息，主要用来表示运行时错误，或者发生了异常事件。

头文件signal.h定义了一系列宏，表示不同的信号。

SIGABRT：异常中止（可能由于调用了 abort() 方法）。
SIGFPE：算术运算发生了错误（可能是除以 0 或者溢出）。
SIGILL：无效指令。
SIGINT：中断。
SIGSEGV：无效内存访问。
SIGTERM：终止请求。

上面每个宏的值都是一个正整数常量。

signal()

头文件signal.h还定义了一个signal()函数，用来指定某种信号的处理函数。

1	signal(SIGINT, handler);

signal()接受两个参数，第一个参数是某种信号的宏，第二个参数是处理这个信号的函数指针handler。

信号处理函数handler接受一个 int 类型的参数，表示信号类型。它的原型如下。

1	void (*func)(int);

handler函数体内部可以根据这个整数，判断到底接受到了哪种信号，因为多个信号可以共用同一个处理函数。一旦处理函数执行完成，程序会从信号发生点恢复执行。但是，如果遇到 SIGABRT 信号，处理函数执行完成，系统会让程序中止。

当系统向程序发送信号时，程序可以忽略信号，即不指定处理函数。

signal()的返回值是前一个处理函数的指针，常常把它保存在变量之中，当新的处理函数执行完，再恢复以前的处理函数。

void (*orig_handler)(int);
orig_handler = signal(SIGINT, handler);
// SIGINT 信号发生之后
signal(SIGINT, orig_handler);

上面示例中，signal()为信号SIGINT指定了新的处理函数handler，把原来的处理函数保存在变量orig_handler里面。等到handler这个函数用过之后，再恢复原来的处理函数。

信号相关的宏

signal.h还提供了信号相关的宏。

（1）SIG_DFL

SIG_DFL 表示默认的处理函数。

1	signal(SIGINT, SIG_DFL);

上面示例中，SIGINT 的处理函数是默认处理函数，由当前实现决定。

（2）SIG_IGN

SIG_IGN 表示忽略该信号。

1	signal(SIGINT, SIG_IGN);

上面示例表示不对 SIGINT 信号进行处理。由于程序运行时按下 Ctrl + c 是发出 SIGINT 信号，所以使用该语句后，程序无法用 Ctrl + c 终止。

（3）SIG_ERR

SIG_ERR 是信号处理函数发生错误时，signal()的返回值。

if (signal(SIGINT, handler) == SIG_ERR) {
  perror("signal(SIGINT, handler) failed");
  // ...
}

上面示例可以判断handler处理 SIGINT 时，是否发生错误。

raise()

raise()函数用来在程序中发出信号。

1	int raise(int sig);

它接受一个信号值作为参数，表示发出该信号。它的返回值是一个整数，可以用来判断信号发出是否成功，0 表示成功，非 0 表示失败。

void handler(int sig) {
  printf("Handler called for signal %d\n", sig);
}

signal(SIGINT, handler);
raise(SIGINT);

上面示例中，raise()触发 SIGINT 信号，导致 handler 函数执行。

stdarg.h

stdarg.h定义于函数的可变参数相关的一些方法。

va_list 类型
va_start()
va_arg()：获取当前参数
va_end()。

va_copy()：it makes a copy of your va_list variable in the exact same state.
va_copy() can be useful if you need to scan ahead through the arguments but need to also remember your current place.

接受可变函数作为参数的一些方法。

vprintf()
vfprintf()
vsprintf()
vsnprintf()

#include <stdio.h>
#include <stdarg.h>

int my_printf(int serial, const char *format, ...)
{
    va_list va;

    // Do my custom work
    printf("The serial number is: %d\n", serial);

    // Then pass the rest off to vprintf()
    va_start(va, format);
    int rv = vprintf(format, va);
    va_end(va);

    return rv;
}

int main(void)
{
    int x = 10;
    float y = 3.2;

    my_printf(3490, "x is %d, y is %f\n", x, y);
}

stdbool.h

stdbool.h头文件定义了4个宏。

bool：定义为_Bool。
true：定义为1。
false：定义为0。
__bool_true_false_are_defined：定义为1。

bool isEven(int number) {
  if (number % 2) {
    return true;
  } else {
    return false;
  }
}

#include <stdio.h>
#include <stdbool.h>

int main(void) {
  unsigned long num;
  unsigned long div;
  bool isPrime = true;

  num = 64457;

  for (div = 2; (div * div) <= num; div++) {
   if (num % div == 0) isPrime = false;
  }

  if (isPrime) {
    printf("%lu is prime.\n", num);
  } else {
    printf("%lu is not prime.\n", num);
  }

  return 0;
}

stddef.h

stddef.h提供了常用类型和宏的定义，但没有声明任何函数。

这个头文件定义的类型如下。

ptrdiff_t：指针相减运算时，返回结果的数据类型。
size_t：sizeof运算符返回的类型。
wchar_t：一种足够大、能容纳各种字符的类型。

以上三个类型都是整数类型，其中ptrdiff_t是有符号整数，size_t是无符号整数。

stddef.h定义了两个宏。

NULL：空指针。
offsetof()

offsetof()

offsetof()是stddef.h定义的一个宏，用来返回某个属性在 Struct 结构内部的起始位置。由于系统为了字节对齐，可能会在 Struct 结构的属性之间插入空字节，这个宏对于确定某个属性的内存位置很有用。

它是一个带参数的宏，接受两个参数。第一个参数是 Struct 结构，第二个参数是该结构的一个属性，返回 Struct 起始位置到该属性之间的字节数。

struct s {
  char a;
  int b[2];
  float c;
};

printf("%zu\n", offsetof(struct s, a)); // 0
printf("%zu\n", offsetof(struct s, b)); // 4
printf("%zu\n", offsetof(struct s, c)); // 12

对于上面这个 Struct 结构，offsetof(struct s, a)一定等于0，因为a属性是第一个属性，与 Struct 结构自身的地址相同。

系统为了字节对齐，在a属性后面分配了3个空字节，导致b属性存储在第4个字节，所以offsetof(struct s, b)和offsetof(struct s, c)分别是4和12。

stdint.h

固定宽度的整数类型

stdint.h 定义了一些固定宽度的整数类型别名，主要有下面三类。

宽度完全确定的整数intN_t，比如int32_t。
宽度不小少于某个大小的整数int_leastN_t，比如int_least8_t。
宽度不小于某个大小、并且处理速度尽可能快的整数int_fastN_t，比如int_fast64_t。

上面所有类型都是有符号的，类型名前面可以加一个前缀u，表示无符号类型，比如uint16_t。

C 语言标准要求至少定义以下类型。

int8_t uint8_t
int16_t uint16_t
int32_t uint32_t
int64_t uint64_t
int_least8_t uint_least8_t
int_least16_t uint_least16_t
int_least32_t uint_least32_t
int_least64_t uint_least64_t
int_fast8_t uint_fast8_t
int_fast16_t uint_fast16_t
int_fast32_t uint_fast32_t
int_fast64_t uint_fast64_t

最大宽度的整数类型

以下两个类型表示当前系统可用的最大宽度整数。

intmax_t
uintmax_t

如果想要尽可能大的整数时，可以使用上面类型。

固定宽度的整数常量

以下一些带参数的宏，可以生成固定宽度的整数常量。

INT8_C(x) UINT8_C(x)
INT16_C(x) UINT16_C(x)
INT32_C(x) UINT32_C(x)
INT64_C(x) UINT64_C(x)
INTMAX_C(x) UINTMAX_C(x)

下面是用法示例。

1 2	uint16_t x = UINT16_C(12); intmax_t y = INTMAX_C(3490);

固定宽度的整数极限值

下面一些宏代表了固定宽度的整数最大值和最小值。

INT8_MAX INT8_MIN UINT8_MAX
INT16_MAX INT16_MIN UINT16_MAX
INT32_MAX INT32_MIN UINT32_MAX
INT64_MAX INT64_MIN UINT64_MAX
INT_LEAST8_MAX INT_LEAST8_MIN UINT_LEAST8_MAX
INT_LEAST16_MAX INT_LEAST16_MIN UINT_LEAST16_MAX
INT_LEAST32_MAX INT_LEAST32_MIN UINT_LEAST32_MAX
INT_LEAST64_MAX INT_LEAST64_MIN UINT_LEAST64_MAX
INT_FAST8_MAX INT_FAST8_MIN UINT_FAST8_MAX
INT_FAST16_MAX INT_FAST16_MIN UINT_FAST16_MAX
INT_FAST32_MAX INT_FAST32_MIN UINT_FAST32_MAX
INT_FAST64_MAX INT_FAST64_MIN UINT_FAST64_MAX
INTMAX_MAX INTMAX_MIN UINTMAX_MAX

注意，所有无符号整数类型的最小值都为0，所以没有对应的宏。

占位符

C 语言还在头文件 inttypes.h 里面，为上面类型定义了printf()和scanf()的占位符，参见《inttypes.h》一章。

stdio.h

stdio.h是 C 语言的标准 I/O 库，用于读取和写入文件，也用于控制台的输入和输出。

标准 I/O 函数

以下函数用于控制台的输入和输出。

printf()：输出到控制台，详见《基本语法》一章。
scanf()：从控制台读取输入，详见《I/O 函数》一章。
getchar()：从控制台读取一个字符，详见《I/O 函数》一章。
putchar()：向控制台写入一个字符，详见《I/O 函数》一章。
gets()：从控制台读取整行输入（已废除），详见《I/O 函数》一章。
puts()：向控制台写入一个字符串，详见《I/O 函数》一章。

文件操作函数

以下函数用于文件操作，详见《文件操作》一章。

fopen()：打开文件。
fclose()：关闭文件。
freopen()：打开一个新文件，关联一个已经打开的文件指针。
fprintf()：输出到文件。
fscanf()：从文件读取数据。
getc()：从文件读取一个字符。
fgetc()：从文件读取一个字符。
putc()：向文件写入一个字符。
fputc()：向文件写入一个字符。
fgets()：从文件读取整行。
fputs()：向文件写入字符串。
fread()：从文件读取二进制数据。
fwrite()：向文件写入二进制数据。
fseek()：将文件内部指针移到指定位置。
ftell()：获取文件内部指针的当前位置。
rewind()：将文件内部指针重置到文件开始处。
fgetpos()：获取文件内部指针的当前位置。
fsetpos()：设置文件内部指针的当前位置。
feof()：判断文件内部指针是否指向文件结尾。
ferror()：返回文件错误指示器的状态。
clearerr()：重置文件错误指示器。
remove()：删除文件。
rename()：文件改名，以及移动文件。

字符串操作函数

以下函数用于操作字符串，详见《字符串操作》一章。

sscanf()：从字符串读取数据，详见《I/O 函数》一章。
sprintf()：输出到字符串。
snprintf()：输出到字符串的更安全版本，指定了输出字符串的数量。

tmpfile()

tmpfile()函数创建一个临时文件，该文件只在程序运行期间存在，除非手动关闭它。它的原型如下。

1	FILE* tmpfile(void);

tmpfile()返回一个文件指针，可以用于访问该函数创建的临时文件。如果创建失败，返回一个空指针 NULL。

1 2	FILE* tempptr; tempptr = tmpfile();

调用close()方法关闭临时文件后，该文件将被自动删除。

tmpfile()有两个缺点。一是无法知道临时文件的文件名，二是无法让该文件成为永久文件。

tmpnam()

tmpname()函数为临时文件生成一个名字，确保不会与其他文件重名。它的原型如下。

1	char* tmpname(char* s);

它的参数是一个字符串变量，tmpnam()会把临时文件的文件名复制到这个变量里面，并返回指向该字符串变量的指针。如果生成文件名失败，tmpnam()返回空指针 NULL。

char filename[L_tmpname];

if (tmpnam(filename) != NULL)
  // 输出诸如 /tmp/filew9PMuZ 的文件名
  printf("%s\n", filename);
else
  printf("Something wrong!\n");

上面示例中，L_tmpname是stdio.h定义的一个宏，指定了临时文件的文件名长度。

tmpname()的参数也可以是一个空指针 NULL，同样返回指向文件名字符串的指针。

1 2	char* filename; filename = tmpnam(NULL);

上面示例中，变量filename就是tmpnam()生成的文件名。

该函数只是生成一个文件名，稍后可以使用fopen()打开该文件并使用它。

fflush()

fflush()用于清空缓存区。它接受一个文件指针作为参数，将缓存区内容写入该文件。

1	fflush(fp);

如果不需要保存缓存区内容，则可以传入空指针 NULL。

1	fflush(NULL);

如果清空成功，fflush()返回0，否则返回 EOF。

注意，fflush()一般只用来清空输出缓存区（比如写文件）。如果使用它来清空输入缓存区（比如读文件），属于未定义行为。

fflush()的一个用途是不等回车键，就强迫输出缓存区。大多数系统都是行缓存，这意味着只有遇到回车键（或者缓存区满了，或者文件读到结尾），缓存区的内容才会输出，fflush()可以不等回车键，立即输出。

for (int i = 9; i >= 0; i--) {
  printf("\r%d", i);
  fflush(stdout);
  sleep(1);
}

上面示例是一个倒计时效果，\r是回车键，表示每轮循环都会回到当前行的行首，等于删除上一轮循环的输出。fflush(stdout)表示立即将缓存输出到显示器，这一行是必需的，否则由于上一行的输出没有回车键，不会触发缓存输出，屏幕上不会显示任何内容，只会等到程序运行结束再一次性输出。

setvbuf()

setvbuf()函数用于定义某个字节流应该如何缓存。它可以接受四个参数。

1	int setvbuf(FILE* stream, char* buffer, int mode, size_t size)

第一个参数stream是文件流。

第二个参数buffer是缓存区的地址。

第三个参数mode指定缓存的行为模式，它是下面三个宏之一，这些宏都定义在stdio.h。

_IOFBF：满缓存。当缓存为空时，才从流读入数据；当缓存满了，才向流写入数据。一般情况下，这是默认设置。
_IOLBF：行缓存。每次从流读入一行数据，或向流写入一行数据，即以行为单位读写缓存。
_IONBF：无缓存。不使用缓存区，直接读写设备。

第四个参数size指定缓存区的大小。较大的缓存区提供更好的性能，而较小的缓存区可以节省空间。stdio.h提供了一个宏BUFSIZ，表示系统默认的缓存区大小。

它的意义在于，使得用户可以在打开一个文件之前，定义自己的文件缓冲区，而不必使用fopen()函数打开文件时设定的默认缓冲区。

1
2
3

char buffer[N];

setvbuf(stream, buffer, _IOFBF, N);

上面示例设置文件流stream的缓存区从地址buffer开始，大小为N，模式为_IOFBF。

setvbuf()的第二个参数可以为空指针 NULL。这样的话，setvbuf()会自己创建一个缓存区。

注意，setvbuf()的调用必须在对文件流执行任何操作之前。

如果调用成功，setvbuf()的返回值为0，否则返回非零值。

下面的例子是将缓存区调整为行缓存。

FILE *fp;
char lineBuf[1024];

fp = fopen("somefile.txt", "r");
setvbuf(fp, lineBuf, _IOLBF, 1024);

setbuf()

setbuf()是setvbuf()的早期版本，可以视为后者的简化版本，也用来定义某个字节流的缓存区。

1	void setbuf(FILE* stream, char* buffer);

它的第一个参数stream是文件流，第二个参数buffer是缓存区的地址。

它总是可以改写成setvbuf()。

char buffer[BUFSIZ];

setbuf(stream, buffer);

// 等同于
setvbuf(stream, buffer, _IOFBF, BUFSIZ);

上面示例中，BUFSIZ是stdio.h定义的宏，表示系统默认的缓存区大小。

setbuf()函数没有返回值。

setbuf()的第二个参数如果设置为 NULL，表示不进行缓存。

setbuf(stdout, NULL);

// 等同于
setvbuf(stdout, NULL, _IONBF, 0);

ungetc()

ungetc()将从缓存里面读取的上一个字符，重新放回缓存，下一个读取缓存的操作会从这个字符串开始。有些操作需要了解下一个字符是什么，再决定应该怎么处理，这时这个函数就很有用。

它的原型如下。

1	int ungetc(int c, FILE *stream);

它的第一个参数是一个字符变量，第二个参数是一个打开的文件流。它的返回值是放回缓存的那个字符，操作失败时，返回 EOF。

int ch = fgetc(fp);

if (isdigit(ch)) {
  ch = fgetd(fp);
}

ungetc(ch, fp);

上面示例中，如果读取的字符不是数字，就将其放回缓存。

perror()

perror()用于在 stderr 的错误信息之前，添加一个自定义字符串。

1	void perror(const char *s);

该函数的参数就是在报错信息前添加的字符串。它没有返回值。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <errno.h>

int main(void) {
  int x = -1;

  errno = 0;
  float y = sqrt(x);
  if (errno != 0) {
    perror("sqrt error");
    exit(EXIT_FAILURE);
  }
}

上面示例中，求-1的平方根，导致报错。头文件errno.h提供宏errno，只要上一步操作出错，这个宏就会设置成非零值。perror()用来在报错信息前，加上sqrt error的自定义字符串。

执行上面的程序，就会得到下面的报错信息。

1
2
3

$ gcc test.c -lm
$ ./a.out
sqrt error: Numerical argument out of domain

可变参数操作函数

（1）输出函数

下面是printf()的变体函数，用于按照给定格式，输出函数的可变参数列表（va_list）。

vprintf()：按照给定格式，输出到控制台，默认是显示器。
vfprintf()：按照给定格式，输出到文件。
vsprintf()：按照给定格式，输出到字符串。
vsnprintf()：按照给定格式，输出到字符串的安全版本。

它们的原型如下，基本与对应的printf()系列函数一致，除了最后一个参数是可变参数对象。

#include <stdio.h>
#include <stdarg.h>
    
int vprintf(
  const char * restrict format,
  va_list arg
);

int vfprintf(
  FILE * restrict stream,
  const char * restrict format,
  va_list arg
);
    
int vsprintf(
  char * restrict s,
  const char * restrict format,
  va_list arg
);
    
int vsnprintf(
  char * restrict s,
  size_t n,
  const char * restrict format,
  va_list arg
);

它们的返回值都为输出的字符数，如果出错，返回负值。

vsprintf()和vsnprintf()的第一个参数可以为 NULL，用来查看多少个字符会被写入。

下面是一个例子。

int logger(char *format, ...) {
  va_list va;
  va_start(va, format);
  int result = vprintf(format, va);
  va_end(va);

  printf("\n");

  return result;
}

// 输出 x = 12 and y = 3.20
logger("x = %d and y = %.2f", x, y);

（2）输入函数

下面是scanf()的变体函数，用于按照给定格式，输入可变参数列表 (va_list)。

vscanf()：按照给定格式，从控制台读取（默认为键盘）。
vfscanf()：按照给定格式，从文件读取。
vsscanf()：按照给定格式，从字符串读取。

它们的原型如下，跟对应的scanf()函数基本一致，除了最后一个参数是可变参数对象。

#include <stdio.h>
#include <stdarg.h>
    
int vscanf(
  const char * restrict format,
  va_list arg
);
    
int vfscanf(
  FILE * restrict stream,
  const char * restrict format,
  va_list arg
);
    
int vsscanf(
  const char * restrict s,
  const char * restrict format,
  va_list arg
);

它们返回成功读取的项数，遇到文件结尾或错误，则返回 EOF。

下面是一个例子。

int error_check_scanf(int expected_count, char *format, ...) {
  va_list va;

  va_start(va, format);
  int count = vscanf(format, va);
  va_end(va);

  assert(count == expected_count);

  return count;
}

error_check_scanf(3, "%d, %d/%f", &a, &b, &c);

stdlib.h

类型别名和宏

stdlib.h 定义了下面的类型别名。

size_t：sizeof 的返回类型。
wchar_t：宽字符类型。

stdlib.h 定义了下面的宏。

NULL：空指针。
EXIT_SUCCESS：函数运行成功时的退出状态。
EXIT_FAILURE：函数运行错误时的退出状态。
RAND_MAX：rand() 函数可以返回的最大值。
MB_CUR_MAX：当前语言环境中，多字节字符占用的最大字节数。

abs()，labs()，llabs()

这三个函数用于计算整数的绝对值。abs()用于 int 类型，labs()用于 long int 类型，llabs()用于 long long int 类型。

1
2
3

int abs(int j);
long int labs(long int j);
long long int llabs(long long int j);

下面是用法示例。

// 输出 |-2| = 2
printf("|-2| = %d\n", abs(-2));

// 输出 |4|  = 4
printf("|4|  = %d\n", abs(4));

div()，ldiv()，lldiv()

这三个函数用来计算两个参数的商和余数。div()用于 int 类型的相除，ldiv()用于 long int 类型的相除，lldiv()用于 long long int 类型的相除。

1
2
3

div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
lldiv_t lldiv(long long int numer, long long int denom);

这些函数把第2个参数（分母）除以第1个参数（分子），产生商和余数。这两个值通过一个数据结构返回，div()返回 div_t 结构，ldiv()返回 ldiv_t 结构，lldiv()返回 lldiv_t 结构。

这些结构都包含下面两个字段，

1 2	int　quot;　 //　商 int　rem;　 //　余数

它们完整的定义如下。

typedef struct {
  int quot, rem;
} div_t;
    
typedef struct {
  long int quot, rem;
} ldiv_t;
    
typedef struct {
  long long int quot, rem;
} lldiv_t;

下面是一个例子。

div_t d = div(64, -7);

// 输出 64 / -7 = -9
printf("64 / -7 = %d\n", d.quot);

// 输出 64 % -7 = 1
printf("64 %% -7 = %d\n", d.rem);

字符串转成数值

a 系列函数

stdlib.h定义了一系列函数，可以将字符串转为数组。

atoi()：字符串转成 int 类型。
atof()：字符串转成 double 类型。
atol()：字符串转成 long int 类型。
atoll()：字符串转成 long long int 类型。

它们的原型如下。

int atoi(const char* nptr);
double atof(const char* nptr);
long int atol(const char* nptr);
long long int atoll(const char* nptr);

上面函数的参数都是一个字符串指针，字符串开头的空格会被忽略，转换到第一个无效字符处停止。函数名称里面的a代表 ASCII，所以atoi()的意思是“ASCII to int”。

它们返回转换后的数值，如果字符串无法转换，则返回0。

下面是用法示例。

1 2	atoi("3490") // 3490 atof("3.141593") // 3.141593

如果参数是数字开头的字符串，atoi()会只转换数字部分，比如atoi("42regular")会返回整数42。如果首字符不是数字，比如“hello world”，则会返回0。

str 系列函数（浮点数转换）

stdlib.h还定义了一些更强功能的浮点数转换函数。

strtof()：字符串转成 float 类型。
strtod()：字符串转成 double 类型。
strtold()：字符串转成 long double 类型。

它们的原型如下。

float strtof(
  const char* restrict nptr,
  char** restrict endptr
);

double strtod(
  const char* restrict nptr,
  char** restrict endptr
);
    
long double strtold(
  const char* restrict nptr,
  char** restrict endptr
);

它们都接受两个参数，第一个参数是需要转换的字符串，第二个参数是一个指针，指向原始字符串里面无法转换的部分。

nptr：待转换的字符串（起首的空白字符会被忽略）。
endprt：一个指针，指向不能转换部分的第一个字符。如果字符串可以完全转成数值，该指针指向字符串末尾的终止符\0。这个参数如果设为 NULL，就表示不需要处理字符串剩余部分。

它们的返回值是已经转换后的数值。如果字符串无法转换，则返回0。如果转换结果发生溢出，errno 会被设置为 ERANGE。如果值太大（无论是正数还是负数），函数返回HUGE_VAL；如果值太小，函数返回零。

char *inp = "   123.4567abdc";
char *badchar;

double val = strtod(inp, &badchar);

printf("%f\n", val); // 123.456700
printf("%s\n", badchar); // abdc

字符串可以完全转换的情况下，第二个参数指向\0，因此可以用下面的写法判断是否完全转换。

if (*endptr == '\0') {
  // 完全转换
} else {
  // 存在无法转换的字符
}

如果不关心没有转换的部分，则可以将 endptr 设置为 NULL。

这些函数还可以将字符串转换为特殊值 Infinity 和 NaN。如果字符串包含 INF 或 INFINITY（大写或小写皆可），则将转换为 Infinity；如果字符串包含 NAN，则将返回 NaN。

str 系列函数（整数转换）

str 系列函数也有整数转换的对应函数。

strtol()：字符串转成 long int 类型。
strtoll()：字符串转成 long long int 类型。
strtoul()：字符串转成 unsigned long int 类型。
strtoull()：字符串转成 unsigned long long int 类型。

它们的原型如下。

long int strtol(
  const char* restrict nptr,
  char** restrict endptr,
  int base
);
    
long long int strtoll(
  const char* restrict nptr,
  char** restrict endptr,
  int base
);
    
unsigned long int strtoul(
  const char* restrict nptr,
  char** restrict endptr,
  int base
);
    
unsigned long long int strtoull(
  const char* restrict nptr,
  char** restrict endptr, int base
);

它们接受三个参数。

（1）nPtr：待转换的字符串（起首的空白字符会被忽略）。

（2）endPrt：一个指针，指向不能转换部分的第一个字符。如果字符串可以完全转成数值，该指针指向字符串末尾的终止符\0。这个参数如果设为 NULL，就表示不需要处理字符串剩余部分。

（3）base：待转换整数的进制。这个值应该是2到36之间的整数，代表相应的进制，如果是特殊值0，表示让函数根据数值的前缀，自己确定进制，即如果数字有前缀0，则为八进制，如果数字有前缀0x或0X，则为十六进制。

它们的返回值是转换后的数值，如果转换不成功，返回0。

下面是转换十进制整数的例子。

char* s = "3490";
unsigned long int x = strtoul(u, NULL, 10);

printf("%lu\n", x); // 3490

下面是转换十六进制整数的例子。

char* end;

long value = strtol("0xff", &end, 16);
printf("%ld\n", value); // 255
printf("%s\n", end); // 无内容

value = strtol("0xffxx", &end, 16);
printf("%ld\n", value); // 255
printf("%s\n", end); // xx

上面示例中，strtol()可以指定字符串包含的是16进制整数。不能转换的部分，可以使用指针end进行访问。

下面是转换二进制整数的例子。

char* s = "101010";
unsigned long int x = strtoul(s, NULL, 2);

printf("%lu\n", x); // 42

下面是让函数自行判断整数进制的例子。

#include <stdio.h>
#include <stdlib.h>

int main(void) {
  const char* string = "-1234567abc";
  char* remainderPtr;
  long x = strtol(string, &remainderPtr, 0);
  printf("%s\"%s\"\n%s%ld\n%s\"%s\"\n",
    "The original string is ",
    string,
    "The converted value is ",
    x,
    "The remainder of the original string is ",
    remainderPtr
  );
}

上面代码的输出结果如下。

1
2
3

The original string is "-1234567abc"
The converted value is -1234567
The remainder of the original string is "abc"

如果被转换的值太大，strtol()函数在errno中存储ERANGE这个值，并返回LONG_MIN（原值为负数）或LONG_MAX（原值为正数），strtoul()则返回ULONG_MAX。

rand()

rand()函数用来生成 0～RAND_MAX 之间的随机整数。RAND_MAX是一个定义在stdlib.h里面的宏，通常等于 INT_MAX。

// 原型
int rand(void);

// 示例
int x = rand();

如果希望获得整数 N 到 M 之间的随机数（包括 N 和 M 两个端点值），可以使用下面的写法。

1	int x = rand() % （M - N + 1) + N;

比如，1 到 6 之间的随机数，写法如下。

1	int x = rand() % 6 + 1;

获得浮点数的随机值，可以使用下面的写法。

// 0 到 0.999999 之间的随机数
printf("0 to 0.99999: %f\n", rand() / ((float)RAND_MAX + 1));

// n 到 m 之间的随机数：
// n + m * (rand() / (float)RAND_MAX)
printf("10.5 to 15.7: %f\n", 10.5 + 5.2 * rand() / (float)RAND_MAX);

上面示例中，由于rand()和RAND_MAX都是 int 类型，要用显示的类型转换转为浮点数。

srand()

rand()是伪随机数函数，为了增加随机性，必须在调用它之前，使用srand()函数重置一下种子值。

srand()函数接受一个无符号整数（unsigned int）作为种子值，没有返回值。

1	void srand(unsigned int seed);

通常使用time(NULL)函数返回当前距离时间纪元的秒数，作为srand()的参数。

1 2	#include <time.h> srand((unsigned int) time(NULL));

上面代码中，time()的原型定义在头文件time.h里面，返回值的类型是类型别名time_t，具体的类型与系统有关，所以要强制转换一下类型。time()的参数是一个指针，指向一个具体的 time_t 类型的时间值，这里传入空指针NULL作为参数，由于 NULL 一般是0，所以也可以写成time(0)。

abort()

abort()用于不正常地终止一个正在执行的程序。使用这个函数的目的，主要是它会触发 SIGABRT 信号，开发者可以在程序中为这个信号设置一个处理函数。

1	void abort(void);

该函数没有参数。

exit()，quick_exit()，_Exit()

这三个函数都用来退出当前正在执行的程序。

1
2
3

void exit(int status);
void quick_exit(int status);
void _Exit(int status);

它们都接受一个整数，表示程序的退出状态，0是正常退出，非零值表示发生错误，可以使用宏EXIT_SUCCESS和EXIT_FAILURE当作参数。它们本身没有返回值。

它们的区别是，退出时所做的清理工作不同。exit()是正常退出，系统会做完整的清理，比如更新所有文件流，并且删除临时文件。quick_exit()是快速退出，系统的清理工作稍微少一点。_Exit()是立即退出，不做任何清理工作。

下面是一些用法示例。

1
2
3

exit(EXIT_SUCCESS);
quick_exit(EXIT_FAILURE);
_Exit(2);

atexit()，at_quick_exit()

atexit()用来登记当前程序退出时（调用exit()或main()正常退出），所要执行的其他函数。

at_quick_exit()则是登记使用quick_exit()方法退出当前程序时，所要执行的其他函数。

exit()只能触发atexit()登记的函数，quick_exit()只能触发at_quick_exit()登记的函数。

1 2	int atexit(void (func)(void)); int at_quick_exit(void (func)(void));

它们的参数是要执行的函数地址，即函数名。它们的返回值都是调用成功时返回0，调用失败时返回非零值。

下面是一个例子。

void sign_off(void);
void too_bad(void);

int main(void) {

  int n;
  atexit(sign_off);　　 /* 注册 sign_off()函数 */

  puts("Enter an integer:");
  if (scanf("%d", &n) != 1) {
    puts("That's no integer!");
    atexit(too_bad);　/* 注册 too_bad()函数 */
    exit(EXIT_FAILURE);
  }

  printf("%d is %s.\n", n, (n % 2 == 0) ? "even" : "odd");
  return 0;
}

void sign_off(void) {
  puts("sign_off");
}

void too_bad(void) {
  puts("too bad");
}

上面示例中，用户输入失败时，会调用sign_off()和too_bad()函数；但是输入成功时只会调用sign_off()。因为只有输入失败时，才会进入if语句登记too_bad()。

另外，如果有多条atexit()语句，函数退出时最先调用的，是最后一个登记的函数。

atexit()登记的函数（如上例的sign_off和too_bad）应该不带任何参数且返回类型为void。通常，这些函数会执行一些清理任务，例如删除临时文件或重置环境变量。

at_quick_exit()也是同样的规则，下面是一个例子。

void exit_handler_1(void) {
  printf("1\n");
}

void exit_handler_2(void) {
  printf("2\n");
}

int main(void) {
  at_quick_exit(exit_handler_1);
  at_quick_exit(exit_handler_2);
  quick_exit(0);
}

执行上面的示例，命令行会先输出2，再输出1。

getenv()

getenv()用于获取环境变量的值。环境变量是操作系统提供的程序之外的一些环境参数。

1	char* getenv(const char* name);

它的参数是一个字符串，表示环境变量名。返回值也是一个字符串，表示环境变量的值。如果指定的环境变量不存在，则返回 NULL。

下面是输出环境变量$PATH的值的例子。

1	printf("PATH is %s\n", getenv("PATH"));

system()

system()函数用于执行外部程序。它会把它的参数字符串传递给操作系统，让操作系统的命令处理器来执行。

1	void system( char const * command );

这个函数的返回值因编译器而异。但是标准规定，如果 NULL 作为参数，表示询问操作系统，是否有可用的命令处理器，如果有的话，返回一个非零值，否则返回零。

下面是执行ls命令的例子。

1	system("ls -l");

内存管理函数

stdlib.h 提供了一些内存操作函数，下面几个函数详见《内存管理》一章，其余在本节介绍。

malloc()：分配内存区域
calloc()：分配内存区域。
realloc()：调节内存区域大小。
free()：释放内存区域。

aligned_alloc()

很多系统有内存对齐的要求，即内存块的大小必须是某个值（比如64字节）的倍数，这样有利于提高处理速度。aligned_alloc()就用于分配满足内存对齐要求的内存块，它的原型如下。

1	void* aligned_alloc(size_t alignment, size_t size);

它接受两个参数。

alignment：整数，表示内存对齐的单位大小，一般是2的整数次幂（2、4、8、16……）。
size：整数，表示内存块的大小。

分配成功时，它返回一个无类型指针，指向新分配的内存块。分配失败时，返回 NULL。

1	char* p = aligned_alloc(64, 256);

上面示例中，aligned_alloc()分配的内存块，单位大小是64字节，要分配的字节数是256字节。

qsort()

qsort()用来快速排序一个数组。它对数组成员的类型没有要求，任何类型数组都可以用这个函数排序。

void qsort(
  void *base,
  size_t nmemb, 
  size_t size,
  int (*compar)(const void *, const void *)
);

该函数接受四个参数。

base：指向要排序的数组开始位置的指针。
nmemb：数组成员的数量。
size：数组每个成员占用的字节长度。
compar：一个函数指针，指向一个比较两个成员的函数。

比较函数compar将指向数组两个成员的指针作为参数，并比较两个成员。如果第一个参数小于第二个参数，该函数应该返回一个负值；如果两个函数相等，返回0；如果第一个参数大于第二个参数，应该返回一个正数。

下面是一个用法示例。

#include <stdio.h>
#include <stdlib.h>

int compar(const void* elem0, const void* elem1) {
  const int* x = elem0;
  const int* y = elem1; 
  
  return *x - *y;
}

int main(void) {
  int a[9] = {14, 2, 3, 17, 10, 8, 6, 1, 13};

  qsort(a, 9, sizeof(int), compar);

  for (int i = 0; i < 9; i++)
    printf("%d ", a[i]);
  putchar('\n');
}

执行上面示例，会输出排序好的数组“1 2 3 6 8 10 13 14 17”。

bsearch()

bsearch()使用二分法搜索，在数组中搜索一个值。它对数组成员的类型没有要求，任何类型数组都可以用这个函数搜索值。

注意，该方法只对已经排序好的数组有效。

void *bsearch(
  const void* key,
  const void* base,
  size_t nmemb,
  size_t size,
  int (*compar)(const void *, const void *)
);

这个函数接受5个参数。

key：指向要查找的值的指针。
base：指向数组开始位置的指针，数组必须已经排序。
nmemb：数组成员的数量。
size：数组每个成员占用的字节长度。
compar：指向一个将待查找值与其他值进行比较的函数的指针。

比较函数compar将待查找的值作为第一个参数，将要比较的值作为第二个参数。如果第一个参数小于第二个参数，该函数应该返回一个负值；如果两个参数相等，返回0；如果第一个参数大于第二个参数，返回一个正值。

如果找到待查找的值，bsearch()返回指向该值的指针，如果找不到，返回 NULL。

下面是一个用法示例。

#include <stdio.h>
#include <stdlib.h>

int compar(const void *key, const void *value) {
  const int* k = key;
  const int* v = value;

  return *k - *v;
}

int main(void) {
  int a[9] = {2, 6, 9, 12, 13, 18, 20, 32, 47};

  int* r;
  int key;

  key = 12; // 包括在数组中
  r = bsearch(&key, a, 9, sizeof(int), compar);
  printf("Found %d\n", *r);

  key = 30;  // 不包括在数组中
  r = bsearch(&key, a, 9, sizeof(int), compar);
  if (r == NULL)
    printf("Didn't find 30\n");

  return 0;
}

执行上面的示例，会输出下面的结果。

1 2	Found 12 Didn't find 30

多字节字符函数

stdlib.h 提供了下面的函数，用来操作多字节字符，详见《多字节字符》一章。

mblen()：多字节字符的字节长度。
mbtowc()：将多字节字符转换为宽字符。
wctomb()：将宽字符转换为多字节字符。
mbstowcs()：将多字节字符串转换为宽字符串。
wcstombs()：将宽字符串转换为多字节字符串。

string.h

string.h主要定义了字符串处理函数和内存操作函数。

字符串处理函数

以下字符串处理函数，详见《字符串》一章。

strcpy()：复制字符串。
strncpy()：复制字符串，有长度限制。
strcat()：连接两个字符串。
strncat()：连接两个字符串，有长度限制。
strcmp()：比较两个字符串。
strncmp()：比较两个字符串，有长度限制。
strlen()：返回字符串的字节数。

strchr()，strrchr()

strchr()和strrchr()都用于在字符串中查找指定字符。不同之处是，strchr()从字符串开头开始查找，strrchr()从字符串结尾开始查找，函数名里面多出来的那个r表示 reverse（反向）。

1 2	char* strchr(char* str, int c); char* strrchr(char *str, int c);

它们都接受两个参数，第一个参数是字符串指针，第二个参数是所要查找的字符。

一旦找到该字符，它们就会停止查找，并返回指向该字符的指针。如果没有找到，则返回 NULL。

下面是一个例子。

char *str = "Hello, world!";
char *p;

p = strchr(str, ',');  // p 指向逗号的位置
p = strrchr(str, 'o'); // p 指向 world 里面 o 的位置

strspn()，strcspn()

strspn()用来查找属于指定字符集的字符串长度，strcspn()正好相反，用来查找不属于指定字符集的字符串长度。

1 2	size_t strspn(char* str, const char* accept); size_t strcspn(char str, const char reject);

这两个函数接受两个参数，第一个参数是源字符串，第二个参数是由指定字符组成的字符串。

strspn()从第一个参数的开头开始查找，一旦发现第一个不属于指定字符集范围的字符，就停止查找，返回到目前为止的字符串长度。如果始终没有不在指定字符集的字符，则返回第一个参数字符串的长度。

strcspn()则是一旦发现第一个属于指定字符集范围的字符，就停止查找，返回到目前为止的字符串长度。如果始终没有发现指定字符集的字符，则返回第一个参数字符串的长度。

char str[] = "hello world";
int n;

n = strspn(str1, "aeiou");
printf("%d\n", n);  // n == 0

n = strcspn(str1, "aeiou");
printf("%d\n", n); // n == 1

上面示例中，第一个n等于0，因为0号位置的字符h就不属于指定字符集aeiou，可以理解为开头有0个字符属于指定字符集。第二个n等于1，因为1号位置的字符e属于指定字符集aeiou，可以理解为开头有1个字符不属于指定字符集。

strpbrk()

strpbrk()在字符串中搜索指定字符集的任一个字符。

1	char* strpbrk(const char* s1, const char* s2);

它接受两个参数，第一个参数是源字符串，第二个参数是由指定字符组成的字符串。

它返回一个指向第一个匹配字符的指针，如果未找到匹配字符，则返回 NULL。

char* s1 = "Hello, world!";
char* s2 = "dow!";

char* p = strpbrk(s1, s2);

printf("%s\n", p);  // "o, world!"

上面示例中，指定字符集是“dow!”，那么s1里面第一个匹配字符是“Hello”的“o”，所以指针p指向这个字符。输出的话，就会输出从这个字符直到字符串末尾的“o, world!”。

strstr()

strstr()在一个字符串里面，查找另一个字符串。

char *strstr(
  const char* str,
  const char* substr
);

它接受两个参数，第一个参数是源字符串，第二个参数是所要查找的子字符串。

如果匹配成功，就返回一个指针，指向源字符串里面的子字符串。如果匹配失败，就返回 NULL，表示无法找到子字符串。

char* str = "The quick brown fox jumped over the lazy dogs.";
char* p = strstr(str, "lazy");

printf("%s\n", p == NULL ? "null": p); // "lazy dogs."

上面示例中，strstr()用来在源字符串str里面，查找子字符串lazy。从返回的指针到字符串结尾，就是“lazy dogs.”。

strtok()

strtok()用来将一个字符串按照指定的分隔符（delimiter），分解成一系列词元（tokens）。

1	char* strtok(char* str, const char* delim);

它接受两个参数，第一个参数是待拆分的字符串，第二个参数是指定的分隔符。

它返回一个指针，指向分解出来的第一个词元，并将词元结束之处的分隔符替换成字符串结尾标志\0。如果没有待分解的词元，它返回 NULL。

如果要遍历所有词元，就必须循环调用，参考下面的例子。

strtok()的第一个参数如果是 NULL，则表示从上一次strtok()分解结束的位置，继续往下分解。

#include <stdio.h>
#include <string.h>

int main(void) {
  char string[] = "This is a sentence with 7 tokens";
  char* tokenPtr = strtok(string, " ");

  while (tokenPtr != NULL) {
    printf("%s\n", tokenPtr);
    tokenPtr = strtok(NULL, " ");
  }
}

上面示例将源字符串按照空格，分解词元。它的输出结果如下。

This
is
a
sentence
with
7
tokens

注意，strtok()会修改原始字符串，将所有分隔符都替换成字符串结尾符号\0。因此，最好生成一个原始字符串的拷贝，然后再对这个拷贝执行strtok()。

strcoll()

strcoll()用于比较两个启用了本地化设置的字符串，用法基本与strcmp()相同。

1	int strcoll(const char s1, const char s2);

请看下面的示例。

setlocale(LC_ALL, "");

// 报告 é > f
printf("%d\n", strcmp("é", "f"));  

// 报告 é < f
printf("%d\n", strcoll("é", "f"));

上面示例比较带重音符号的é与f，strcmp()会返回é大于f，而strcoll()就会正确识别é排在f前面，所以小于f。注意，在比较之前，需要使用setlocale(LC_ALL, "")，启用本地化设置。

strxfrm()

strxfrm()将一个本地化字符串转成可以使用strcmp()进行比较的形式，相当于strcoll()内部的第一部分操作。

size_t strxfrm(
  char * restrict s1, 
  const char * restrict s2, 
  size_t n
);

它接受三个参数，将第二个参数s2转为可以使用strcmp()比较的形式，并将结果存入第一个参数s1。第三个参数n用来限定写入的字符数，防止超出s1的边界。

它返回转换后的字符串长度，不包括结尾的终止符。

如果第一个参数是 NULL，第三个参数是0，则不进行实际的转换，只返回转换后所需的字符串长度。

下面的示例是用这个函数自己实现一个strcoll()。

int my_strcoll(char* s1, char* s2) {
  int len1 = strxfrm(NULL, s1, 0) + 1;
  int len2 = strxfrm(NULL, s2, 0) + 1;

  char *d1 = malloc(len1);
  char *d2 = malloc(len2);

  strxfrm(d1, s1, len1);
  strxfrm(d2, s2, len2);

  int result = strcmp(d1, d2);

  free(d2);
  free(d1);

  return result;
}

上面示例中，先为两个进行比较的本地化字符串，分配转换后的存储空间，使用strxfrm()将它们转为可比较的形式，再用strcmp()进行比较。

strerror()

strerror()函数返回特定错误的说明字符串。

1	char *strerror(int errornum);

它的参数是错误的编号，由errno.h定义。返回值是一个指向说明字符串的指针。

1 2	// 输出 No such file or directory printf("%s\n", strerror(2));

上面示例输出2号错误的说明字符“No such file or directory“。

下面的例子是自定义报错信息。

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main(void) {
  FILE* fp = fopen("NONEXISTENT_FILE.TXT", "r");

  if (fp == NULL) {
    char* errmsg = strerror(errno);
    printf("Error %d opening file: %s\n", errno, errmsg);
  }
}

上面示例中，通过strerror(errno)拿到当前的默认报错信息，其中errno是errno.h定义的宏，表示当前的报错编号。然后，再输出一条自定义的报错信息。

内存操作函数

以下内存操作函数，详见《内存管理》一章。

memcpy()：内存复制函数。
memmove()：内存复制函数（允许重叠）。
memcmp()：比较两个内存区域。

memchr()

memchr()用于在内存区域中查找指定字符。

1	void* memchr(const void* s, int c, size_t n);

它接受三个参数，第一个参数是内存区域的指针，第二个参数是所要查找的字符，第三个参数是内存区域的字节长度。

一旦找到，它就会停止查找，并返回指向该位置的指针。如果直到检查完指定的字节数，依然没有发现指定字符，则返回 NULL。

下面是一个例子。

char *str = "Hello, world!";
char *p;

p = memchr(str, '!', 13); // p 指向感叹号的位置

memset()

memset()将一段内存全部格式化为指定值。

1	void* memset(void* s, int c, size_t n);

它的第一个参数是一个指针，指向内存区域的开始位置，第二个参数是待写入的字符值，第三个参数是一个整数，表示需要格式化的字节数。它返回第一个参数（指针）。

1	memset(p, ' ', N);

上面示例中，p 是一个指针，指向一个长度为 N 个字节的内存区域。memset()将该块内存区域的每个字节，都改写为空格字符。

下面是另一个例子。

char string1[15] = "BBBBBBBBBBBBBB";

// 输出 bbbbbbbBBBBBBB
printf("%s\n", (char*) memset(string1, 'b', 7));

memset()的一个重要用途，就是将数组成员全部初始化为0。

1	memset(arr, 0, sizeof(arr));

下面是将 Struct 结构都初始化为0的例子。

struct banana {
  float ripeness;
  char *peel_color;
  int grams;
};

struct banana b;

memset(&b, 0, sizeof b);

b.ripeness == 0.0;     // True
b.peel_color == NULL;  // True
b.grams == 0;          // True

上面示例，将 Struct banana 的实例 b 的所有属性都初始化为0。

其他函数

1
2
3

void* memset(void* a, int c, size_t n);

size_t strlen(const char* s);

time.h

time_t

time_t 是一个表示时间的类型别名，可以视为国际标准时 UTC。它可能是浮点数，也可能是整数，Unix 系统一般是整数。

许多系统上，time_t 表示自时间纪元（time epoch）以来的秒数。Unix 的时间纪元是国际标准时 UTC 的1970年1月1日的零分零秒。time_t 如果为负数，则表示时间纪元之前的时间。

time_t 一般是32位或64位整数类型的别名，具体类型取决于当前系统。如果是32位带符号整数，time_t 可以表示的时间到 2038年1月19日03:14:07 UTC 为止；如果是32位无符号整数，则表示到2106年。如果是64位带符号整数，可以表示-2930亿年到+2930亿年的时间范围。

struct tm

struct tm 是一个数据结构，用来保存时间的各个组成部分，比如小时、分钟、秒、日、月、年等。下面是它的结构。

struct tm {
  int tm_sec;    // 秒数 [0, 60]
  int tm_min;    // 分钟 [0, 59]
  int tm_hour;   // 小时 [0, 23]
  int tm_mday;   // 月份的天数 [1, 31]
  int tm_mon;    // 月份 [0, 11]，一月用 0 表示
  int tm_year;   // 距离 1900 的年数
  int tm_wday;   // 星期几 [0, 6]，星期天用 0 表示
  int tm_yday;   // 距离1月1日的天数 [0, 365]
  int tm_isdst;  // 是否采用夏令时，1 表示采用，0 表示未采用
};

time()

time()函数返回从时间纪元到现在经过的秒数。

1	time_t time(time_t* returned_value);

time()接受一个 time_t 指针作为参数，返回值会写入指针地址。参数可以是空指针 NULL。

time()的返回值是 time_t 类型的当前时间。如果计算机无法提供当前的秒数，或者返回值太大，无法用time_t类型表示，time()函数就返回-1。

time_t now;

// 写法一    
now = time(NULL);

// 写法二    
time(&now);

上面示例展示了将当前时间存入变量now的两种写法。

如果要知道某个操作耗费的精确时间，需要调用两次time()，再将两次的返回值相减。

time_t begin = time(NULL);

// ... 执行某些操作

time_t end = time(NULL);

printf("%d\n", end - begin);

注意，上面的方法只能精确到秒。

ctime()

ctime()用来将 time_t 类型的值直接输出为人类可读的格式。

1	char* ctime( time_t const * time_value );

ctime()的参数是一个 time_t 指针，返回一个字符串指针。该字符串的格式类似“Sun Jul 4 04:02:48 1976\n\0”，尾部包含换行符和字符串终止标志。

下面是一个例子。

time_t now; 

now = time(NULL);

// 输出 Sun Feb 28 18:47:25 2021
printf("%s", ctime(&now));

注意，ctime()会在字符串尾部自动添加换行符。

localtime()，gmtime()

localtime()函数用来将 time_t 类型的时间，转换为当前时区的 struct tm 结构。

gmtime()函数用来将 time_t 类型的时间，转换为 UTC 时间的 struct tm 结构。

它们的区别就是返回值，前者是本地时间，后者是 UTC 时间。

1 2	struct tm* localtime(const time_t* timer); struct tm* gmtime(const time_t* timer);

下面是一个例子。

time_t now = time(NULL);

// 输出 Local: Sun Feb 28 20:15:27 2021
printf("Local: %s", asctime(localtime(&now)));

// 输出 UTC  : Mon Mar  1 04:15:27 2021
printf("UTC  : %s", asctime(gmtime(&now)));

asctime()

asctime()函数用来将 struct tm 结构，直接输出为人类可读的格式。该函数会自动在输出的尾部添加换行符。

用法示例参考上一小节。

mktime()

mktime()函数用于把一个 struct tm 结构转换为 time_t 值。

1	time_t　mktime(struct tm* tm_ptr);

mktime()的参数是一个 struct tm 指针。

mktime()会自动设置 struct tm 结构里面的tm_wday属性和tm_yday属性，开发者自己不必填写这两个属性。所以，这个函数常用来获得指定时间是星期几（tm_wday）。

struct tm 结构的tm_isdst属性也可以设为-1，让mktime()决定是否应该采用夏令时。

下面是一个例子。

struct tm some_time = {
  .tm_year=82,   // 距离 1900 的年数
  .tm_mon=3,     // 月份 [0, 11]
  .tm_mday=12,   // 天数 [1, 31]
  .tm_hour=12,   // 小时 [0, 23]
  .tm_min=00,    // 分钟 [0, 59]
  .tm_sec=04,    // 秒数 [0, 60]
  .tm_isdst=-1,  // 夏令时
};
    
time_t some_time_epoch;
some_time_epoch = mktime(&some_time);
    
// 输出 Mon Apr 12 12:00:04 1982
printf("%s", ctime(&some_time_epoch));

// 输出 Is DST: 0
printf("Is DST: %d\n", some_time.tm_isdst);

difftime()

difftime()用来计算两个时间之间的差异。Unix 系统上，直接相减两个 time_t 值，就可以得到相差的秒数，但是为了程序的可移植性，最好还是使用这个函数。

1	double difftime( time_t time1, time_t time2 );

difftime()函数接受两个 time_t 类型的时间作为参数，计算 time1 - time2 的差，并把结果转换为秒。

注意它的返回值是 double 类型。

#include <stdio.h>
#include <time.h>
    
int main(void) {
  struct tm time_a = {
    .tm_year=82, 
    .tm_mon=3,   
    .tm_mday=12, 
    .tm_hour=4,  
    .tm_min=00,  
    .tm_sec=04,  
    .tm_isdst=-1,
  };
    
  struct tm time_b = {
    .tm_year=120,
    .tm_mon=10,  
    .tm_mday=15, 
    .tm_hour=16, 
    .tm_min=27,  
    .tm_sec=00,  
    .tm_isdst=-1,
  };
    
  time_t cal_a = mktime(&time_a);
  time_t cal_b = mktime(&time_b);
    
  double diff = difftime(cal_b, cal_a);
    
  double years = diff / 60 / 60 / 24 / 365.2425;
  
  // 输出 1217996816.000000 seconds (38.596783 years) between events
  printf("%f seconds (%f years) between events\n", diff, years);
}

上面示例中，折算年份时，为了尽量准确，使用了一年的准确长度 365.2425 天，这样可以抵消闰年的影响。

strftime()

strftime()函数用来将 struct tm 结构转换为一个指定格式的字符串，并复制到指定地址。

size_t strftime(
  char* str, 
  size_t maxsize, 
  const char* format, 
  const struct tm* timeptr
)

strftime()接受四个参数。

第一个参数：目标字符串的指针。
第二个参数：目标字符串可以接受的最大长度。
第三个参数：格式字符串。
第四个参数：struct tm 结构。

如果执行成功（转换并复制），strftime()函数返回复制的字符串长度；如果执行失败，返回-1。

下面是一个例子。

#include <stdio.h>
#include <time.h>

int main(void) {
  char s[128];
  time_t now = time(NULL);

  // %c: 本地时间
  strftime(s, sizeof s, "%c", localtime(&now));
  puts(s);   // Sun Feb 28 22:29:00 2021

  // %A: 完整的星期日期的名称
  // %B: 完整的月份名称
  // %d: 月份的天数
  strftime(s, sizeof s, "%A, %B %d", localtime(&now));
  puts(s);   // Sunday, February 28

  // %I: 小时（12小时制）
  // %M: 分钟
  // %S: 秒数
  // %p: AM 或 PM
  strftime(s, sizeof s, "It's %I:%M:%S %p", localtime(&now));
  puts(s);   // It's 10:29:00 PM

  // %F: ISO 8601 yyyy-mm-dd 格式
  // %T: ISO 8601 hh:mm:ss 格式
  // %z: ISO 8601 时区
  strftime(s, sizeof s, "ISO 8601: %FT%T%z", localtime(&now));
  puts(s);   // ISO 8601: 2021-02-28T22:29:00-0800
}

下面是常用的格式占位符。

%%：输出 % 字符。
%a：星期几的简写形式，以当地时间计算。
%A：星期几的完整形式，以当地时间计算。
%b：月份的简写形式，以当地时间计算。
%B：月份的完整形式，以当地时间计算。
%c：日期和时间，使用“%x %X”。
%d：月份的天数（01-31）。
%H：小时，采用24小时制（00-23）。
%I：小时，采用12小时制（00-12）。
%J：一年的第几天（001-366）。
%m：月数（01-12）。
%M：分钟（00～59）。
%P：AM 或 PM。
%R：相当于”%H:%M”。
%S：秒（00-61）。
%U：一年的第几星期（00-53），以星期日为第1天。
%w：一星期的第几天，星期日为第0天。
%W：一年的第几星期(00-53)，以星期一为第1天。
%x：完整的年月日的日期，以当地时间计算。
%X：完整的时分秒的时间，以当地时间计算。
%y：两位数年份（00-99）。
%Y：四位数年份（例如 1984）。
%Z：时区的简写。

timespec_get()

timespec_get()用来将当前时间转成距离时间纪元的纳秒数（十亿分之一秒）。

1	int timespec_get ( struct timespec* ts, int base ) ;

timespec_get()接受两个参数。

第一个参数是 struct timespec 结构指针，用来保存转换后的时间信息。struct timespec 的结构如下。

struct timespec {
  time_t tv_sec;   // 秒数
  long   tv_nsec;  // 纳秒
};

第二个参数是一个整数，表示时间计算的起点。标准只给出了宏 TIME_UTC 这一个可能的值，表示返回距离时间纪元的秒数。

下面是一个例子。

struct timespec ts;
    
timespec_get(&ts, TIME_UTC);
    
// 1614581530 s, 806325800 ns
printf("%ld s, %ld ns\n", ts.tv_sec, ts.tv_nsec);
    
double float_time = ts.tv_sec + ts.tv_nsec/1000000000.0;

// 1614581530.806326 seconds since epoch
printf("%f seconds since epoch\n", float_time);

clock()

clock()函数返回从程序开始执行到当前的 CPU 时钟周期。一个时钟周期等于 CPU 频率的倒数，比如 CPU 的频率如果是 1G Hz，表示1秒内时钟信号可以变化 10^9 次，那么每个时钟周期就是 10^-9 秒。

1	clock_t　clock(void);

clock()函数返回一个数字，表示从程序开始到现在的 CPU 时钟周期的次数。这个值的类型是 clock_t，一般是 long int 类型。

为了把这个值转换为秒，应该把它除以常量CLOCKS_PER_SEC（每秒的时钟周期），这个常量也由time.h定义。

1	printf("CPU time: %f\n", clock() / (double)CLOCKS_PER_SEC);

上面示例可以输出程序从开始到运行到这一行所花费的秒数。

如果计算机无法提供 CPU 时间，或者返回值太大，无法用clock_t类型表示，clock()函数就返回-1。

为了知道某个操作所耗费的精确时间，需要调用两次clock()，然后将两次的返回值相减。

clock_t start = clock();

// ... 执行某些操作

clock_t end = clock();

long double seconds = (float)(end - start) / CLOCKS_PER_SEC;

参考链接

How to Measure Execution Time of a Program

wchar.h

宽字符使用两个或四个字节表示一个字符，导致 C 语言常规的字符处理函数都会失效。wchar.h 定义了许多宽字符专用的处理函数。

类型别名和宏

wchar.h 定义了一个类型别名 wint_t，表示宽字符对应整数值。

wchar.h 还定义了一个宏 WEOF，表示文件结束字符 EOF 的宽字符版。

btowc()，wctob()

btowc()将单字节字符转换为宽字符，wctob()将宽字符转换为单字节字符。

1 2	wint_t btowc(int c); int wctob(wint_t c);

btowc()返回一个宽字符。如果参数是 EOF，或转换失败，则返回 WEOF。

wctob()返回一个单字节字符。如果参数是 WEOF，或者参数宽字符无法对应单个的单字节字符，则返回 EOF。

下面是用法示例。

wint_t wc = btowc('B'); 

// 输出宽字符 B
wprintf(L"Wide character: %lc\n", wc);

unsigned char c = wctob(wc);

// 输出单字节字符 B
wprintf(L"Single-byte character: %c\n", c);

fwide()

fwide()用来设置一个字节流是宽字符流，还是多字节字符流。

如果使用宽字符专用函数处理字节流，就会默认设置字节流为宽字符流，否则就需要使用fwide()显式设置。

1	int fwide(FILE* stream, int mode);

它接受两个参数，第一个参数是文件指针，第二个参数是字节流模式，有三种选择。

0：字节流模式保持原样。
-1（或其他负值）：设为多字节字符流。
1（或其他正值）：设为宽字符流。

fwide()的返回值也分成三种情况：如果是宽字符流，返回一个正值；如果是多字节字符流，返回一个负值；如果是普通字符流，返回0。

一旦设置了字节流模式，就无法再更改。

#include <stdio.h>
#include <wchar.h>

int main(void) {
  wprintf(L"Hello world!\n");
  int mode = fwide(stdout, 0);
  wprintf(L"Stream is %ls-oriented\n", mode < 0 ? L"byte" : L"wide");
}

上面示例中，wprintf()将字节流隐式设为宽字符模式，所以fwide(stdout, 0)的返回值大于零。

宽字符专用函数

下面这些函数基本都是 stdio.h 里面的字符处理函数的宽字符版本，必须使用这些函数来操作宽字符。

fgetwc() 从宽字符流中获取宽字符，对应 fgetc()。
fgetws() 从宽字符流中读取宽字符串，对应 fgets()。
fputwc() 将宽字符写入宽字符流，对应 fputc()。
fputws() 将宽字符串写入宽字符流，对应 fputs()。
fwprintf() 格式化宽输出到宽字符流，对应 fprintf()。
fwscanf() 来自宽字符流的格式化宽字符输入，对应 fscanf()。
getwchar() 从 stdin 获取一个宽字符，对应 getchar()。
getwc() 从 stdin 获取一个宽字符，对应 getc()。
putwchar() 写一个宽字符到 stdout，对应 putchar()。
putwc() 写一个宽字符到 stdout，对应 putc()。
swprintf() 格式化宽输出到宽字符串，对应 sprintf()。
swscanf() 来自宽字符串的格式化宽输入，对应 sscanf()。
ungetwc() 将宽字符推回输入流，对应 ungetc()。
vfwprintf() 可变参数的格式化宽字符输出到宽字符流，对应 vfprintf()。
vfwscanf() 来自宽字符流的可变参数格式化宽字符输入，对应 vfscanf()。
vswprintf() 可变参数的格式化宽字符输出到宽字符串，对应 vswprintf()。
vswscanf() 来自宽字符串的可变参数格式化宽字符输入，对应 vsscanf()。
vwprintf() 可变参数格式化宽字符输出，对应 vprintf()。
vwscanf() 可变参数的格式化宽字符输入，对应 vscanf()。
wcscat() 危险地连接宽字符串，对应 strcat()。
wcschr() 在宽字符串中查找宽字符，对应 strchr()。
wcscmp() 比较宽字符串，对应 strcmp()。
wcscoll() 比较两个考虑语言环境的宽字符串，对应 strcoll()。
wcscpy() 危险地复制宽字符串，对应 strcpy()。
wcscspn() 不是从宽字符串前面开始计算字符，对应 strcspn()。
wcsftime() 格式化的日期和时间输出，对应 strftime()。
wcslen() 返回宽字符串的长度，对应 strlen()。
wcsncat() 更安全地连接宽字符串，对应 strncat()。
wcsncmp() 比较宽字符串，长度有限，对应 strncmp()。
wcsncpy() 更安全地复制宽字符串，对应 strncpy()。
wcspbrk() 在宽字符串中搜索一组宽字符中的一个，对应 strpbrk()。
wcsrchr() 从末尾开始在宽字符串中查找宽字符，对应 strrchr()。
wcsspn() 从宽字符串前面的集合中计算字符，对应 strspn()。
wcsstr() 在另一个宽字符串中找到一个宽字符串，对应 strstr()。
wcstod() 将宽字符串转换为 double，对应 strtod()。
wcstof() 将宽字符串转换为 float，对应 strtof()。
wcstok() 标记一个宽字符串，对应 strtok()。
wcstold() 将宽字符串转换为 long double，对应 strtold()。
wcstoll() 将宽字符串转换为 long long，对应 strtoll()。
wcstol() 将宽字符串转换为 long，对应 strtol()。
wcstoull() 将宽字符串转换为 unsigned long long，对应 strtoull()。
wcstoul() 将宽字符串转换为 unsigned long，对应 strtoul()。
wcsxfrm() 转换宽字符串以根据语言环境进行比较，对应 strxfrm()。
wmemcmp() 比较内存中的宽字符，对应 memcmp()。
wmemcpy() 复制宽字符内存，对应 memcpy()。
wmemmove() 复制宽字符内存，可能重叠，对应 memmove()。
wprintf() 格式化宽输出，对应 printf()。
wscanf() 格式化宽输入，对应 scanf()。

多字节字符专用函数

wchar.h 也定义了一些多字节字符的专用函数。

mbsinit() 判断 mbstate_t 是否处于初始转换状态。
mbrlen() 给定转换状态时，计算多字节字符串的字节数，对应 mblen()。
mbrtowc() 给定转换状态时，将多字节字符转换为宽字符，对应 mbtowc()。
wctombr() 给定转换状态时，将宽字符转换为多字节字符，对应 wctomb()。
mbsrtowcs() 给定转换状态时，将多字节字符串转换为宽字符串，对应 mbstowcs()。
wcsrtombs() 给定转换状态时，将宽字符串转换为多字节字符串，对应 wcstombs()。

wctype.h

wctype.h 提供 ctype.h 里面函数的宽字符版本。

宽字符类型判断函数

下面函数判断宽字符的类型。

iswalnum() 测试宽字符是否为字母数字
iswalpha() 测试宽字符是否为字母
iswblank() 测试这是否是一个宽空白字符
iswcntrl() 测试这是否是一个宽控制字符。
iswdigit() 测试这个宽字符是否是数字
iswgraph() 测试宽字符是否是可打印的非空格字符
iswlower() 测试宽字符是否为小写
iswprint() 测试宽字符是否可打印
iswpunct() 测试宽字符是否为标点符号
iswspace() 测试宽字符是否为空格
iswupper() 测试宽字符是否为大写
iswxdigit() 测试宽字符是否为十六进制数字

wctype()，iswctype()

iswctype()是上一节各种宽字符类型判断函数的通用版本，必须与wctype()配合使用。

1	int iswctype(wint_t wc, wctype_t desc);

iswctype()接受两个参数，第一个参数是一个需要判断类型的宽字符，第二个参数是宽字符类型描述，来自wctype()的返回值。

如果宽字符属于指定类型，iswctype()返回一个非零值，否则返回零。

wctype()用来获取某个种类宽字符的类型描述。

1	wctype_t wctype(const char* property);

wctype()的参数是一个给定的字符串，可用的值如下：alnum、alpha、blank、cntrl、digit、graph、lower、print、punct、space、upper、xdigit。

wctype()的返回值的类型为 wctype_t，通常是一个整数。如果参数是一个无效值，则返回0。

1
2
3

if (iswctype(c, wctype("digit")))
// 相当于
if (iswdigit(c))

上面示例用来判断宽字符c是否为数值，相当于iswdigit()。

iswctype()的完整类型判断如下。

iswctype(c, wctype("alnum")) // 相当于 iswalnum(c)
iswctype(c, wctype("alpha")) // 相当于 iswalpha(c)
iswctype(c, wctype("blank")) // 相当于 iswblank(c)
iswctype(c, wctype("cntrl")) // 相当于 iswcntrl(c)
iswctype(c, wctype("digit")) // 相当于 iswdigit(c)
iswctype(c, wctype("graph")) // 相当于 iswgraph(c)
iswctype(c, wctype("lower")) // 相当于 iswlower(c)
iswctype(c, wctype("print")) // 相当于 iswprint(c)
iswctype(c, wctype("punct")) // 相当于 iswpunct(c)
iswctype(c, wctype("space")) // 相当于 iswspace(c)
iswctype(c, wctype("upper")) // 相当于 iswupper(c)
iswctype(c, wctype("xdigit")) // 相当于 iswxdigit(c)

大小写转换函数

wctype.h 提供以下宽字符大小写转换函数。

towlower() 将大写宽字符转换为小写
towupper() 将小写宽字符转换为大写
towctrans() 宽字符大小写转换的通用函数
wctrans() 大小写转换的辅助函数，配合 towctrans() 使用

先看towlower()和towupper()的用法示例。

1 2	towlower(L'B') // b towupper(L'e') // E

towctrans()和wctrans()的原型如下。

1 2	wint_t towctrans(wint_t wc, wctrans_t desc); wctrans_t wctrans(const char* property);

下面是它们的用法示例。

1 2	towctrans(c, wctrans("toupper")) // 相当于 towupper(c) towctrans(c, wctrans("tolower")) // 相当于 towlower(c)

《C语言入门教程》阮一峰

https://mxts.jiujiuer.xyz/2021/11/02/计算机科学/编程语言/C·C++/《C语言入门教程》阮一峰/

作者

阮一峰

发布于

2021-11-02

更新于

2025-08-16

许可协议

#C语言