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的值通常是两个宏:EDOMERANGE

这两个宏都定义在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,可以用8163264代入。

下面是用法示例:

#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():计算参数xy次方。
  • sqrt():计算一个数的平方根。
  • cbrt():计算立方根。
  • fabs():计算绝对值。
  • hypot():根据直角三角形的两条直角边,计算斜边。
  • fmax():返回两个参数之中的最大值。
  • fmin():返回两个参数之中的最小值。
  • remainder():返回 IEC 60559 标准的余数,类似于fmod(),但是余数范围是从-y/2y/2,而不是从0y
  • 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 函数执行。

作者:余识
全部文章:0
会员文章:0
总阅读量:0
c/c++pythonrustJavaScriptwindowslinux