23. C语言标准库函数（上）

1. assert

assert.h头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行，这个宏常常被称为“断言”。

assert(PI > 3);

上面代码在程序运行到这一行语句时，验证变量PI是否大于3，如果确实大于3，程序继续运行，否则就会终止运行，并且给出报错信息提示。

assert()宏接受一个表达式作为参数，如果该表达式为真（返回值非零），assert()不会产生任何作用，程序继续运行。

如果该表达式为假（返回值为零），assert()就会报错，在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。

最后，调用abort()函数终止程序（abort()函数的原型在stdlib.h头文件中）。

z = x * x - y * y;
assert(z >= 0);

上面的assert()语句类似于下面的代码：

if (z < 0) {
  puts("z less than 0");
  abort();
}

如果断言失败，程序会中断执行，会显示下面的提示：

Assertion failed: (z >= 0), function main, file /Users/assert.c, line 14.

上面报错的格式如下：

Assertion failed: [expression], function [abc], file [xyz], line [nnn].

上面代码中，方括号的部分使用实际数据替换掉。

使用assert()有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭assert()的机制。

如果已经确认程序没有问题，不需要再做断言，就在#include <assert.h>语句的前面，定义一个宏NDEBUG。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的assert()语句。

如果程序又出现问题，可以移除这条#define NDBUG指令（或者把它注释掉），再次编译，这样就重新启用了assert()语句。

assert()的缺点是，因为引入了额外的检查，增加了程序的运行时间。

C11 引入了静态断言static_assert()，用于在编译阶段进行断言判断。

static_assert(constant-expression, string-literal);

static_assert()接受两个参数，第一个参数constant-expression是一个常量表达式，第二个参数string-literal是一个提示字符串。

如果第一个参数的值为false，会产生一条编译错误，第二个参数就是错误提示信息：

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()不会生成可执行代码，所以不会造成任何运行时的性能损失。

2.ctype

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()：如果参数是小写字符，返回大写字符，否则返回原始参数。

// 将字符转为大写
ch = toupper(ch);

注意，这两个函数不会改变原始字符。

3.error

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 比较，用来确定到底发生了哪一类错误。

4.float

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

（13）科学计数法的指数部分的十进制最大次幂

• FLT_MAX_10_EXP
• DBL_MAX_10_EXP
• LDBL_MAX_10_EXP

5.inttypes

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

6.iso646

iso646.h头文件指定了一些常见运算符的替代拼写，比如，它用关键字and代替逻辑运算符&&：

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 替代 ^=

7.limits

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 的数：

#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。

8.locale

locale.h是程序的本地化设置，主要影响以下的行为。

• 数字格式
• 货币格式
• 字符集
• 日期和时间格式

它设置了以下几个宏。

• LC_COLLATE：影响字符串比较函数strcoll()和strxfrm()。
• LC_CTYPE：影响字符处理函数的行为。
• LC_MONETARY：影响货币格式。
• LC_NUMERIC：影响printf()的数字格式。
• LC_TIME：影响时间格式strftime()和wcsftime()。
• LC_ALL：将以上所有类别设置为给定的语言环境。

setlocale()用来设置当前的地区：

char* setlocale(int category, const char* locale);

它接受两个参数。第一个参数表示影响范围，如果值为前面五个表示类别的宏之一，则只影响该宏对应的类别，如果值为LC_ALL，则影响所有类别。

第二个参数通常只为"C"（正常模式）或""（本地模式）。

任意程序开始时，都隐含下面的调用：

setlocale(LC_ALL, "C");

下面的语句将格式本地化：

setlocale(LC_ALL, "");

上面示例中，第二个参数为空字符，表示使用当前环境提供的本地化设置。

理论上，第二个参数也可以设为当前系统支持的某种格式：

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()用来获取当前格式的详细信息：

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;
}

9.math

math.h头文件提供了很多数学函数。

很多数学函数的返回值是 double 类型，但是同时提供 float 类型与 long double 类型的版本，比如pow()函数就还有powf()和powl()版本：

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_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()判断参数是否带有符号。如果参数为负值，则返回1，否则返回0：

signbit(3490.0) // 0
signbit(-37.0)  // 1

以下是三角函数，参数为弧度值。

• acos()：反余弦。
• asin()：反正弦。
• atan()：反正切
• atan2()：反正切。
• cos()：余弦。
• sin()：正弦。
• tan()：正切。

不要忘了，上面所有函数都有 float 版本（函数名加上 f 后缀）和 long double 版本（函数名加上 l 后缀）。

下面是一个例子：

cos(PI/4) // 0.707107

以下是双曲函数，参数都为浮点数。

• acosh()：反双曲余弦。
• asinh()：反双曲正弦。
• atanh()：反双曲正切。
• cosh()：双曲余弦。
• tanh()：双曲正切。
• sinh()：双曲正弦。

以下是指数函数和对数函数，它们的返回值都是 double 类型。

• exp()：计算欧拉数 e 的乘方，即 ex。
• exp2()：计算 2 的乘方，即 2x。
• expm1()：计算 ex - 1。
• log()：计算自然对数，exp()的逆运算。
• log2()：计算以2为底的对数。
• log10()：计算以10为底的对数。
• logp1()：计算一个数加 1 的自然对数，即ln(x + 1)。
• logb()：计算以宏FLT_RADIX（一般为2）为底的对数，但只返回整数部分。

下面是一些例子：

exp(3.0) // 20.085500
log(20.0855) // 3.000000
log10(10000) // 3.000000

如果结果值超出了 C 语言可以表示的最大值，函数将返回HUGE_VAL，它是一个在math.h中定义的 double 类型的值。

如果结果值太小，无法用 double 值表示，函数将返回0。以上这两种情况都属于出错。

frexp()将参数分解成浮点数和指数部分（2为底数），比如 1234.56 可以写成 0.6028125 * 211，这个函数就能分解出 0.6028125 和 11。

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()返回一个浮点数的指数部分，指数的基数是宏FLT_RADIX（一般是2）。

int ilogb(double x);

它的参数为x，返回值是 logr|x|，其中r为宏FLT_RADIX。

下面是用法示例：

ilogb(257) // 8
ilogb(256) // 8
ilogb(255) // 7

ldexp()将一个数乘以2的乘方。它可以看成是frexp()的逆运算，将小数部分和指数部分合成一个f * 2^n形式的浮点数：

double ldexp(double x, int exp);

它接受两个参数，第一个参数是乘数x，第二个参数是2的指数部分exp，返回“x * 2exp”：

ldexp(1, 10) // 1024.000000
ldexp(3, 2) // 12.000000
ldexp(0.75, 4) // 12.000000
ldexp(0.5, -1) // 0.250000

modf()函数提取一个数的整数部分和小数部分：

 double modf(double value, double* iptr);

它接受两个参数，第一个参数value表示待分解的数值，第二个参数是浮点数变量iptr。返回值是value的小数部分，整数部分放入变量double，例如：

// int_part 的值是 3.0
modf(3.14159, &int_part); // 返回 0.14159

scalbn()用来计算“x * rn”，其中r是宏FLT_RADIX。

double scalbn(double x, int n);

它接受两个参数，第一个参数x是乘数部分，第二个参数n是指数部分，返回值是“x * rn”，例如：

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()函数以传统方式进行四舍五入，比如1.5舍入到2，-1.5舍入到-2。

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()用来截去一个浮点数的小数部分，将剩下的整数部分以浮点数的形式返回。

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()返回不小于其参数的最小整数（double 类型），属于“向上舍入”。

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()返回不大于其参数的最大整数，属于“向下舍入”。

double floor(double x);

用法如下：

floor(7.1) // 7.0
floor(7.9) // 7.0
floor(-7.1) // -8.0
floor(-7.9) // -8.0

下面的函数可以实现“四舍五入”：

double round_nearest(double x) {
  return x < 0.0 ? ceil(x - 0.5) : floor(x + 0.5);
}

fmod()返回第一个参数除以第二个参数的余数，就是余值运算符%的浮点数版本，因为%只能用于整数运算：

double fmod(double x, double y);

它在幕后执行的计算是x - trunc(x / y) * y，返回值的符号与x的符号相同：

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()返回两个参数之中，是否存在 NAN。

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

10.signal

signal.h提供了信号（即异常情况）的处理工具。所谓“信号”（signal），可以理解成系统与程序之间的短消息，主要用来表示运行时错误，或者发生了异常事件。

头文件signal.h定义了一系列宏，表示不同的信号。

• SIGABRT：异常中止（可能由于调用了 abort() 方法）。
• SIGFPE：算术运算发生了错误（可能是除以 0 或者溢出）。
• SIGILL：无效指令。
• SIGINT：中断。
• SIGSEGV：无效内存访问。
• SIGTERM：终止请求。

上面每个宏的值都是一个正整数常量。

头文件signal.h还定义了一个signal()函数，用来指定某种信号的处理函数：

signal(SIGINT, handler);

signal()接受两个参数，第一个参数是某种信号的宏，第二个参数是处理这个信号的函数指针handler。

信号处理函数handler接受一个 int 类型的参数，表示信号类型，它的原型如下：

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 表示默认的处理函数：

signal(SIGINT, SIG_DFL);

上面示例中，SIGINT 的处理函数是默认处理函数，由当前实现决定。

（2）SIG_IGN

SIG_IGN 表示忽略该信号：

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()函数用来在程序中发出信号：

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 函数执行。