第16章-C预处理器和C库

---

C预处理器在程序执行之前查看程序（故称之为预处理器）。根据程序中的预处理器指令，预处理器把符号缩写替换成其表示的内容。预处理器并不知道 C。基本上它的工作是把一些文本转换成另外一些文本。

翻译程序的第一步：

在预处理之前，编译器必须对该程序进行一些翻译处理。首先，编译器把源代码中出现的字符映射到源字符集。该过程处理多字节字符和三字符序列——字符扩展让C更加国际化。第二，编译器定位每个反斜杠后面跟着换行符的实例，并删除它们。也就是说，把下面两个物理行（physical line）：

printf("That's wond\
erful!\n");

转换成一个逻辑行（logical line）：

printf("That's wonderful\n!");

注意，在这种场合中，“换行符”的意思是通过按下Enter键在源代码文件中换行所生成的字符，而不是指符号表征\n。

由于预处理表达式的长度必须是一个逻辑行，所以这一步为预处理器做好了准备工作。一个逻辑行可以是多个物理行。

第三，编译器把文本划分成预处理记号序列、空白序列和注释序列（记号是由空格、制表符或换行符分隔的项，详见16.2.1）。这里要注意的是，编译器将用一个空格字符替换每一条注释。因此，下面的代码：

int/* 这看起来并不像一个空格*/fox;

将变成：

int fox;

而且，实现可以用一个空格替换所有的空白字符序列（不包括换行符）。最后，程序已经准备好进入预处理阶段，预处理器查找一行中以#号开始的预处理指令。

---

明示常量：#define

/* 简单的预处理示例 */
#include <stdio.h>
#define TWO 2　　　/* 可以使用注释 */
#define OW "Consistency is the last refuge of the unimagina\
tive.- Oscar Wilde" /* 反斜杠把该定义延续到下一行 */
#define FOUR TWO*TWO
#define PX printf("X is %d.\n", x)
#define FMT　"X is %d.\n"
int main(void) {
	int x = TWO;
	PX;
	x = FOUR;
	printf(FMT, x);
	printf("%s\n", OW);
	printf("TWO: OW\n");
	return 0;
}

X is 2.
X is 4.
Consistency is the last refuge of the unimaginative.- Oscar Wilde
TWO: OW

上述的报错， 只要宏替换一看便知：

int y = 20;
printf("x is %d.\n", x); // PX的替换
——>找不到变量x的定义！

注：预处理器不做计算，不对表达式求值，它只进行替换。一般而言，预处理器发现程序中的宏后，会用宏等价的替换文本进行替换。如果替换的字符串中还包含宏，则继续替换这些宏。

#define LIMIT 20
const int LIM = 50;
static int data1[LIMIT];　　　 // 有效
static int data2[LIM];　　　　　// 无效！
const int LIM2 = 2 * LIMIT;　 // 有效
const int LIM3 = 2 * LIM;　　　// 无效！

这里解释一下上面代码中的“无效”注释。在C中，非自动数组的大小应该是整型常量表达式，这意味着表示数组大小的必须是整型常量的组合（如5）、枚举常量和sizeof表达式，不包括const声明的值（7、这也是C++和C的区别之一，在C++中可以把const值作为常量表达式的一部分）。但是，有的实现可能接受其他形式的常量表达式。例如，GCC 4.7.3不允许data2的声明，但是Clang 4.6允许。

记号：

从技术角度来看，可以把宏的替换体看作是记号（token）型字符串，而不是字符型字符串。C预处理器记号是宏定义的替换体中单独的“词”。用空白把这些词分开。例如：

#define FOUR 2*2

该宏定义有一个记号：2*2序列。但是，下面的宏定义中： 

#define SIX 2 * 3

有3个记号：2、*、3。

替换体中有多个空格时，字符型字符串和记号型字符串的处理方式不同。考虑下面的定义：

#define EIGHT 4 * 8

如果预处理器把该替换体解释为字符型字符串，将用4 * 8替换EIGHT。即，额外的空格是替换体的一部分。如果预处理器把该替换体解释为记号型字符串，则用3个的记号4 * 8（分别由单个空格分隔）来替换EIGHT。换而言之，解释为字符型字符串，把空格视为替换体的一部分；解释为记号型字符串，把空格视为替换体中各记号的分隔符。

在实际应用中，一些C编译器把宏替换体视为字符串而不是记号。在比这个例子更复杂的情况下，两者的区别才有实际意义。

顺带一提，C编译器处理记号的方式比预处理器复杂。由于编译器理解C语言的规则，所以不要求代码中用空格来分隔记号。例如，C编译器可以把2*2直接视为3个记号，因为它可以识别2是常量，*是运算符。

重定义常量：

假设先把LIMIT定义为20，稍后在该文件中又把它定义为25。这个过程称为重定义常量。不同的实现采用不同的重定义方案。除非新定义与旧定义相同，否则有些实现会将其视为错误。另外一些实现允许重定义，但会给出警告。ANSI标准采用第1种方案，只有新定义和旧定义完全相同才允许重定义。

具有相同的定义意味着替换体中的记号必须相同，且顺序也相同。因此，下面两个定义相同：

#define SIX 2 * 3
#define SIX 2 * 3

这两条定义都有 3 个相同的记号，额外的空格不算替换体的一部分。而下面的定义则与上面两条宏定义不同：

#define SIX 2*3

这条宏定义中只有一个记号，因此与前两条定义不同。如果需要重定义宏，使用#undef 指令（稍后讨论）。

如果确实需要重定义常量，使用const关键字和作用域规则更容易些。

在#define中使用参数：

在#define中使用参数可以创建外形和作用与函数类似的类函数宏。

#define SQUARE(X) X*X

在程序中可以这样用：

z = SQUARE(2);

程序中设置x的值为5，你可能认为SQUARE(x+2)应该是 7*7，即 49。但是，输出的结果是 17，这不是一个平方值！导致这样结果的原因是，我们前面提到过，预处理器不做计算、不求值，只替换字符序列。预处理器把出现x的地方都替换成x+2。因此，x*x变成了x+2*x+2。如果x为5，那么该表达式的值为：5+2*5+2 = 5 + 10 + 2 = 17

要多加几个圆括号：

#define SQUARE(x) (x)*(x)

现在SQUARE(x+2)变成了(x+2)*(x+2)，在替换字符串中使用圆括号就得到符合预期的乘法运算。

但是，这并未解决所有的问题。下面的输出行：

100/SQUARE(2)
将变成：
100/2*2 = 50*2 = 100

把SQUARE(x)定义为下面的形式可以解决这种混乱：

#define SQUARE(x) (x*x)

这样修改定义后得100/(2*2)，即100/4，得25。

要处理前面的两种情况，要这样定义：

#define SQUARE(x) ((x)*(x))

因此，必要时要使用足够多的圆括号来确保运算和结合的正确顺序。

尽管如此，这样做还是无法避免程序中最后一种情况的问题。SQUARE(++x)变成了++x*++x，递增了两次x，一次在乘法运算之前，一次在乘法运算之后：++x*++x = 6*7 = 42。

解决这个问题最简单的方法是，避免用++x 作为宏参数。一般而言，不要在宏中使用递增或递减运算符。

用宏参数创建字符串：#运算符

下面是一个类函数宏：

#define PSQR(X) printf("The square of X is %d.\n", ((X)*(X)));

PSQR(8);
输出为：
The square of X is 64.

注意双引号字符串中的X被视为普通文本，而不是一个可被替换的记号。

C允许在字符串中包含宏参数。在类函数宏的替换体中，#号作为一个预处理运算符，可以把记号转换成字符串。例如，如果x是一个宏形参，那么#x就是转换为字符串"x"的形参名。这个过程称为字符串化（stringizing）。

/* 在字符串中替换 */
#include <stdio.h>
#define PSQR(x) printf("The square of " #x " is %d.\n",((x)*(x)))
int main(void) {
    int y = 5;
    PSQR(y);  // 可直接传入变量名
    PSQR(2 + 4);

    return 0;
}

The square of y is 25.
The square of 2 + 4 is 36.

调用第1个宏时，用"y"替换#x。调用第2个宏时，用"2 + 4"替换#x。

预处理器黏合剂：##运算符

与#运算符类似，##运算符可用于类函数宏的替换部分。而且，##还可用于对象宏的替换部分。##运算符把两个记号组合成一个记号。例如，可以这样做：

#define XNAME(n) x ## n

然后，宏XNAME(4)将展开为x4。

// 使用##运算符
#include <stdio.h>
#define XNAME(n) x ## n
#define PRINT_XN(n) printf("x" #n " = %d\n", x ## n);
int main(void) {
    int XNAME(1) = 14;　　// 变成 int x1 = 14;
    int XNAME(2) = 20;　　// 变成 int x2 = 20;
    int x3 = 30;
    PRINT_XN(1);　　　　　 // 变成 printf("x1 = %d\n", x1);
    PRINT_XN(2);　　　　　 // 变成 printf("x2 = %d\n", x2);
    PRINT_XN(3);　　　　　 // 变成 printf("x3 = %d\n", x3);
    return 0;
}

x1 = 14
x2 = 20
x3 = 30

注意，PRINT_XN()宏用#运算符组合字符串，##运算符把记号组合为一个新的标识符。

变参宏：...和_ _VA_ARGS_ _

通过把宏参数列表中最后的参数写成省略号（即，3个点...）来实现这一功能。这样，预定义宏_ _VA_ARGS_ _可用在替换部分中，表明省略号代表什么。例如，下面的定义：

#define PR(...) printf(_ _VA_ARGS_ _)

假设稍后调用该宏：

PR("Howdy");
PR("weight = %d, shipping = $%.2f\n", wt, sp);

对于第1次调用，_ _VA_ARGS_ _展开为1个参数："Howdy"。

对于第2次调用，_ _VA_ARGS_ _展开为3个参数："weight = %d, shipping = $%.2f\n"、wt、sp。

因此，展开后的代码是：

printf("Howdy");
printf("weight = %d, shipping = $%.2f\n", wt, sp);

// 变参宏
#include <stdio.h>
#include <math.h>
#define PR(X, ...) printf("Message " #X ": " __VA_ARGS__)
int main(void) {
    double x = 48;
    double y;
    y = sqrt(x);
    PR(1, "x = %g\n", x);
    PR(2, "x = %.2f, y = %.4f\n", x, y);
    return 0;
}

Message 1: x = 48
Message 2: x = 48.00, y = 6.9282

第1个宏调用，X的值是1，所以#X变成"1"。展开后成为：

print("Message " "1" ": " "x = %g\n", x);

然后，串联4个字符，把调用简化为：

print("Message 1: x = %g\n", x);

 记住，省略号只能代替最后的宏参数。即 ... 替换__VA_ARGS__。

宏和函数的选择：

宏和函数的选择实际上是时间和空间的权衡。宏生成内联代码，即在程序中生成语句。如果调用20次宏，即在程序中插入20行代码。如果调用函数20次，程序中只有一份函数语句的副本，所以节省了空间。然而另一方面，程序的控制必须跳转至函数内，随后再返回主调程序，这显然比内联代码花费更多的时间。

宏的一个优点是，不用担心变量类型（这是因为宏处理的是字符串，而不是实际的值）。因此，只要能用int或float类型都可以使用SQUARE(x)宏。

对于简单的函数，程序员通常使用宏，如下所示：

#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
#define ABS(X) ((X) < 0 ? -(X) : (X))
#define ISSIGN(X) ((X) == '+' || (X) == '-' ? 1 : 0)

用圆括号把宏的参数和整个替换体括起来。这样能确保被括起来的部分在下面这样的表达式中正确地展开：

forks = 2 * MAX(guests + 3, last);

如果打算使用宏来加快程序的运行速度，那么首先要确定使用宏和使用函数是否会导致较大差异。在程序中只使用一次的宏无法明显减少程序的运行时间。在嵌套循环中使用宏更有助于提高效率。许多系统提供程序分析器以帮助程序员压缩程序中最耗时的部分。

文件包含：#include

当预处理器发现#include 指令时，会查看后面的文件名并把文件的内容包含到当前文件中，即替换源文件中的#include指令。这相当于把被包含文件的全部内容输入到源文件#include指令所在的位置。

#include <stdio.h>　　　　  ←查找系统目录
#include "hot.h"　　　　　  ←查找当前工作目录
#include "/usr/biff/p.h"  ←查找/usr/biff目录

包含一个大型头文件不一定显著增加程序的大小。在大部分情况下，头文件的内容是编译器生成最终代码时所需的信息，而不是添加到最终代码中的材料。

// names_st.h -- names_st 结构的头文件
#include <string.h>
#define SLEN 32 // 常量
struct names_st { // 结构声明
    char first[SLEN];
    char last[SLEN];
};
typedef struct names_st names; // 类型定义
// 函数原型
void get_names(names *);
void show_names(const names *);
char * s_gets(char * st, int n);

可执行代码通常在源代码文件中，而不是在头文件中。

// names_st.c -- 定义 names_st.h中的函数
#include <stdio.h>
#include "names_st.h"　　// 包含头文件
// 函数定义
void get_names(names * pn) {
    printf("Please enter your first name: ");
    s_gets(pn->first, SLEN);
    printf("Please enter your last name: ");
    s_gets(pn->last, SLEN);
}
void show_names(const names * pn) {
    printf("%s %s", pn->first, pn->last);
}
char * s_gets(char * st, int n) {
    char * ret_val;
    char * find;
    ret_val = fgets(st, n, stdin);
    if (ret_val) {
        find = strchr(st, '\n');　 // 查找换行符
        if (find)　　　　　　　　　 // 如果地址不是NULL，
            *find = '\0';　　　　 // 在此处放置一个空字符
        else
            while (getchar() != '\n')
                continue;　　　// 处理输入行中的剩余字符
    }
    return ret_val;
}

// useheader.c -- 使用 names_st 结构
#include <stdio.h>
#include "names_st.h"
// 记住要链接 names_st.c
int main(void) {
    names candidate;
    get_names(&candidate);
    printf("Let's welcome ");
    show_names(&candidate);
    printf(" to this program!\n");
    return 0;
}

Please enter your first name: Ian
Please enter your last name: Smersh
Let's welcome Ian Smersh to this program!

两个源代码文件都使用names_st类型结构，所以它们都必须包含names_st.h头文件。

必须编译和链接names_st.c和useheader.c源代码文件。

声明和指令放在nems_st.h头文件中，函数定义放在names_st.c源代码文件中。

使用头文件：

浏览任何一个标准头文件都可以了解头文件的基本信息。头文件中最常用的形式如下。

明示常量——例如，stdio.h中定义的EOF、NULL和BUFSIZE（标准I/O缓冲区大小）。

宏函数——例如，getc(stdin)通常用getchar()定义，而getc()经常用于定义较复杂的宏，头文件ctype.h通常包含ctype系列函数的宏定义。

函数声明——例如，string.h头文件（一些旧的系统中是strings.h）包含字符串函数系列的函数声明。在ANSI C和后面的标准中，函数声明都是函数原型形式。

结构模版定义——标准I/O函数使用FILE结构，该结构中包含了文件和与文件缓冲区相关的信息。FILE结构在头文件stdio.h中。

类型定义——标准 I/O 函数使用指向 FILE 的指针作为参数。通常，stdio.h 用#define 或typedef把FILE定义为指向结构的指针。类似地，size_t和time_t类型也定义在头文件中。

int status = 0;　　　　// 该变量具有文件作用域，在源代码文件
然后，可以在与源代码文件相关联的头文件中进行引用式声明：
extern int status;　　 // 在头文件中

这行代码会出现在包含了该头文件的文件中，这样使用该系列函数的文件都能使用这个变量。

需要包含头文件的另一种情况是，使用具有文件作用域、内部链接和const 限定符的变量或数组。const 防止值被意外修改，static 意味着每个包含该头文件的文件都获得一份副本。因此，不需要在一个文件中进行定义式声明，在其他文件中进行引用式声明。

其他指令：

#undef指令：

#undef指令用于“取消”已定义的#define指令。也就是说，假设有如下定义：

#define LIMIT 400

然后，下面的指令:

#undef LIMIT

将移除上面的定义。现在就可以把LIMIT重新定义为一个新值。即使原来没有定义LIMIT，取消LIMIT的定义仍然有效。如果想使用一个名称，又不确定之前是否已经用过，为安全起见，可以用#undef 指令取消该名字的定义。

从C预处理器角度看已定义：

如果标识符是同一个文件中由前面的#define指令创建的宏名，而且没有用#undef 指令关闭，那么该标识符是已定义的。如果标识符不是宏，假设是一个文件作用域的C变量，那么该标识符对预处理器而言就是未定义的。

已定义宏可以是对象宏，包括空宏或类函数宏：

#define LIMIT 1000　　　　   // LIMIT是已定义的
#define GOOD　　　　　　　   // GOOD 是已定义的
#define A(X) ((-(X))*(X))　// A 是已定义的
int q;　　　　　　　　　　　  // q 不是宏，因此是未定义的！！！
#undef GOOD　　　　　　　　  // GOOD 取消定义，是未定义的

条件编译：

可以使用其他指令创建条件编译（conditinal compilation）。也就是说，可以使用这些指令告诉编译器根据编译时的条件执行或忽略信息（或代码）块。

1.#ifdef、#else和#endif指令

#ifdef MAVIS
#include "horse.h"　// 如果已经用#define定义了 MAVIS，则执行下面的指令
#define STABLES 5
#else
#include "cow.h"　　//如果没有用#define定义 MAVIS，则执行下面的指令
#define STABLES 15
#endif

条件编译可以直接嵌套在代码里面：

这里使用的较新的编译器和 ANSI 标准支持的缩进格式。如果使用旧的编译器，必须左对齐所有的指令或至少左对齐#号。

/* 使用条件编译 */
#include <stdio.h>
#define JUST_CHECKING
#define LIMIT 4
int main(void) {
    int i;
    int total = 0;
    for (i = 1; i <= LIMIT; i++) {
        total += 2 * i*i + 1;
        #ifdef JUST_CHECKING
            printf("i=%d, running total = %d\n", i, total);
        #endif
    }
    printf("Grand total = %d\n", total);
    return 0;
}

i=1, running total = 3
i=2, running total = 12
i=3, running total = 31
i=4, running total = 64
Grand total = 64

如果省略JUST_CHECKING定义（把它放在C注释中，或者使用#undef指令取消它的定义）并重新编译该程序，只会输出最后一行。

可以用这种方法在调试程序。定义JUST_CHECKING并合理使用#ifdef，编译器将执行用于调试的程序代码，打印中间值。调试结束后，可移除JUST_CHECKING定义并重新编译。如果以后还需要使用这些信息，重新插入定义即可。这样做省去了再次输入额外打印语句的麻烦。#ifdef还可用于根据不同的C实现选择合适的代码块。

2.#ifndef指令

#ifndef指令与#ifdef指令的用法类似，也可以和#else、#endif一起使用，但是它们的逻辑相反。#ifndef指令判断后面的标识符是否是未定义的，常用于定义之前未定义的常量。如下所示：

/* arrays.h */
#ifndef SIZE
#define SIZE 100
#endif

通常，包含多个头文件时，其中的文件可能包含了相同宏定义。#ifndef指令可以防止相同的宏被重复定义。

在被包含的文件中有某些项（如，一些结构类型的声明）只能在一个文件中出现一次。C标准头文件使用#ifndef技巧避免重复包含。

// names.h -- 修订后的 names_st 头文件，避免重复包含
#ifndef NAMES_H_
#define NAMES_H_
// 明示常量
#define SLEN 32
// 结构声明
struct names_st{
    char first[SLEN];
    char last[SLEN];
};
// 类型定义
typedef struct names_st names;
// 函数原型
void get_names(names *);
void show_names(const names *);
char * s_gets(char * st, int n);
#endif

// doubincl.c -- 包含头文件两次
#include <stdio.h>
#include "names.h"
#include "names.h"　 // 不小心第2次包含头文件
int main() {
    names winner = { "Less", "Ismoor" };
    printf("The winner is %s %s.\n", winner.first, winner.last);
    return 0;
}

3.#if和#elif指令

可以按照if else的形式使用#elif（早期的实现不支持#elif）。例如，可以这样写：

#if SYS == 1
#include "ibmpc.h"
#elif SYS == 2
#include "vax.h"
#elif SYS == 3
#include "mac.h"
#else
#include "general.h"
#endif

较新的编译器提供另一种方法测试名称是否已定义，即用#if defined(VAX)代替#ifdef VAX。

#if defined (IBMPC)
#include "ibmpc.h"
#elif defined (VAX)
#include "vax.h"
#elif defined (MAC)
#include "mac.h"
#else
#include "general.h"
#endif

如果在VAX机上运行这几行代码，那么应该在文件前面用下面的代码定义VAX：

#define VAX

条件编译还有一个用途是让程序更容易移植。改变文件开头部分的几个关键的定义，即可根据不同的系统设置不同的值和包含不同的文件。

预定义宏：

C标准规定了一些预定义宏，如表16.1所列。

C11标准是C语言标准的第三版，前一个标准版本是C99标准。

// predef.c -- 预定义宏和预定义标识符
#include <stdio.h>
void why_me();
int main() {
    printf("The file is %s.\n", __FILE__);
    printf("The date is %s.\n", __DATE__);
    printf("The time is %s.\n", __TIME__);
    printf("The version is %ld.\n", __STDC_VERSION__);
    printf("This is line %d.\n", __LINE__);
    printf("This function is %s\n", __func__);
    why_me();
    return 0;
}
void why_me() {
    printf("This function is %s\n", __func__);
    printf("This is line %d.\n", __LINE__);
}

The file is /Volumes/Data/workplace/c_workplace/XcodeCpp/XcodeCpp/main.c.
The date is Oct 23 2019.
The time is 23:11:51.
The version is 201112.
This is line 9.
This function is main
This function is why_me
This is line 16.

#line和#error： 

#line指令重置_ _LINE_ _和_ _FILE_ _宏报告的行号和文件名。

可以这样使用#line：

#line 1000　　　　　// 把当前行号重置为1000
#line 10 "cool.c" // 把行号重置为10，把文件名重置为cool.c

#error 指令让预处理器发出一条错误消息，该消息包含指令中的文本。如果可能的话，编译过程应该中断。

可以这样使用#error指令：

#if _ _STDC_VERSION_ _ != 201112L
#error Not C11
#endif

编译以上代码生成后，输出如下： 

$ gcc newish.c
newish.c:14:2: error: #error Not C11
$ gcc -std=c11 newish.c
$

如果编译器只支持旧标准，则会编译失败，如果支持C11标准，就能成功编译。

#pragma：

在现在的编译器中，可以通过命令行参数或IDE菜单修改编译器的一些设置。#pragma把编译器指令放入源代码中。例如，在开发C99时，标准被称为C9X，可以使用下面的编译指示（pragma）让编译器支持C9X：

#pragma c9x on

一般而言，编译器都有自己的编译指示集。例如，编译指示可能用于控制分配给自动变量的内存量，或者设置错误检查的严格程度，或者启用非标准语言特性等。C99 标准提供了 3 个标准编译指示，但是超出了本书讨论的范围。

C99还提供_Pragma预处理器运算符，该运算符把字符串转换成普通的编译指示。例如：

_Pragma("nonstandardtreatmenttypeB on")

等价于下面的指令：

#pragma nonstandardtreatmenttypeB on

由于该运算符不使用#符号，所以可以把它作为宏展开的一部分：

#define PRAGMA(X) _Pragma(#X)
#define LIMRG(X) PRAGMA(STDC CX_LIMITED_RANGE X)

然后，可以使用类似下面的代码：

LIMRG ( ON )

顺带一提，下面的定义看上去没问题，但实际上无法正常运行：

#define LIMRG(X) _Pragma(STDC CX_LIMITED_RANGE #X)

问题在于这行代码依赖字符串的串联功能，而预处理过程完成之后才会串联字符串。

_Pragma 运算符完成“解字符串”（destringizing）的工作，即把字符串中的转义序列转换成它所代表的字符。因此，

_Pragma("use_bool \"true \"false")

变成了：

#pragma use_bool "true "false

泛型选择（C11）：

在程序设计中，泛型编程（generic programming）指那些没有特定类型，但是一旦指定一种类型，就可以转换成指定类型的代码。例如，C++在模板中可以创建泛型算法，然后编译器根据指定的类型自动使用实例化代码。C没有这种功能。然而，C11新增了一种表达式，叫作泛型选择表达式（generic selection expression），可根据表达式的类型（即表达式的类型是int、double 还是其他类型）选择一个值。泛型选择表达式不是预处理器指令，但是在一些泛型编程中它常用作#define宏定义的一部分。

下面是一个泛型选择表达式的示例：

_Generic(x, int: 0, float: 1, double: 2, default: 3)

_Generic是C11的关键字。_Generic后面的圆括号中包含多个用逗号分隔的项。第1个项是一个表达式，后面的每个项都由一个类型、一个冒号和一个值组成，如float: 1。第1个项的类型匹配哪个标签，整个表达式的值是该标签后面的值。例如，假设上面表达式中x是int类型的变量，x的类型匹配int:标签，那么整个表达式的值就是0。如果没有与类型匹配的标签，表达式的值就是default:标签后面的值。泛型选择语句与 switch 语句类似，只是前者用表达式的类型匹配标签，而后者用表达式的值匹配标签。

下面是一个把泛型选择语句和宏定义组合的例子：

#define MYTYPE(X) _Generic((X),\
int: "int",\
float : "float",\
double: "double",\
default: "other"\
)

宏必须定义为一条逻辑行，但是可以用\把一条逻辑行分隔成多条物理行。在这种情况下，对泛型选择表达式求值得字符串。例如，对MYTYPE(5)求值得"int"，因为值5的类型与int:标签匹配。

#include <stdio.h>
#define MYTYPE(X) _Generic((X),\
int: "int",\
float : "float",\
double: "double",\
default: "other"\
)
int main(void) {
    int d = 5;
    printf("%s\n", MYTYPE(d));　　　// d 是int类型
    printf("%s\n", MYTYPE(2.0*d)); // 2.0 * d 是double类型
    printf("%s\n", MYTYPE(3L));　　 // 3L 是long类型
    printf("%s\n", MYTYPE(&d));　　 // &d 的类型是 int *
    return 0;
}

int
double
other
other

对一个泛型选择表达式求值时，程序不会先对第一个项求值，它只确定类型。只有匹配标签的类型后才会对表达式求值。

可以像使用独立类型（“泛型”）函数那样使用_Generic 定义宏。

内联函数（C99）:

通常，函数调用都有一定的开销，因为函数的调用过程包括建立调用、传递参数、跳转到函数代码并返回。使用宏使代码内联，可以避免这样的开销。C99还提供另一种方法：内联函数（inline function）。读者可能顾名思义地认为内联函数会用内联代码替换函数调用。其实C99和C11标准中叙述的是：“把函数变成内联函数建议尽可能快地调用该函数，其具体效果由实现定义”。因此，把函数变成内联函数，编译器可能会用内联代码替换函数调用，并（或）执行一些其他的优化，但是也可能不起作用。

创建内联函数的定义有多种方法。标准规定具有内部链接的函数可以成为内联函数，还规定了内联函数的定义与调用该函数的代码必须在同一个文件中。因此，最简单的方法是使用函数说明符 inline 和存储类别说明符static。通常，内联函数应定义在首次使用它的文件中，所以内联函数也相当于函数原型。如下所示：

#include <stdio.h>
inline static void eatline() { // 内联函数定义/原型
    while (getchar() != '\n')
        continue;
}
int main() {
    ...
    eatline(); // 函数调用
    ...
}

编译器查看内联函数的定义（也是原型），可能会用函数体中的代码替换 eatline()函数调用。也就是说，效果相当于在函数调用的位置输入函数体中的代码：

#include <stdio.h>
inline static void eatline() { //内联函数定义/原型
    while (getchar() != '\n')
        continue;
}
int main() {
    ...
    while (getchar() != '\n') //替换函数调用
        continue;
    ...
}

由于并未给内联函数预留单独的代码块，所以无法获得内联函数的地址（实际上可以获得地址，不过这样做之后，编译器会生成一个非内联函数）。另外，内联函数无法在调试器中显示。内联函数应该比较短小。把较长的函数变成内联并未节约多少时间，因为执行函数体的时间比调用函数的时间长得多。

编译器优化内联函数必须知道该函数定义的内容。这意味着内联函数定义与函数调用必须在同一个文件中。鉴于此，一般情况下内联函数都具有内部链接。因此，如果程序有多个文件都要使用某个内联函数，那么这些文件中都必须包含该内联函数的定义。最简单的做法是，把内联函数定义放入头文件，并在使用该内联函数的文件中包含该头文件即可。

// eatline.h
#ifndef EATLINE_H_
#define EATLINE_H_
inline static void eatline() {
    while (getchar() != '\n')
        continue;
}
#endif

一般都不在头文件中放置可执行代码，内联函数是个特例。因为内联函数具有内部链接，所以在多个文件中定义同一个内联函数不会产生什么问题。

与C++不同的是，C还允许混合使用内联函数定义和外部函数定义（具有外部链接的函数定义）。例如，一个程序中使用下面3个文件：

//file1.c
...
inline static double square(double);
int main() {
    double q = square(1.3);
    ...
}
double square(double x) {
    return x * x;
}
...
————————————————————————————————————————————
//file2.c
...
double square(double x) { return (int) (x*x); }
void spam(double v) {
    double kv = square(v);
    ...
————————————————————————————————————————————
//file3.c
...
inline double square(double x) { return (int) (x * x + 0.5); }
void masp(double w) {
    double kw = square(w);
    ...

如上述代码所示，3个文件中都定义了square()函数。file1.c文件中是inline static定义；file2.c 文件中是普通的函数定义（因此具有外部链接）；file3.c 文件中是 inline 定义，省略了static。

3个文件中的函数都调用了square()函数，这会发生什么情况？。file1.c文件中的main()使用square()的局部static定义。由于该定义也是inline定义，所以编译器有可能优化代码，也许会内联该函数。file2.c 文件中，spam()函数使用该文件中 square()函数的定义，该定义具有外部链接，其他文件也可见。file3.c文件中，编译器既可以使用该文件中square()函数的内联定义，也可以使用file2.c文件中的外部链接定义。如果像file3.c那样，省略file1.c文件inline定义中的static，那么该inline定义被视为可替换的外部定义。

注意GCC在C99之前就使用一些不同的规则实现了内联函数，所以GCC可以根据当前编译器的标记来解释inline。

_Noreturn函数（C11）：

C99新增inline关键字时，它是唯一的函数说明符（关键字extern和static是存储类别说明符，可应用于数据对象和函数）。C11新增了第2个函数说明符_Noreturn，表明调用完成后函数不返回主调函数。exit()函数是_Noreturn 函数的一个示例，一旦调用exit()，它不会再返回主调函数。注意，这与void返回类型不同。void类型的函数在执行完毕后返回主调函数，只是它不提供返回值。

_Noreturn的目的是告诉用户和编译器，这个特殊的函数不会把控制返回主调程序。告诉用户以免滥用该函数，通知编译器可优化一些代码。

C库：

最初，并没有官方的C库。后来，基于UNIX的C实现成为了标准。ANSI C委员会主要以这个标准为基础，开发了一个官方的标准库。在意识到C语言的应用范围不断扩大后，该委员会重新定义了这个库，使之可以应用于其他系统。

我们讨论过一些标准库中的 I/O 函数、字符函数和字符串函数。本章将介绍更多函数。不过，首先要学习如何使用库。

访问C库：

如何访问C库取决于实现，因此你要了解当前系统的一般情况。首先，可以在多个不同的位置找到库函数。例如，getchar()函数通常作为宏定义在stdio.h头文件中，而strlen()通常在库文件中。其次，不同的系统搜索这些函数的方法不同。下面介绍3种可能的方法。

1.自动访问

在一些系统中，只需编译程序，就可使用一些常用的库函数。记住，在使用函数之前必须先声明函数的类型，通过包含合适的头文件即可完成。在描述库函数的用户手册中，会指出使用某函数时应包含哪个头文件。

2.文件包含

如果函数被定义为宏，那么可以通过#include 指令包含定义宏函数的文件。通常，类似的宏都放在合适名称的头文件中。例如，许多系统（包括所有的ANSI C系统）都有ctype.h文件，该文件中包含了一些确定字符性质（如大写、数字等）的宏。

3.库包含

在编译或链接程序的某些阶段，可能需要指定库选项。即使在自动检查标准库的系统中，也会有不常用的函数库。必须通过编译时选项显式指定这些库。注意，这个过程与包含头文件不同。头文件提供函数声明或原型，而库选项告诉系统到哪里查找函数代码。虽然这里无法涉及所有系统的细节，但是可以提醒读者应该注意什么。

使用库描述：

可以看几个具有代表性的示例。首先，了解函数文档。

可以在多个地方找到函数文档。你所使用的系统可能有在线手册，集成开发环境通常都有在线帮助。C实现的供应商可能提供描述库函数的纸质版用户手册，或者把这些材料放在CD-ROM中或网上。有些出版社也出版C库函数的参考手册。这些材料中，有些是一般材料，有些则是针对特定实现的。

关于fread()的描述，早期是：

#include <stdio.h>
int fread(ptr, size, nitems, stream);
char *ptr;
int size, nitems;
FILE *stream;

ANSI C90标准提供了下面的描述：

#include <stdio.h>
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

首先，使用了新的函数原型格式。其次，改变了一些类型。size_t 类型被定义为 sizeof 运算符的返回值类型——无符号整数类型，通常是unsigned int或unsigned long。stddef.h文件中包含了size_t类型的typedef或#define定义。其他文件（包括stdio.h）通过包含stddef.h来包含这个定义。许多函数（包括fread()）的实际参数中都要使用sizeof运算符，形式参数的size_t类型中正好匹配这种常见的情况。

另外，ANSI C把指向void的指针作为一种通用指针，用于指针指向不同类型的情况。例如，fread()的第1个参数可能是指向一个double类型数组的指针，也可能是指向其他类型结构的指针。如果假设实际参数是一个指向内含20个double类型元素数组的指针，且形式参数是指向void的指针，那么编译器会选用合适的类型，不会出现类型冲突的问题。

C99/C11标准在以上的描述中加入了新的关键字restrict：

#include <stdio.h>
size_t fread(void * restrict ptr, size_t size,size_t nmemb, FILE * restrict stream);

数学库：

数学库中包含许多有用的数学函数。math.h头文件提供这些函数的原型。

注意，函数中涉及的角度都以弧度为单位（1 弧度=180/π=57.296 度）。

三角问题：

/* 把直角坐标转换为极坐标 */
#include <stdio.h>
#include <math.h>
#define RAD_TO_DEG (180/(4 * atan(1)))
typedef struct polar_v {
	double magnitude;
	double angle;
} Polar_V;
typedef struct rect_v {
	double x;
	double y;
} Rect_V;
Polar_V rect_to_polar(Rect_V);
int main(void) {
	Rect_V input;
	Polar_V result;
	puts("Enter x and y coordinates; enter q to quit:");
	while (scanf("%lf %lf", &input.x, &input.y) == 2) {
		result = rect_to_polar(input);
		printf("magnitude = %0.2f, angle = %0.2f\n", result.magnitude, result.angle);
	}
	puts("Bye.");
	return 0;
}
Polar_V rect_to_polar(Rect_V rv) {
	Polar_V pv;
	pv.magnitude = sqrt(rv.x * rv.x + rv.y * rv.y);
	if (pv.magnitude == 0)
		pv.angle = 0.0;
	else
		pv.angle = RAD_TO_DEG * atan2(rv.y, rv.x);
	return pv;
}

Enter x and y coordinates; enter q to quit:
|10 10
magnitude = 14.14, angle = 45.00
|-12 -5
magnitude = 13.00, angle = -157.38
q
Bye.

类型变体：

如果不需要双精度，那么用float类型的单精度值来计算会更快些。而且把long double类型的值传递给double类型的形参会损失精度，形参获得的值可能不是原来的值。为了解决这些潜在的问题，C标准专门为float类型和long double类型提供了标准函数，即在原函数名前加上f或l前缀。因此，sqrtf()是sqrt()的float版本，sqrtl()是sqrt()的long double版本。

利用C11 新增的泛型选择表达式定义一个泛型宏，根据参数类型选择最合适的数学函数版本。

/*　定义泛型宏 */
#include <stdio.h>
#include <math.h>
#define RAD_TO_DEG (180/(4 * atanl(1)))
// 泛型平方根函数
#define SQRT(X) _Generic(\
    (X),\
    long double: sqrtl, \
    default: sqrt, \
    float: sqrtf)(X)
// 泛型正弦函数，角度的单位为度
#define SIN(X) _Generic(\
    (X),\
    long double: sinl((X)/RAD_TO_DEG),\
    default: sin((X)/RAD_TO_DEG),\
    float: sinf((X)/RAD_TO_DEG)\
)
int main(void) {
    float x = 45.0f;
    double xx = 45.0;
    long double xxx = 45.0L;
    long double y = SQRT(x);
    long double yy = SQRT(xx);
    long double yyy = SQRT(xxx);
    printf("%.17Lf\n", y); // 匹配 float
    printf("%.17Lf\n", yy); // 匹配 default
    printf("%.17Lf\n", yyy); // 匹配 long double
    int i = 45;
    yy = SQRT(i); // 匹配 default
    printf("%.17Lf\n", yy);
    yyy = SIN(xxx); // 匹配 long double
    printf("%.17Lf\n", yyy);
    return 0;
}

6.70820379257202148
6.70820393249936942
6.70820393249936909
6.70820393249936942
0.70710678118654752

如上所示，SQRT(i)和SQRT(xx)的返回值相同，因为它们的参数类型分别是int和double，所以只能与default标签对应。

有趣的一点是，如何让_Generic 宏的行为像一个函数。SIN()的定义也许提供了一个方法：每个带标号的值都是函数调用，所以_Generic表达式的值是一个特定的函数调用，如sinf((X)/RAD_TO_DEG)，用传入SIN()的参数替换X。

SQRT()的定义也许更简洁。_Generic表达式的值就是函数名，如sinf。函数的地址可以代替该函数名，所以_Generic表达式的值是一个指向函数的指针。然而，紧随整个_Generic表达式之后的是(X)，函数指针(参数)表示函数指针。因此，这是一个带指定的参数的函数指针。

简而言之，对于 SIN()，函数调用在泛型选择表达式内部；而对于SQRT()，先对泛型选择表达式求值得一个指针，然后通过该指针调用它所指向的函数。

tgmath.h库（C99）:

如果包含了tgmath.h，要调用sqrt()函数而不是sqrt()宏，可以用圆括号把被调用的函数名括起来：

#include <tgmath.h>
...
float x = 44.0;
double y;
y = sqrt(x);　　　 // 调用宏，所以是 sqrtf(x)
y = (sqrt)(x);　　// 调用函数 sqrt()

这样做没问题，因为类函数宏的名称必须用圆括号括起来。圆括号只会影响操作顺序，不会影响括起来的表达式，所以这样做得到的仍然是函数调用的结果。实际上，在讨论函数指针时提到过，由于C语言奇怪而矛盾的函数指针规则，还也可以使用(*sqrt)()的形式来调用sqrt()函数。 

不借助C标准以外的机制，C11新增的_Generic表达式是实现tgmath.h最简单的方式。

通用工具库：

通用工具库包含各种函数，包括随机数生成器、查找和排序函数、转换函数和内存管理函数。

exit()和atexit()函数：

ANSI 标准还新增了一些不错的功能，其中最重要的是可以指定在执行 exit()时调用的特定函数。atexit()函数通过退出时注册被调用的函数提供这种功能，atexit()函数接受一个函数指针作为参数。

/* atexit()示例 */
#include <stdio.h>
#include <stdlib.h>
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("Thus terminates another magnificent program from");
    puts("SeeSaw Software!");
}
void too_bad(void) {
    puts("SeeSaw Software extends its heartfelt condolences");
    puts("to you upon the failure of your program.");
}

Enter an integer:
|212
212 is even.
Thus terminates another magnificent program from
SeeSaw Software!

如果在IDE中运行，可能看不到最后两行。下面是另一个运行示例：

Enter an integer:
|what?
That's no integer!
SeeSaw Software extends its heartfelt condolences
to you upon the failure of your program.
Thus terminates another magnificent program from
SeeSaw Software!

在IDE中运行，可能看不到最后4行。

1.atexit()函数的用法

这个函数使用函数指针。要使用 atexit()函数，只需把退出时要调用的函数地址传递给 atexit()即可。函数名作为函数参数时相当于该函数的地址，所以该程序中把sign_off或too_bad作为参数。然后，atexit()注册函数列表中的函数，当调用exit()时就会执行这些函数。ANSI保证，在这个列表中至少可以放 32 个函数。最后调用 exit()函数时，exit()会执行这些函数（执行顺序与列表中的函数顺序相反，即最后添加的函数最先执行）。

注意，输入失败时，会调用sign_off()和too_bad()函数；但是输入成功时只会调用sign_off()。因为只有输入失败时，才会进入if语句中注册too_bad()。另外还要注意，最先调用的是最后一个被注册的函数。

atexit()注册的函数（如sign_off()和too_bad()）应该不带任何参数且返回类型为void。通常，这些函数会执行一些清理任务，例如更新监视程序的文件或重置环境变量。

注意，即使没有显式调用exit()，还是会调用sign_off()，因为main()结束时会隐式调用exit()。

2.exit()函数的用法

exit()执行完atexit()指定的函数后，会完成一些清理工作：刷新所有输出流、关闭所有打开的流和关闭由标准I/O函数tmpfile()创建的临时文件。然后exit()把控制权返回主机环境，如果可能的话，向主机环境报告终止状态。通常，UNIX程序使用0表示成功终止，用非零值表示终止失败。UNIX返回的代码并不适用于所有的系统，所以ANSI C为了可移植性的要求，定义了一个名为EXIT_FAILURE的宏表示终止失败。类似地，ANSI C还定义了EXIT_SUCCESS表示成功终止。不过，exit()函数也接受0表示成功终止。在ANSI C中，在非递归的main()中使用exit()函数等价于使用关键字return。尽管如此，在main()以外的函数中使用exit()也会终止整个程序。

qsort()函数：

对较大型的数组而言，“快速排序”方法是最有效的排序算法之一。该算法由C.A.R.Hoare于1962年开发。它把数组不断分成更小的数组，直到变成单元素数组。首先，把数组分成两部分，一部分的值都小于另一部分的值。这个过程一直持续到数组完全排序好为止。

快速排序算法在C实现中的名称是qsort()。qsort()函数排序数组的数据对象，其原型如下：

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

第1个参数是指针，指向待排序数组的首元素。ANSI C允许把指向任何数据类型的指针强制转换成指向void的指针，因此，qsort()的第1个实际参数可以引用任何类型的数组。

第2个参数是待排序项的数量。函数原型把该值转换为size_t类型。前面提到过，size_t定义在标准头文件中，是sizeof运算符返回的整数类型。

由于qsort()把第1个参数转换为void指针，所以qsort()不知道数组中每个元素的大小。为此，函数原型用第 3 个参数补偿这一信息，显式指明待排序数组中每个元素的大小。例如，如果排序 double类型的数组，那么第3个参数应该是sizeof(double)。

最后，qsort()还需要一个指向函数的指针，这个被指针指向的比较函数用于确定排序的顺序。该函数应接受两个参数：分别指向待比较两项的指针。如果第1项的值大于第2项，比较函数则返回正数；如果两项相同，则返回0；如果第1项的值小于第2项，则返回负数。qsort()根据给定的其他信息计算出两个指针的值，然后把它们传递给比较函数。

qsort()原型中的第4个函数确定了比较函数的形式：

int (*compar)(const void *, const void *)

这表明 qsort()最后一个参数是一个指向函数的指针，该函数返回 int 类型的值且接受两个指向const void的指针作为参数，这两个指针指向待比较项。

/* 用 qsort()排序一组数字 */
#include <stdio.h>
#include <stdlib.h>
#define NUM 40
void fillarray(double ar[], int n);
void showarray(const double ar[], int n);
int mycomp(const void *p1, const void *p2);
int main(void) {
	double vals[NUM];
	fillarray(vals, NUM);
	puts("Random list:");
	showarray(vals, NUM);
	qsort(vals, NUM, sizeof(double), mycomp);
	puts("\nSorted list:");
	showarray(vals, NUM);
	return 0;
}
void fillarray(double ar[], int n) {
	int index;
	for (index = 0; index < n; index++)
		ar[index] = (double) rand() / ((double) rand() + 0.1);
}
void showarray(const double ar[], int n) {
	int index;
	for (index = 0; index < n; index++) {
		printf("%9.4f ", ar[index]);
		if (index % 6 == 5)
			putchar('\n');
	}
	if (index % 6 != 0)
		putchar('\n');
}
/* 按从小到大的顺序排序 */
int mycomp(const void *p1, const void *p2) {
	/* 要使用指向double的指针来访问这两个值 */
	const double *a1 = (const double*) p1;
	const double *a2 = (const double*) p2;
	if (*a1 < *a2)
		return -1;
	else if (*a1 == *a2)
		return 0;
	else
		return 1;
}

Random list:
0.0001　 1.6475　 2.4332　 0.0693　 0.7268　 0.7383
24.0357　0.1009　 87.1828　5.7361　 0.6079　 0.6330
1.6058　 0.1406　 0.5933　 1.1943　 5.5295　 2.2426
0.8364　 2.7127　 0.2514　 0.9593　 8.9635　 0.7139
0.6249　 1.6044　 0.8649　 2.1577　 0.5420　 15.0123
1.7931　 1.6183　 1.9973　 2.9333　 12.8512　1.3034
0.3032　 1.1406　 18.7880　0.9887
Sorted list:
0.0001　 0.0693　 0.1009　 0.1406　 0.2514　 0.3032
0.5420　 0.5933　 0.6079　 0.6249　 0.6330　 0.7139
0.7268　 0.7383　 0.8364　 0.8649　 0.9593　　0.9887
1.1406　 1.1943　 1.3034　 1.6044　 1.6058　 1.6183
1.6475　 1.7931　 1.9973　 2.1577　 2.2426　 2.4332
2.7127　 2.9333　 5.5295　 5.7361　 8.9635　 12.8512
15.0123　18.7880　24.0357　87.1828

断言库：

assert.h 头文件支持的断言库是一个用于辅助调试程序的小型库。它由assert()宏组成，接受一个整型表达式作为参数。如果表达式求值为假（非零），assert()宏就在标准错误流（stderr）中写入一条错误信息，并调用abort()函数终止程序（abort()函数的原型在stdlib.h头文件中）。assert()宏是为了标识出程序中某些条件为真的关键位置，如果其中的一个具体条件为假，就用 assert()语句终止程序。通常，assert()的参数是一个条件表达式或逻辑表达式。如果 assert()中止了程序，它首先会显示失败的测试、包含测试的文件名和行号。

assert的用法：

/* myassert.c：使用 assert() */
#include <stdio.h>
#include <math.h>
#include <assert.h>
int main() {
    double x, y, z;
    puts("Enter a pair of numbers (0 0 to quit): ");
    while (scanf("%lf%lf", &x, &y) == 2 && (x != 0 || y != 0)) {
        z = x * x - y * y; /* 应该用 + */
        assert(z >= 0);
        printf("answer is %f\n", sqrt(z));
        puts("Next pair of numbers: ");
    }
    puts("Done");
    return 0;
}

Enter a pair of numbers (0 0 to quit):
|4 3
answer is 2.645751
Next pair of numbers:
|5 3
answer is 4.000000
Next pair of numbers:
|3 5
Assertion failed: z >= 0, file D:\workplace\cpp_workplace\MyHello\myassert.c, line 10

使用 assert()有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭 assert()的机制。如果认为已经排除了程序的 bug，就可以把下面的宏定义写在包含assert.h的位置前面：

#define NDEBUG

 并重新编译程序，这样编译器就会禁用文件中的所有 assert()语句。如果程序又出现问题，可以移除这条#define指令（或者把它注释掉），然后重新编译程序，这样就重新启用了assert()语句。

_Static_assert（C11）：

assert()表达式是在运行时进行检查。C11新增了一个特性：_Static_assert声明，可以在编译时检查assert()表达式。因此，assert()可以导致正在运行的程序中止，而_Static_assert()可以导致程序无法通过编译。_Static_assert()接受两个参数。第1个参数是整型常量表达式，第2个参数是一个字符串。如果第 1 个表达式求值为 0（或_False），编译器会显示字符串，而且不编译该程序。

/* statasrt.c */
#include <stdio.h>
#include <limits.h>
_Static_assert(CHAR_BIT == 16, "16-bit char falsely assumed");
int main(void) {
    puts("char is 16 bits.");
    return 0;
}

$ clang statasrt.c
statasrt.c:4:1: error: static_assert failed "16-bit char falsely assumed"
_Static_assert(CHAR_BIT == 16, "16-bit char falsely assumed");
^　　　　　　　 ～～～～～～～～～～～～～～
1 error generated.
$

根据语法，_Static_assert()被视为声明。因此，它可以出现在函数中，或者在这种情况下出现在函数的外部。

_Static_assert要求它的第1个参数是整型常量表达式，这保证了能在编译期求值。

当然，可以在程序清单的main()函数中使用assert(CHAR_BIT == 16)，但这会在编译和运行程序后才生成一条错误信息，很没效率。

string.h库中的memcpy()和memmove()：

不能把一个数组赋给另一个数组，所以要通过循环把数组中的每个元素赋给另一个数组相应的元素。有一个例外的情况是：使用strcpy()和strncpy()函数来处理字符数组。memcpy()和memmove()函数提供类似的方法处理任意类型的数组。下面是这两个函数的原型：

void *memcpy(void * restrict s1, const void * restrict s2, size_t n);
void *memmove(void *s1, const void *s2, size_t n);

这两个函数都从 s2 指向的位置拷贝 n 字节到 s1 指向的位置，而且都返回 s1 的值。所不同的是， memcpy()的参数带关键字restrict，即memcpy()假设两个内存区域之间没有重叠；而memmove()不作这样的假设，所以拷贝过程类似于先把所有字节拷贝到一个临时缓冲区，然后再拷贝到最终目的地。如果使用 memcpy()时，两区域出现重叠会怎样？其行为是未定义的，这意味着该函数可能正常工作，也可能失败。编译器不会在本不该使用memcpy()时禁止你使用，作为程序员，在使用该函数时有责任确保两个区域不重叠。

由于这两个函数设计用于处理任何数据类型，所有它们的参数都是两个指向 void 的指针。C 允许把任何类型的指针赋给void *类型的指针。如此宽容导致函数无法知道待拷贝数据的类型。因此，这两个函数使用第 3 个参数指明待拷贝的字节数。注意，对数组而言，字节数一般与元素个数不同。如果要拷贝数组中10个double类型的元素，要使用10*sizeof(double)，而不是10。

下面程序清单中的程序使用了这两个函数。该程序假设double类型是int类型的两倍大小。另外，该程序还使用了C11的_Static_assert特性测试断言。

// 使用 memcpy() 和 memmove()
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define SIZE 10
void show_array(const int ar[], int n);
// 如果编译器不支持C11的_Static_assert，可以注释掉下面这行
_Static_assert(sizeof(double) == 2 * sizeof(int), "double not twice int size");
int main() {
	int values[SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int target[SIZE];
	double curious[SIZE / 2] = { 2.0, 2.0e5, 2.0e10, 2.0e20, 5.0e30 };
	puts("memcpy() used:");
	puts("values (original data): ");
	show_array(values, SIZE);
	memcpy(target, values, SIZE * sizeof(int));
	puts("target (copy of values):");
	show_array(target, SIZE);
	puts("\nUsing memmove() with overlapping ranges:");
	memmove(values + 2, values, 5 * sizeof(int));
	puts("values -- elements 0-4 copied to 2-6:");
	show_array(values, SIZE);
	puts("\nUsing memcpy() to copy double to int:");
	memcpy(target, curious, (SIZE / 2) * sizeof(double));
	puts("target -- 5 doubles into 10 int positions:");
	show_array(target, SIZE / 2);
	show_array(target + 5, SIZE / 2);
	return 0;
}
void show_array(const int ar[], int n) {
	int i;
	for (i = 0; i < n; i++)
		printf("%d ", ar[i]);
	putchar('\n');
}

memcpy() used:
values (original data):
1 2 3 4 5 6 7 8 9 10
target (copy of values):
1 2 3 4 5 6 7 8 9 10
Using memmove() with overlapping ranges:
values -- elements 0-4 copied to 2-6:
1 2 1 2 3 4 5 8 9 10
Using memcpy() to copy double to int:
target -- 5 doubles into 10 int positions:
0 1073741824 0 1091070464 536870912
1108516959 2025163840 1143320349 -2012696540 1179618799

程序中最后一次调用 memcpy()从 double 类型数组中把数据拷贝到 int 类型数组中，这演示了memcpy()函数不知道也不关心数据的类型，它只负责从一个位置把一些字节拷贝到另一个位置（例如，从结构中拷贝数据到字符数组中）。而且，拷贝过程中也不会进行数据转换。如果用循环对数组中的每个元素赋值，double类型的值会在赋值过程被转换为int类型的值。这种情况下，按原样拷贝字节，然后程序把这些位组合解释成int类型。

可变参数：stdarg.h

本章前面提到过变参宏，即该宏可以接受可变数量的参数。stdarg.h 头文件为函数提供了一个类似的功能，但是用法比较复杂。必须按如下步骤进行：

1.提供一个使用省略号的函数原型：void f(int lim, ...);

2.在函数定义中创建一个va_list类型的变量：va_list arglist;

3.用宏把该变量初始化为一个参数列表：va_start(arglist, lim);

4.用宏访问参数列表：sometype arg = va_arg(arglist, sometype)；

5.用宏完成清理工作：va_end(arglist);

void f1(int n, ...);　　　　　　　　   // 有效
int f2(const char * s, int k, ...); // 有效
char f3(char c1, ..., char c2);     // 无效，省略号不在最后
double f3(...);　　　　　　　　　　    // 无效，没有形参

最右边的形参（即省略号的前一个形参）起着特殊的作用，标准中用parmN这个术语来描述该形参。在上面的例子中，第1行f1()中parmN为n，第2行f2()中parmN为k。传递给该形参的实际参数是省略号部分代表的参数数量。

例如，可以这样使用前面声明的f1()函数：

f1(2, 200, 400);　　　　　// 2个额外的参数
f1(4, 13, 117, 18, 23); // 4个额外的参数

接下来，声明在stdarg.h中的va_list类型代表一种用于储存形参对应的形参列表中省略号部分的数据对象。变参函数的定义起始部分类似下面这样：

double sum(int lim,...) {
    va_list ap;　 //声明一个储存参数的对象

在该例中，lim是parmN形参，它表明变参列表中参数的数量。

然后，该函数将使用定义在stdarg.h中的va_start()宏，把参数列表拷贝到va_list类型的变量中。该宏有两个参数：va_list类型的变量和parmN形参。接着上面的例子讨论，va_list类型的变量是ap，parmN形参是lim。所以，应这样调用它：

va_start(ap, lim); // 把ap初始化为参数列表

下一步是访问参数列表的内容，这涉及使用另一个宏va_arg()。该宏接受两个参数：一个va_list类型的变量和一个类型名。第1次调用va_arg()时，它返回参数列表的第1项；第2次调用时返回第2项，以此类推。表示类型的参数指定了返回值的类型。例如，如果参数列表中的第1个参数是double类型，第2个参数是int类型，可以这样做：

double tic;
int toc;
...
tic = va_arg(ap, double);　// 检索第1个参数
toc = va_arg(ap, int);　　 //检索第2个参数

注意，传入的参数类型必须与宏参数的类型相匹配。如果第1个参数是10.0，上面tic那行代码可以正常工作。但是如果参数是10，这行代码可能会出错。这里不会像赋值那样把double类型自动转换成int类型。

最后，要使用va_end()宏完成清理工作。例如，释放动态分配用于储存参数的内存。该宏接受一个va_list类型的变量：

va_end(ap); // 清理工作

调用va_end(ap)后，只有用va_start重新初始化ap后，才能使用变量ap。

因为va_arg()不提供退回之前参数的方法，所以有必要保存va_list类型变量的副本。C99新增了一个宏用于处理这种情况：va_copy()。该宏接受两个va_list类型的变量作为参数，它把第2个参数拷贝给第1个参数：

va_list ap;
va_list apcopy;
double tic;
int toc;
...
va_start(ap, lim);　　　　  // 把ap初始化为一个参数列表
va_copy(apcopy, ap);　　　  // 把apcopy作为ap的副本
tic = va_arg(ap, double);　// 检索第1个参数
toc = va_arg(ap, int);　　 // 检索第2个参数

此时，即使删除了ap，也可以从apcopy中检索两个参数。

// use variable number of arguments
#include <stdio.h>
#include <stdarg.h>
double sum(int, ...);
int main(void) {
	double s, t;
	s = sum(3, 1.1, 2.5, 13.3);
	t = sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1);
	printf("return value for "
			"sum(3, 1.1, 2.5, 13.3):　　　　　　　%g\n", s);
	printf("return value for "
			"sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1): %g\n", t);
	return 0;
}
double sum(int lim, ...) {
	va_list ap; // 声明一个对象储存参数
	double tot = 0;
	int i;
	va_start(ap, lim); // 把ap初始化为参数列表
	for (i = 0; i < lim; i++)
	    tot += va_arg(ap, double);// 访问参数列表中的每一项
	va_end(ap); // 清理工作
	return tot;
}

return value for sum(3, 1.1, 2.5, 13.3):　　　　　　　　　16.9
return value for sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1):　 31.6

第1次调用sum()时对3个数求和，第2次调用时对6个数求和。

总而言之，使用变参函数比使用变参宏更复杂，但是函数的应用范围更广。

关键概念：

C标准不仅描述C语言，还描述了组成C语言的软件包、C预处理器和C标准库。通过预处理器可以控制编译过程、列出要替换的内容、指明要编译的代码行和影响编译器其他方面的行为。C库扩展了C语言的作用范围，为许多编程问题提供现成的解决方案。