[C++知识库] C语言标准库深度整理

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C语言标准库深度整理 -> 正文阅读

[C++知识库]C语言标准库深度整理

引言

C语言标准库是一组内置的函数、常量，被定义在15个头文件中，提供了C语言中最基础的功能

stdio.h 即标准输入输出，同时涵盖了文件读写的全部过程。

所谓标准输入输出，直观一点就是键盘和显示屏：键盘将标准输入传递给终端，终端将内容打印在显示屏上。关于这种基于字符串的人机交互，stdio.h主要提供了两组函数，一组是get和put，另一组是print和scan。

操作一个文件的流程大致为：从fopen打开文件，到fread, fwrite读写文件，再到fflush强制写入缓存，最后fclose关闭文件；如需精确定位文件的字节位置，可通过fseek或fgetpos。

stdlib.h 即是standard library，标准库中无法归入其他类别的统统放到这里，主要分为四个部分：内存、系统、字符串转数值和数学算法。

string.h：提供字符串的查询、比较、复制等功能

ctype.h：用于数据类型判断

math.h：提供最基础的数学运算

时间与货币：C标准库提供了针对不同国家的本地化头函数，具体表现在时间和货币上。C标准库对不同地区的时间和货币的表达形式进行了本地化的描述，分别封装在time.h和locale.h中。

单功能库 有很多库十分简单，故统一归类到单一功能库下，包括

stdarg.h：可变参数支持
assert.h：用于报错
stddef.h：指针相减
setjmp.h：跳转

常量库 有的标准库只定义了一些宏，单并未声明函数，故将这类库统一归类到常量库中。

系统错误码errno.h
信号signal.h
浮点型限制信息float.h
整型限制信息limits.h

stdio.h

std是标准的，io即输入输出，合起来stdio就是标准输入输出。

常量和指针

`#define`	功能	操作系统默认
`EOF (-1)`	文件结束符
`BUFSIZ 1024`	`setbuf`函数缓冲区字节数	`__BUFSIZ__`
`FOPEN_MAX 20`	系统可同时打开的文件数量	`__FOPEN_MAX__`
`FILENAME_MAX 1024`	文件名最大长度	`__FILENAME_MAX__`
`L_tmpnam FILENAME_MAX`	`tmpnam`创建的临时文件名的最大长度	`__L_tmpnam__`
`TMP_MAX 26`	`tmpnam`可生成最多独立文件名

stdio.h中定义了三个FILE类型的指针，

#define	stdin	(_REENT->_stdin)
#define	stdout	(_REENT->_stdout)
#define	stderr	(_REENT->_stderr)

其中，_REENT在reent.h由_impure_ptr定义，而_impure_ptr则为_reent的指针。

在_reent中定义了三个FILE型的指针__FILE *_stdin, *_stdout, *_stderr;，分别代表标准输入、标准输出和标准错误。

打开文件

fopen和freopen均为C语言标准库stdio.h中的函数，分别用于打开和重新打开某个stream，二者均返回一个FILE指针。

FILE *fopen(const char *filename, const char *mode)
FILE *freopen(const char *filename, const char *mode, FILE *stream)

其中filename为文件路径，mode为文件打开模式，freopen中输入的的stream为现存的流，freopen将新打开的文件注入stream中，同时关闭旧文件。

其中mode的取值如下，第一列为常规模式，第二列为二进制模式，在二进制模式下，读取的是二进制文件，其他与常规模式相同。

mode		模式	说明
“r”	“rb”	只读	打开的文件必须存在。
“w”	“wb”	写入	创建空文件，若文件已存在，会删除原有内容。
“a”	“ab”	追加	向文件末尾追加数据，若文件不存在，则创建文件。
“r+”	“rb+”	更新	打开一个文件进行读写，该文件必须存在。
“w+”	“wb+”	读写	创建一个用于读写的空文件。
“a+”	“ab+”		打开一个用于读取和追加的文件

fopen和freopen的返回值为FILE指针，刚好可以通过stdio.h中的close进行关闭。

stdio.h中定义了三个单参函数用以调控文件的写入，其输入均为FILE *stream，若成功则返回1，失败则返回0。

返回类型	函数	功能
`int`	`fclose`	关闭stream，刷新缓冲区
`int`	`fflush`	刷新stream的输出缓冲区
`int`	`ferror`	测试stream的错误标识符

如果在没有完成写入的情况下调用close，可能会致使数据丢失，故stdio.h中提供了fflush函数，用于强制将缓冲区的内容写入文件。而fclose则综合了二者的功能，先flush，再close。

FILE结构体

FILE是C语言标准库stdio.h中定义的一个结构体，用于数据缓存，一般写为

//stdio.h
typedef struct _iobuf
{
    char*  _ptr;        //文件输入的下一个位置
    int    _cnt;        //当前缓冲区的相对位置
    char*  _base;       //文件初始位置
    int    _flag;       //文件标志
    int    _file;       //文件有效性
    int    _charbuf;    //缓冲区是否可读取
    int    _bufsiz;     //缓冲区字节数
    char*  _tmpfname;   //临时文件名
} FILE;

其中，_bufsiz为缓冲区字节数，一般由宏来定义

#define BUFSIZ 1024

临时文件名_tmpfname可通过函数tmpnam进行设置，或者通过tmpfile创建二进制文件。

为了理解这些字段的含义，可以写一个小例子

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

//这个函数用来打印FILE内部的字段
void printFILE(FILE *fp){
    printf("fp->_ptr=%s\n",fp->_ptr);
    printf("fp->_cnt=%d\n",fp->_cnt);
    printf("fp->_base=%s\n",fp->_base);
    printf("fp->_flag=%d\n",fp->_flag);
    printf("fp->_file=%d\n",fp->_file);
    printf("fp->_charbuf=%d\n",fp->_charbuf);
    printf("fp->_bufsiz=%d\n",fp->_bufsiz);
    printf("fp->_tmpfname=%s\n",fp->_tmpfname);
    printf("-------------------------------------");
    printf("-------------------------------------\n");
}

int main(){
    FILE* fp = fopen("test.c","r"); //打开test.c文件，即本文件
    printFILE(fp);

    char buf[20];
    fread(buf,1,5,fp);      //读取fp中的数据
    printFILE(fp);

    fclose(fp);             //关闭fp
    printFILE(fp);
    return 0;
}

得到其输出如下，为了便于阅读，用//和/**/对输出进行注释

>gcc test.c
>a.exe
fp->_ptr=(null)     //打开文件后，由于未作操作，故该指针为空
fp->_cnt=0          //当前缓冲区相对位置为0
fp->_base=(null)    //文件初始位置也是一个空指针
fp->_flag=1         
fp->_file=3         
fp->_charbuf=0      //缓冲区文件
fp->_bufsiz=0       //缓冲区是空的
fp->_tmpfname=(null)   
--------------------------------------------------------------------------
// 下面的输出是在执行fread之后，
// 由于读取了5个字节，所以指针跳过了#incl
fp->_ptr=ude<stdio.h>

void printFILE(FILE *fp){
    /*
    这一段将test.c中的内容原封不动地打印了出来
    因为太长，所以省略不写了
    */
    printFILE(fp);
    return 0;
}
LE(fp);
    return 0;
}

fp->_cnt=665        #当前缓冲区的相对位置是65
fp->_base=#include<stdio.h>     #指向文件初始位置的指针

void printFILE(FILE *fp){
    /*
    这一段将test.c中的内容原封不动地打印了出来
    因为太长，所以省略不写了
    */
    printFILE(fp);
    return 0;
}
LE(fp);
    return 0;
}

fp->_flag=9
fp->_file=3
fp->_charbuf=0
fp->_bufsiz=4096        //缓冲区尺寸为4096
fp->_tmpfname=(null)    //并没有临时名字
--------------------------------------------------------------------------
// 关闭文件后，一切又变得未知，但缓冲区尺寸并未变化
fp->_ptr=(null)
fp->_cnt=0
fp->_base=(null)
fp->_flag=0
fp->_file=3
fp->_charbuf=0
fp->_bufsiz=4096
fp->_tmpfname=(null)
--------------------------------------------------------------------------

在上面的输出中，_flag值在打开文件后为1，读取文件后变为9，关闭文件后变为0.

_file则一直为3。

在stdio.h中定义了一系列常量用于描述文件流的状态

#define __SLBF  0x0001   /* 行缓冲 */
#define __SNBF  0x0002   /* 无缓冲 */
#define __SRD   0x0004   /* 可读 */
#define __SWR   0x0008   /* 可写 */
#define __SRW   0x0010   /* 可读写 */
#define __SEOF  0x0020   /* 发现 EOF */
#define __SERR  0x0040   /* 发现 error */
#define __SMBF  0x0080   /* _buf来自内存(malloc) */
#define __SAPP  0x0100   /* fdopen()ed in append mode */
#define __SSTR  0x0200   /* 是一个sprintf/snprintf字符串 */
#define __SOPT  0x0400   /* 进行fseek()优化 */
#define __SNPT  0x0800   /* 不进行fseek()优化 */
#define __SOFF  0x1000   /* set iff _offset is in fact correct */
#define __SMOD  0x2000   /* true => fgetln modified _p text */
#define __SALC  0x4000   /* 动态分配字符串内存*/
#define __SIGN  0x8000   /* 在_fwalk是忽略本文件*/

_flag的值为1，表示启用行缓冲；为9，则是__SLBF | __SWR，说明可写。

文件读写和定位

在stdio.h中定义了读、写还有查找的函数，其中fread用于将文件中的数据写入内存；fwrite将内存中的数据写入文件；fseek则操作文件指针，使之偏移，从而可以更加灵活地读取。

读：size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
写：size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
移：int fseek(FILE *stream, long int offset, int whence)

其中，ptr为指向某个内存块的指针；stream为文件的数据流；nmemb为元素个数，size为每个元素的字节数；whence为添加偏移的位置，offset为相对于whence的偏移量。

在stdio.h中为whence定义了宏，其含义如下


`#define SEEK_SET 0`	从0开始
`#define SEEK_CUR 1`	从当前位置开始
`#define SEEK_END 2`	从EOF开始

读写相对来说比较直观，接下来主要测试一下fseek，说明均在注释中。

//test.c
#include<stdio.h>
void printChar(char *buffer, int len){
	for(int i = 1; i < len; i++)
		printf("%c",buffer[i-1]);
	printf("\n-------------------------\n");
}
int main(){
    FILE* fp = fopen("test.c","r"); //打开test.c文件，即本文件

    char buf[20];
    fread(buf,1,20,fp);          //读取fp中的数据
    printf("printf the first 20 bytes:");
    printChar(buf,20);

    fseek(fp, 24, SEEK_CUR);    //从当前位置开始偏移
    fread(buf,1,20,fp);
    printf("fseek 24 from now:");
    printChar(buf,20);

    fseek(fp, 24, SEEK_SET);    //从0开始偏移
    fread(buf,1,20,fp);
    printf("fseek 24 from 0:");
    printChar(buf,20);

    fseek(fp, -20, SEEK_END);    //从结束位置向前偏移
    fread(buf,1,20,fp);
    printf("fseek 20 from END:"); 
    printChar(buf,20);

    fclose(fp);         //关闭fp
    return 0;
}

输出结果为

>gcc test.c

E:\Documents\00\1217>a.exe
printf the first 20 bytes://test.c
#include<s
-------------------------
fseek 24 from now:har *buffer, int le
-------------------------
fseek 24 from 0:.h>
void printChar(
-------------------------
fseek 20 from END:
    return 0;
}
r(
-------------------------

文件定位

除了fseek可以对文件指针进行移动之外，fsetpos可以直接对文件指针进行定位。相应地，fgetpos可以获取文件指针的位置，二者声明为：

int fgetpos(FILE *stream, fpos_t *pos)
int fsetpos(FILE *stream, const fpos_t *pos)

二者的返回值均为设置之后的位置，关于输入参数，FILE *stream是大家非常熟悉的文件流，而fpos_t是一个结构体，代表相对位置，通常定义为

typedef struct
{
    unsigned long _off;
}fpos_t;

接下来做一个简单的测试

//pos.c
#include <string.h>
#include <stdio.h>
int main(void)
{
    fpos_t pos;
    FILE* fp = fopen("pos.c", "r"); //打开pos.c文件，即本文件
    fgetpos(fp, &pos);              //获取指针位置
    printf("file pointer : %ld\n", pos);
    
    fseek(fp,10,0);         // 移动指针位置
    fgetpos(fp, &pos);      // 获取指针位置并存入&pos所指向的对象
    printf("file pointer : %ld\n", pos);
    fclose(fp);
    return 0;
}

结果如下，可见getpos和fseek的单位是一致的，fseek移动了10个字节，则fgetpos也获取了位置10.

>gcc pos.c
>a.exe
file pointer : 0
file pointer : 10

结合fgetpos和fsetpos，可完成类似fseek的操作

//setpos.c
#include <string.h>
#include <stdio.h>
int main(void)
{
    fpos_t pos;
    FILE* fp = fopen("pos.c", "r");   //打开pos.c文件，即本文件
    printf("file pointer : %ld\n", fgetpos(fp, &pos));
    
    pos += 10;
    fsetpos(fp, &pos);      //设置指针位置
    printf("file pointer : %ld\n", fgetpos(fp, &pos));
    fclose(fp);
    return 0;
}

测试结果为

>gcc setpos.c
>a.exe
file pointer : 0
file pointer : 10

文件和路径的其他操作

流控制

输入为FILE *stream的单参函数，EOF为文件结束标识符。

返回类型		功能
`void`	`clearerr`	清除stream的文件结束和错误标识符
`int`	`feof`	返回stream的文件结束标识符，若未设置，则返回0
`long int`	`ftell`	返回stream的文件位置，如果发生错误，则返回-1L，全局变量errno被设置为一个正值。
`void`	`rewind`	设置文件位置为stream的开头
`int`	`fgetc` `getc`	从stream获取下一个字符，并把位置标识符往前移动

缓存

在打开文件后还没有做其他操作的时候，可以通过ssetvbuf来设置缓冲格式，其声明为

int setvbuf(FILE *stream, char *buffer, int mode, size_t size)

其中stream为文件流；buffer为分配给用户的缓冲；size为缓冲的字节数；mode为缓冲模式，有三种

宏	值	类别	说明
`_IOFBF`	0	全缓冲	输出时，数据在缓冲填满时被一次性写入输入时，缓冲在请求输入且缓冲为空时被填充。
`_IOLBF`	1	行缓冲	输出时，在换行处或缓冲填满时写入数据输入时，缓冲至下一个换行符
`_IONBF`	2	无缓冲	不使用缓冲。I/O操作即时写入，忽略buffer和size

setbuf是setvbuf的一个特例，其中mode为_IONBF，size为BUFSIZ。

路径操作

stdio.h还提供了两个操作文件的函数，分别是删除文件remove和重命名文件rename，其声明分别为：

int remove(const char *filename)
int rename(const char *old_filename, const char *new_filename)

get和put

get和put有互为反函数的感觉，例如getchar()从标准输入stdin获取一个字符，而putchar(int c)将字符c送到标准输出。

例如

#include <stdio.h>
int main ()
{
   char ch;
   printf("getchar: ");
   ch = getchar();
   printf("putchar: ");
   putchar(ch);
   return 0;
}

测试结果为

>gcc gets.c
>a.exe
getchar: a
putchar: a

为了便于对比阅读，下面令

#define FS FILE *stream
#define IC int char
#define CS char *str
#define CCS const char *str

则与get和put有关的函数如下表所示

get	fget	put	fput
`getchar()`		`putchar(IC)`
`getc(FS)`	`fgetc(FS)`	`putc(IC, FS)`	`fputc(IC, FS)`
`gets(CS)`	`fgets(CS, int n, FS)`	`puts(CCS)`	`fputs(CCS, FS)`
`ungetc(IC, FS)`

其中，除fgets和gets的返回值为字符指针，其余均为整型，getchar()也会将输入的字符转为整型。

所有的get和put函数均用于字符的输入输出，后缀c表示从文件输入或输出到文件，没有c则表示基于标准输入输出流。前缀f表示是否由宏来实现，例如getc通常由宏来实现且经过高度优化，故常作为首选，但目前来说与fgetc在速度相差无几。

ungetc把一个无符号字符推入到指定的流stream中，以便接下来被读取。

接下来做一些简单的示例

//fget.c
#include <stdio.h>
 
int main ()
{
    FILE *fp;
 
    fp = fopen("file.txt", "w+");
    //将字符逐一写入文件
    for(int ch = 50; ch <= 100; ch++)
        fputc(ch, fp);
    fclose(fp);

    //读取刚刚写入的文件
    fp = fopen("file.txt","r");
    while(!feof(fp))
        printf("%c",getc(fp));
    
    fclose(fp);
    return 0;
}

测试为

>gcc fget.c
>a.exe
23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd�

需要注意的是，C11标准中移除了gets函数，代之以gets_s，区别在于后者对输入字符个数进行了限制。然而，虽然C11已经出了10年了，但存在感不是很高的样子。

printf

printf是绝大多数人接触的第一个C语言函数，但绝大多数人对printf的认识也就到了hello world为止了，大部分人甚至看不懂这个函数的声明：

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

关键是字符串格式比较复杂，可以表示为%format[flags][m.n]specifier

例如

#include<stdio.h>
#define PI 3.14159265358979323846264338327950288

int main(){
	printf("%6.2f",PI);
	return 0;
}

其输出为

E:\Documents\00\1110>a.exe
  3.14

其中，%6.2f可分为3部分，6表示输出六个字符；.2表示保留2位小数；f表示输出的是浮点数。由于PI在保留2位小数之后，只有4个字符，所以在3.14左侧补上了空格。

各参数的取值与含义可见于下表，如果觉得不够直观，可直接跳到测试部分。

	`specifier`格式化符号
整数	〖`%d`〗〖`%i`〗〖无符号`%u`〗
无符号不同进制	〖八进制`%o`〗〖十六进制`%x`〗〖大写十六进制`%X`〗
浮点数	〖`%f`〗〖科学计数法`%e`, `%E`〗〖`%g`用`%f`和`%e`中较短的那个〗
字符和字符串	〖字符`%c`〗〖字符串`%s`〗
指针	`%p`输出指针地址

其中，

i, d, o, u, x, X可通过h修饰，从而输出短整型；通过l修饰，从而输出长整型
e, E, f, g, G可通过l修饰，表示长双精度型，但在Windows下可能没什么差别。

`flags`标识	描述
-	左对齐，默认是右对齐
+	强制显示正负号
#	与 o、x、X连用时，非零值前面分别显示0、0x 或 0X 与e、E、f连用时，强制包含小数点与g、G连用时，结果与e、E时相同，但不会移除尾部的零
0	在数字左边补充0

m.n中，m表示输出字符的最小数目，若字符长度短于m，则用空格填充；n表示小数点后的位数。

下面随机抽选一些表达式，列出其输出结果，事先声明一些变量

#define PI 3.14159265358979323846264338327950288
#define IPI 31415926
int main(){
    float fPI = PI;
    double dPI = PI;
    printf("%.10f",fPI);
    return 0;
}

浮点型测试

`printf`	输出	说明
`"%.10f",fPI`	3.1415927410	`float`一般只有6位精度
`"%.10f",dPI`	3.1415926536	`double`可保证15位精度
`"%010.5f",dPI`	0003.14159	5位精度，10个字符，左侧补0
`"%015.5E",dPI*1e5`	0003.14159E+005	width指字符个数
`"%#010.0f",dPI*1e5`	000314159.	`#`强制输出小数点
`"%+f",dPI`	+3.141593	`+`强制输出正号
`"%.2G",dPI`	3.1
`"%.2G",dPI*1e10`	3.1E+010	此时显然E模式更短
`"%010.2G\n%010.4G",dPI`	00000003.1 000003.142	默认右对齐
`"%-010.2G\n%-010.4G",dPI`	3.1 3.142	`-`模式下左对齐，所以0没了

整型测试

`printf`	输出	说明
`%u,IPI`	31415926	作为无符号整型输出
`%+d,IPI`	31415926	`+`模式强制显示正号
`%o,IPI`	167657166	输出为8进制
`%x,IPI`	1df5e76	输出为十六进制
`%#X,IPI`	0X1DF5E76	`#`模式下显示0X

在stdio中，定义了一系列printf函数和scanf函数，通过在前面添加一个字母来表示不同的行为：

输出位置		使用参数列表	读取输入
标准输出(屏幕)	`printf`	`vprintf`	`scanf`
stream	`fprintf`	`vfprintf`	`fscanf`
字符串	`sprintf`	`vsprintf`	`sscanf`

为了便于阅读，下面默认

#define FORMAT const char *format

其printf族函数声明分别为

int fprintf(FILE *stream, FORMAT, ...)
int sprintf(char *str, FORMAT, ...)
int vfprintf(FILE *stream, FORMAT, va_list arg)
int vprintf(FORMAT, va_list arg)
int vsprintf(char *str, FORMAT, va_list arg)
int snprintf(char *str, size_t size, FORMAT, ...)

其中snprintf中的size表示要写入字符的最大数目，超过size会被截断。

scanf族函数声明为

int fscanf(FILE *stream, FORMAT, ...)
int scanf(FORMAT, ...)
int sscanf(cSTR, FORMAT, ...)

stdlib.h

内存分配

最简单的内存分配函数为void *malloc(size_t size)，输入内存字节数，返回指向这篇内存区域的指针，如果创建失败，则返回NULL。

void *calloc(size_t nitems, size_t size)在malloc的基础上对内存空间进行了初始化，令所有字节均置零；此外，还可以分配多块内存，nitems就表示所分配的内存块数。

void *realloc(void *ptr, size_t size)用于重新分配内存，其中ptr是一个指向已经被分配的内存的指针。

最后，通过free可以释放由malloc, calloc, realloc等分配的空间。

系统交互

一般情况下，在C语言中退出一个程序用return，如果在main函数中，return在清理局部对象之后，会调用exit函数。

和return相比，exit并不会销毁局部对象，而是会销毁所有静态与全局对象、清空缓冲区，关闭IO通道。终止前则会调用atexit()所定义的函数。

atexit也在stdlib.h中，其声明式为

int atexit(void (*func)(void))

当程序中止时，就会调用函数指针func。

//atexit.c
#include <stdio.h>
#include <stdlib.h>

void funcA (){
   printf("call from atexit\n");
}

int main (){
   atexit(funcA);   //将funcA注册为中止函数
   printf("exiting...\n");
   return 0;
}

测试结果如下

>gcc atexit.c
>a.exe
exiting...
call from atexit

如果希望什么都不做就退出程序，可以使用abort()，将abort();插入到return 0前面，则其输出结果如下，并不会调用funcA。

>a.exe
exiting...

system函数

system，顾名思义，就是调用系统命令行，其输入为字符串，然后把这个字符串输出给命令行，让命令行执行。

为了测试其特性，可以做一个小程序

//system.c
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

int main(){
	char cmd[100];
	while(1){
		printf("input code: ");
		gets(cmd);
		if(strcmp(cmd,"exit")==0)
			break;  //当输入exit时退出
		system(cmd);
	}
	return 0;
}

然后开始

>gcc system.c
>a.exe
input code: asdfasdf
'asdfasdf' 不是内部或外部命令，也不是可运行的程序
或批处理文件。
input code: date
当前日期: 2021/12/19 周日
输入新日期: (年月日)
input code: date
当前日期: 2021/12/19 周日
输入新日期: (年月日)
input code: HELP
有关某个命令的详细信息，请键入 HELP 命令名
ASSOC          显示或修改文件扩展名关联。
ATTRIB         显示或更改文件属性。
BREAK          设置或清除扩展式 CTRL+C 检查。
BCDEDIT        设置启动数据库中的属性以控制启动加载。
# 由于太长，且和命令行中输入HELP的结果是一样的，所以这里就省略了
有关工具的详细信息，请参阅联机帮助中的命令行参考。
input code: exit        #退出

通过system，可以做一个增强版的命令行。

而除了这些终端提供的命令之外，可能还需要一些自定义的语句，这些语句都被存放在环境变量中，getenv可以获取名字对应的环境变量

char *getenv(const char *name)

例如

#include <stdio.h>
#include <stdlib.h>

int main ()
{
   printf("PATH : %s\n", getenv("PATH"));
   return 0;
}

其运行结果为

E:\Documents\00\1220>a.exe
PATH : C:\Program Files\Microsoft\jdk-11.0.12.7-hotspot\bin;C:\Python310\Scripts\;C:\Python310\;C:\Program Files\Common Files\Oracle\Java\javapath;D:\CS\ImageMagick;(x86)\Common Files\Intel\Shared 
....//因为太多所以后面的就不写了

字符串函数

stdlib中定义了6个将字符串转为数值的函数，分别用于浮点、整型、长整型和无符号长整型，为了书写上的便捷，下文中令

#define cSTR const char *str
#define END char **endptr

其中，str为一个字符串，endptr则为字符串指针，则stdlib.h中的字符串转换函数如下表所示

返回值类型	简单	高级
`double`	`atof(cSTR)`	`strtod(cSTR, END)`
`int`	`atoi(cSTR)`
`long int`	`atol(cSTR)`	`strtol(cSTR, END, int base)`
`unsigned long int`		`strtoul(cSTR, END, int base)`

其中，若endptr不为空，则会保存转换数值之后的指针位置；base介于2和36（包含）之间，表示转换整型的基数。

此外，stdlib中还有4个用于不同宽度的字符数组之间的转化函数，主要是char类型和wchar_t之间的转化。

在C++中，除了char作为字符类型的保留字之外，还有三个不同宽度的字符类型作为表达式：wchar_t, char16_t, char32_t；到了C++11，又新增了char16_t和char32_t。

在C语言中，尽管只有一个char是保留字，单并不妨碍定义其他数据类型，wchar_t被定义在stddef.h中，本质上是一个int。字符串和wchar_t之间的转换函数包括

size_t mbstowcs(wchar_t *pwcs, cSTR, size_t n)：str转为pwcs
size_t wcstombs(char *str, const wchar_t *pwcs, size_t n)：pwcs转为str
int wctomb(char *str, wchar_t wchar)：wchar转为str
int mbtowc(whcar_t *pwc, cSTR, size_t n)：str转为pwc

此外，stdlib.h中还定义了一个计算字符串长度的函数mblen，和string.h中的strlen的区别在于，mblen中多了一个最大字节数的参数n：

int mblen(cSTR, size_t n)

数学函数和算法

stdlib中封装了四个用于整型或长整型的数学函数，包括两个绝对值函数abs和labs，分别用于整型和长整型；两个除法div和ldiv，也是分别用于整型和长整型。

此外，还有一个随机数生成器rand()，将会生成一个范围在 0 到 RAND_MAX 之间的伪随机数。若想指定随机数种子，可使用函数srand(unsigned int seed)。

stdlib中还有两个基本的查找和排序函数，分别是二分查找bsearch、伪快排qsort。

排序

stdlib.h中的排序函数为

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

其中，

base为指向数组第一个元素的指针
nitems为待排序数组中元素个数
size为数组中每个元素的字节数
compar是个函数指针，为用于比较两个元素的函数

其中，用于比较元素的compar符合我们的直觉，可定义为

int cmpInt (const void * a, const void * b);

当其返回值大于0时，表示a>b，等于0时，表示a=b，小于0时表示a<b。

这种函数指针出现在C语言标准库中感觉还是很炫酷的，连带着让qsort也显得高级感十足，下面举个例子来测试一下

//sortList.c
#include <stdio.h>
#include <stdlib.h>

int cmpInt (const void * a, const void * b){
   return (*(int*)a - *(int*)b);
}

void printList(int *lst, int N){
   for(int n = 0 ; n < N; n++ )
      printf("%d ", lst[n]);
    printf("\n");
}

int main(){
    int N = 8;
    int lst[N];
    for(int i=0; i<N; i++)
        lst[i] = rand();
    printf("the original list: ");
    printList(lst, N);
    
    qsort(lst, N, sizeof(int), cmpInt);
    printf("the qSorted list: ");
    printList(lst, N);
    
    return 0;
}

输出结果为

>gcc sortList.c
>a.exe
the original list: 41 18467 6334 26500 19169 15724 11478 29358
the qSorted list: 41 6334 11478 15724 18467 19169 26500 29358

二分查找

所谓二分查找，前提是有一个有序数组。假设这个数组是升序数组，那么先将这个数组从中间分开，变成两份，此之谓二分。然后用中间值和待查元素比较，如果中间值大于待查元素，那么就舍弃大份，用小份和待查元素继续二分查找，知道分完或者找到待查元素。

stdlib.h中的二分查找函数为

void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *))

其中，

key指向要查找的元素
base指向被查数组的第一个对象
nitems为数组中元素个数
size为数组中每个元素的字节数
compar用来比较两个元素的函数，和qsort中相似。

如果key在base数组中，则返回数组中等于key的值的指针，否则返回NULL。

举个例子

//searchList.c
#include <stdio.h>
#include <stdlib.h>

int cmpInt (const void * a, const void * b){
   return (*(int*)a - *(int*)b);
}

void printPos(int* lst, int* pos, int key){
    if(pos == NULL)
        printf("%d is not in lst\n", key);
    else
        printf("Found %d at %d\n", *pos, pos-lst);
}

int main(){
    size_t N = 6;
    int lst[N];
    for(int i=0; i<N; i++)
        lst[i] = rand();
    int *p;

    //对乱序lst中的值进行查找
    printf("----search from unsorted values-----\n");
    for(int i = 0; i<N; i++){
	   p = (int*)bsearch(lst+i, lst, N, sizeof(int), cmpInt);
	   printPos(lst, p, lst[i]);
    }

    //对排序后的list进行查找
    printf("---------search from sorted values---------\n");
    qsort(lst, N, sizeof(int), cmpInt);
    for(int i = 0; i<N; i++){
	   p = (int*)bsearch(lst+i, lst, N, sizeof(int), cmpInt);
	   printPos(lst, p, lst[i]);
    }

    //对不在lst中的值进行查找
    printf("------search rand value ----------\n");
    int rd;
    for(int i = 0; i<3; i++){
        rd = rand();
        p = (int*)bsearch(&rd, lst, N, sizeof(int), cmpInt);
        printPos(lst, p, rd);
    }
   
   return 0;
}

得到其结果为

>gcc test.c
>a.exe
----search from unsorted values-----
Found 41 at 0
18467 is not in lst
Found 6334 at 2
26500 is not in lst
Found 19169 at 4
15724 is not in lst
---------search from sorted values---------
Found 41 at 0
Found 6334 at 1
Found 15724 at 2
Found 18467 at 3
Found 19169 at 4
Found 26500 at 5
------search rand value ----------
11478 is not in lst
29358 is not in lst
26962 is not in lst

必须要注意的一点是，二分查找输入的数组必须是有序的，bsearch只会机械地按照比较函数进行二分，而并没有排序的义务。如果输入是乱序，那么可事先通过qsort进行排序。

string.h

为了看上去规整简洁，令

#define cSTR const char *str
#define vSTR const void *str

由于字符串自身存在终止符\0，所以本节所有提及对字符串前n个字符的操作，均默认n小于字符串长度；若n大于字符串长度，则对字符串整体进行操作。

C语言中的字符串无非是终止于\0的字符数组，但并未提供任何长度信息，所以要有一个函数来计算字符串长度，此即

size_t strlen(cSTR)

然后认识一下用于分割字符串的strtok

char *strtok(char *str, const char *delim)

其功能为通过delim将str分解为一组小字符串，所谓分解，其实就是将分割符号替换为\0；然后返回被分割之后的第一个字符串。

在strtok对字符串分割之后，可通过表达式strtok(NULL, delim)，将被分割后的字符串逐一调出。

//teststrtok.c
#include<stdio.h>
#include<string.h>

int main(){
	char oldStr[50] = "I am tiny cold";
	const char s[2] = " ";
	printf("str length: %d\n", strlen(oldStr));
	char* newStr = strtok(oldStr,s);
	while(newStr != NULL){
		printf("the newStr is 【%s】 with length : %d\n", newStr, strlen(newStr));
		newStr = strtok(NULL, s);
	}
	return 0;
}

测试结果为

>gcc testStrtok.c
>a.exe
str length: 20
the newStr is 【I】 with length : 1
the newStr is 【am】 with length : 2
the newStr is 【tiny】 with length : 4
the newStr is 【cold】 with length : 4

接下来将string.h中的函数分为四个类别，分别是查询，比较，复制和追加以及本地函数。

由于字符串是存在长度的，所以在本文中，所有字符串中前n个字符中的n默认不大于字符串长度。

查询函数

查询函数	返回	类型
void *memchr(vSTR, int c, size_t n)	`str`前`n`个字节中首次出现`c`的位置	指针
char *strchr(cSTR, int c)	`str`首次出现`c`的位置	指针
char *strrchr(cSTR, int c)	`str`最后出现`c`的位置	指针
char *strstr(cSTR1, cSTR2)	`str1`中首次次出现字符串`str2`的位置	指针
char *strpbrk(cSTR1, cSTR2)	`str1`中首个个属于`str2`的字符的位置	指针
size_t strspn(cSTR1, cSTR2)	`str1`中第一个不属于`str2`的字符的索引	整数
char *strerror(int errnum)	根据错误号errnum索引错误名详见errno.h

比较函数

比较函数	返回
int memcmp(vSTR1, vSTR2, size_t n)	比较`str1`和`str2`的前n个字节
int strncmp(cSTR1, cSTR2, size_t n)	比较`str1`和`str2`的前n个字符
int strcmp(cSTR1, cSTR2)	比较`str1`和`str2`
size_t strcspn(cSTR1, cSTR2)	str1开头连续不含str2中字符的个数

注意

有关字符串str1和str2的比较中：

若二者相等，则返回0
若str1<str2，则返回值小于0
若str1>str2，则返回值大于0

复制和追加

下面用于字符串复制的函数，均返回一个指向目标字符串的指针。

复制
char `strcpy`(char dest, vSTR)	将`str`复制到`dest`
char `strncpy`(char dest, cSTR, size_t n)	把`str`前`n`个字符复制到 `dest`
void `memset`(void str, int c, size_t n)	将`str`的前`n`个字符设为`c`
void `memcpy`(void dest, vSTR, size_t n) void `memmove`(void dest, vSTR, size_t n)	将`str`的前`n`个字节复制到`dest`

其中，strncpy是对字符串的操作，而memcpy是对内存块的操作。

如果内存块发生重叠，memmove可以保证源字符串被覆盖之前，将重叠区域的字节复制到目标区域，所以比memcpy更加安全。

所谓追加，无非是将一个字符串的内容复制到另一个字符串的结尾，本质上也可称为广义的复制。

追加
char strcat(char dest, cSTR)	把`str`追加到`dest`结尾。
char strncat(char dest, cSTR, size_t n)	把`str`的前`n`个字符追加到`dest`结尾

本地函数

所谓本地函数，就是受到locale.h中LC_COLLATE影响的函数，其功能和返回值取决于当前所在的地区。string.h中共有两个本地函数，分别是用于字符串比较的strcoll和用于更改字符串格式的strxfrm。

对于前者，若我们想对一组汉字按照拼音进行排序，那么就要用到strcoll，其声明为

int strcoll(cSTR1, cSTR2)

做一个测试

//testStrcoll.c
#include <stdio.h>
#include <string.h>
#include <locale.h>

void printStrcoll(const char *str1, const char *str2){
    char flag = strcoll(str1,str2)>0 ? '>' : '<';
    printf("%s%c%s\n",str1, flag, str2);
}

int main (void)
{
    printf ("默认比较：");
    printStrcoll("甲","乙");

    setlocale (LC_ALL, "");
    printf ("拼音比较：");
    printStrcoll("甲","乙");

    return 0;
}

由于我实在不熟悉汉字编码顺序，所以选择了一个不太能说明问题的两个字符，其结果为

>gcc testStrcoll.c
>a.exe
默认比较：甲>乙
拼音比较：甲>乙

需要注意，本程序用的是gcc11.2进行编译的，低于10的版本可能会汉字乱码。

另一个本地函数声明为

size_t strxfrm(char *dest, cSTR, size_t n)

其功能就是简单的将str的前n个字符转换为本地形式后复制到dest中，返回值是被转换的字符长度。

ctype.h

作为强类型语言，C语言自其诞生以来，就通过类型来为初学者增加重重阻碍。为了避免各种麻烦，早在上古时期，C语言的程序员们就写了大量判别变量类型的代码段，这些代码段也很快就走进了标准库。

ctype中共有11个鉴别字符类型的函数，这些函数的输入输出均为int型，但又不完全是int型。输入的int是通过强转得到的；输出为0和1，即布尔型。

	返回1的情况	ASCII码位置	十六进制
isalnum	字母和数字	48-57, 65-90, 97-122	30-39, 41-5A, 61-7A
isalpha	字母	65-90, 97-122	41-5A, 61-7A
isupper	大写字母	65-90	41-5A
islower	小写字母	97-122	61-7A
iscntrl	控制字符	0-31,127	00-1F, 7F
isdigit	十进制数字	48-57	30-39
isxdigit	十六进制数字	48-57, 48-53, 97-102	30-39,41-46, 61-66
isgraph	图形字符	33-126	21-7E
isprint	可打印	32-126	20-7E
ispunct	标点符号	33-47, 58-64 91-96, 123-126	21-2F, 3A-40 5B-60, 7B-7E
isspace	空白字符	9-13,32	09-0D, 20

判别函数之间可由下图表示

isxdigit

A-F a-f

isdigit

isprint

isgraph

isalnum

0-9

isalpha

isupper

A-Z

islower

a-z

ispunct

! # $ % & '等

space

isspace

FF NL CR HT VT

iscntrl

BEL BS

此外，ctype中还封装了两个大小写转换的函数：int tolower(int c)和int toupper(int c)，这两个函数很容易实现，只要看一下十六进制下的ASCII即可发现。

前32个字符为控制符

	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	NUL	SOH	STX	ETX	EOT	ENQ	ACK	BEL	BS	HT	LF	VT	FF	CR	SO	SI
1	DLE	DC1	DC2	DC3	DC4	NAK	SYN	ETB	CAN	EM	SUB	ESC	FS	GS	RS	US

32-126为可打印字符，其中20为空格，大小写字母正好差了0x20。

	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
2		!	"	#	$	%	&	’	(	)	*	+	,	-	.	/
3	0	1	2	3	4	5	6	7	8	9	:	;	<	=	>	?
4	@	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O
5	P	Q	R	S	T	U	V	W	X	Y	Z	[	`\`	]	^	_
6	`	a	b	c	d	e	f	g	h	i	j	k	l	m	n	o
7	p	q	r	s	t	u	v	w	x	y	z	{	\|	}	~	DEL

math.h

double型的数学运算包，封装了最常用的一些数学函数，其中三角函数均用弧度制。

	不太需要解释的函数
三角函数	acos, asin, atan, cos, cosh, sin, `atan2(y,x)`= $\arctan\frac{y}{x}$
双曲函数	cosh, sinh, tanh
指数对数	exp, log, log10, sqrt, `pow(x,y)`= $x^y$
取整函数	向上取整`ceil`，向下取整`floor`
其他函数	绝对值fabs, 求余fmod, `ldexp(x, y)`= $x\times2^y$

modf(double x, double *integer)返回值为小数部分，并设置 integer 为整数部分。例如令x=2.5，则输出为0.5，然后让integer=2。

frexp(double x, int *exponent)可将x分解成尾数和指数，返回值是尾数，并将指数存入exponent中。所得的值是 x = mantissa * 2 ^ exponent。

#include<stdio.h>
#include<math.h>

int main(){
	float y,x;
	int a;
	x = 25.5;
	y = frexp(x,&a);
	printf("%f=%f*2^%d",x,y,a);
	return 0;
}

运行之后得到

>gcc testMath.c
>a.exe
>25.500000=0.796875*2^5 (x=y*2^a)

时间与货币

time.h

一般计算机中通过时间戳来代表时间，所谓时间戳就是从1970年11日0时0分0秒开始到当前时刻所经历的秒数。在C语言中，time_t就是专门表示这个时间戳的数据类型，在如今的操作系统中，一般time_t都是64位整型。

函数time()可以获取当前的时间戳，并将其编码位time_t格式。通过ctime函数，可将时间戳转为便于阅读的年月日字符串。

例如

#include<stdio.h>
#include<time.h>

int main(){
	time_t seconds = time(NULL);            //获取当前时间戳
	printf("timestamp: %ld\n", seconds);    //输出时间戳
	printf("time:%s\n", ctime(&seconds));   //输出时间字符串
	return(0);
}

编译运行之后为

>gcc testTime.c
>a.exe
timestamp: 1639375539
time:Mon Dec 13 14:05:39 2021

和time_t相似，time.h中还设置了clock_t用来描述处理器时间，通过无参数函数clock()可以直接返回一个clock_t类型的数据。

在time.h中还定义了tm结构，用于存储日期和时间。

struct tm {
   int tm_sec;         // 秒，范围从 0 到 59
   int tm_min;         // 分，范围从 0 到 59
   int tm_hour;        // 小时，范围从 0 到 23
   int tm_mday;        // 一月中的第几天，范围从 1 到 31
   int tm_mon;         // 月，范围从 0 到 11
   int tm_year;        // 自 1900 年起的年数
   int tm_wday;        // 一周中的第几天，范围从 0 到 6
   int tm_yday;        // 一年中的第几天，范围从 0 到 365
   int tm_isdst;       // 夏令时
};

gmtime和localtime函数可将时间戳转为tm结构，前者返回的是格林尼治标准时间，后者返回的是本地时间。然后，和ctime相似，asctime可以把tm结构转为方便阅读的字符串。

反过来，通过mktime可将tm结构按照本地时间的方式转化为time_t格式的时间戳。

测试程序如下

#include<stdio.h>
#include<time.h>

int main(){
	time_t seconds = time(NULL);
	struct tm *tLocal;
	tLocal = localtime(&seconds);
	printf("Local: %2d:%02d\n",tLocal->tm_hour, tLocal->tm_min);
	printf("Local asctime: %s\n", asctime(tLocal));
	return(0);
}

输出为

Local: 14:26
Local asctime: Mon Dec 13 14:26:45 2021

如果对ctime的返回值不满意，还可以通过strftime函数自定义时间格式，其声明为

size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr)

其中，timeptr为传入的tm指针；str为为时间日期字符串，用于输出；maxsize表示被复制到str的最大字符个数。而输入参数中，最关键的则是format这个字符串。

在format中，每个字符的含义如下


星期	`%a`为缩写星期名称，`%A`为完整星期名称， `%w`表示星期`几`(星期日为0)
星期	`%U, %W`表示一年中的第`几`周，二者分别以首个周日、首个周一为首周首日
月份	`%b`为缩写月份名称，`%B`为完整月份名称，`%m`表示第`几`月
年份	`%y`为年份后两个数字，`%Y`为完整年份
日期	`%d`为一月中的第`几`天，`%j`为一年中的第`几`天
小时	`%H`为24小时格式，`%I`为12小时格式
分秒	`%M`表示分，`%S`表示秒
符号	`%p`表示’AM’或’PM’，`%Z`表示时区的名称或缩写，`%%`为%转义
格式	`%x`为日期表示法：`08/19/12`；`%X`为时间表示法：`02:50:06`
	`%c`为日期和时间表示法 Sun Aug 19 02:56:02 2012

locale.h

locale.h对时间和货币的书写格式进行了封装，从而符合不同地区的使用习惯，故而locale.h中设计了两个用于本地化的函数

char *setlocale(int category, const char *locale)
struct lconv *localeconv(void)

前者用于设置或读取本地化信息，locale即代表某个区域的字符串，category代表将要设置的函数类别，其输入参数包括

值	宏	说明	影响的函数
0	LC_ALL	下面的所有选项
1	LC_COLLATE	字符串比较	strcoll 和 strxfrm
2	LC_CTYPE	字符分类和转换	所有字符函数
3	LC_MONETARY	货币格式	`localeconv()`
4	LC_NUMERIC	小数点分隔符	`localeconv()`
5	LC_TIME	日期和时间格式	`strftime()`
6	LC_MESSAGES	系统响应

其中，localeconv()函数被封装在locale.h中，其返回值是一个lconv结构，主要用于描述货币的表示方法，每个字段的含义在下面的注释中说明。在注释中，cs表示当前区域的货币符号。

typedef struct {
   char *decimal_point;     //常规数值的小数点字符
   char *thousands_sep;     //常规数值的千位分隔符
   char *grouping;          //常规数值中每组数字大小的字符串
   char *int_curr_symbol;   //国际货币符号使用的字符串。前三个字符由 ISO 4217:1987 指定，第四个字符用于分隔货币符号和货币量。
   char *currency_symbol;   //当前区域的货币符号，后文用cs表示
   char *mon_decimal_point; //货币的小数点字符
   char *mon_thousands_sep; //货币的千位分隔符
   char *mon_grouping;      //货币数值中每组数字大小的字符串
   char *positive_sign;     //货币的正号
   char *negative_sign;     //货币的负号
   char int_frac_digits;    //国际货币值中小数点后要显示的位数
   char frac_digits;        //货币值中小数点后要显示的位数。
   char p_cs_precedes;      //cs在正货币值中的位置
   char p_sep_by_space;     //cs与正货币值之间是否使用空格
   char n_cs_precedes;      //cs在负货币值中的位置
   char n_sep_by_space;     //cs与负货币值之间是否使用空格
   char p_sign_posn;        //表示正货币值中正号的位置
   char n_sign_posn;        //表示负货币值中负号的位置
} lconv

其中，grouping和mon_grouping均为字符串，分别表示在常规数值和货币中每组数字大小。字符串中每个字符都代表一个整数，用以指定当前组的位数。

当前区域的货币符号cs与货币值之间的排版方式为

	值为1	值为0
p_cs_precedes	cs在正货币值之前	cs在正货币值之后
p_sep_by_space	cs和正货币值之间用空格	cs和正货币值之间不使用空格
n_cs_precedes	cs在负货币值之前	cs在负货币值之后。
n_sep_by_space	cs和负货币值之间使用空格	cs和负货币值之间不使用空格

货币中正负号的位置通过p_sign_posn和n_sign_posn来调节，二者均有5个取值。

对于-1美元，其n_sign_posn取值从0-5，n_cs_precedes分别为0,1时，表示方法分别如下

	0	1	2	3	4
0	(`1.00`$)	-`1.00`$	`1.00`$-	`1.00`-$	`1.00`$-
1	($`1.00`)	-$`1.00`	$`1.00`-	-$`1.00`	$-`1.00`
说明	括号	数值和cs之前	数值和cs之后	cs之前	cs之后

单功能库

C语言标准库中有很多十分简单，故统一归类到单一功能库下，包括


stdarg.h	可变参数支持
stddef.h	指针相减
setjmp.h	跳转

assert.h

经典断言

感觉现在很多人都不用assert了，毕竟IDE都这么智能，assert的功能也非常简单，如果输入一个0(False)，那么就会打印一条错误信息。

#include<stdio.h>
#include<assert.h>

int main(){
	assert(1);
	assert(0);
}

这样一个简单的案例，在命令行中通过gcc编译，果然在第6行报错了。

E:\Documents\00\1101>gcc assert1.c

E:\Documents\00\1101>a.exe
Assertion failed: 0, file assert1.c, line 6

查看insert.h的源文件，会发现下面几行代码

#undef assert       //取消已有的assert定义
#ifdef NDEBUG
#define assert (test) ((void)0)
#else
#define assert (test) ...
#endif

这说明，当NDEBUG被定义的时候，会将assert自动转化为一个空函数，从而取消断言。

gcc中-D指令可以添加宏代码，则下面的代码并不会报错

E:\Documents\00\1101>gcc -DNDEBUG assert1.c
E:\Documents\00\1101>a.exe

C11静态断言

assert非常简单，简单到可以写成条件语句

void assertIf(int i){
    if(!i){
        printf("error");
        abort();            //自stdlib中调用，可终结函数
    }
}

assert的好处是，可以自动返回出错的行数，并且能够通过define NDEBUG将其禁止。不足之处在于，只能在运行时执行。C11推出了一个新的函数_Static_assert，顾名思义为静态断言，可以在编译时执行：

//sa.c
#include<assert.h>
int main(){
	_Static_assert(0);
}

结果为

E:\Documents\00\1101>gcc sa.c
sa.c: In function 'main':
sa.c:10:2: error: static assertion failed: "ERROR"
  _Static_assert(0,"ERROR");

stdarg.h

stdarg.h提供了C语言对可变参数的支持，先举一个简短的例子

//testStdArg.c
#include <stdarg.h>
#include <stdio.h>

void printIntList(int N, ...){
    va_list args;       //存放...所代表的参数
    va_start(args, N);  //初始化变量args
    for (int idx = 1; idx <= N; ++idx)
        printf("param %d: %d, ", idx, va_arg(args, int));
    printf("-----\n");
    va_end(args);
}

int main(void)
{
    printIntList(4,1,2,3,4);
    printIntList(4,1,2,3);
    printIntList(3,1,2,3,4);
}

>gcc testStdArg.c
>a.exe
param 1: 1, param 2: 2, param 3: 3, param 4: 4, 
-----
param 1: 1, param 2: 2, param 3: 3, param 4: 4, 
-----
param 1: 1, param 2: 2, param 3: 3, 
-----

其中，va_list为stdarg.h中声明的数据类型，用以存放...所代表的参数，在printIntList中，定义了va_list类型的args用于存储变量。

在stdarg.h中声明了三个函数，在上面的案例中都用上了，下面逐一解析

void va_start(va_list ap, last_arg)

用于初始化ap变量，last_arg为最后一个参数的下标
对于函数printIntList(4,1,2,3,4)而言，总共输入了5个参数，故其last_arg应该为4。

type va_arg(va_list ap, type)

逐个检索函数参数列表中类型为type参数
在printIntList中，va_arg被写在一个循环中，会逐个检索int型的参数
在printIntList(4,1,2,3)中，由于N设为4，所以va_arg会检索4次，最后返回的4实际上是一个野指针。

void va_end(va_list ap)

在参数调用结束之后，应该调用va_end来释放ap

stddef.h

定义了三个数据类型：size_t，wchar_t和ptrdiff_t。

其中size_t是sizeof的结果，一般是long unsigned int；wchar_t用于描述宽字符，一般是int。

ptrdiff_t是指针相减的数据类型，stddef.h还定义了一个宏函数offsetof，用于确定结构的某个成员到起始位置的偏移字节。

对于前者，例如

#include <stdio.h>
#include <stddef.h>

int main(){
    char x[20];
    ptrdiff_t nx = &x[5]-&x[0];
    printf("%d\n", nx);    //输出为5
    long int y[20];
    ptrdiff_t ny = &y[5]-&y[1];
    printf("%d\n", ny);    //输出为4
    return(0);
}

通过指针相减，当然可以得到结构中某个字段距离结构体初始指针的距离

#include <stdio.h>
#include <stddef.h>
typedef struct TEST{
    int a,b;
}test;

int main(){
    test x;
    static size_t off = (char*)&x->b - (char*)&x;
}

如果想在不创建示实例的情况下得到字段b到test初始值的偏离，可以可以采用offsetof函数

static size_t off = offsetof(test, b)

setjmp.h

setjmp.h中有两个函数，分别是setjmp和longjmp。

setjmp相当于回城标记，而longjmp则是个传送阵。调用longjmp会跳转到setjmp所在的位置——就如goto一样，但goto只能在函数内跳转，longjmp则可跨越函数。

setjmp一般被写为

int setjmp(jmp_buf env)

其输入参数env可理解为是系统地图，setjmp将当前位置刻录在地图中。jmp_buf是一个结构体，用来描述当前的地图。

那么当程序继续运行，想要回城的时候，被调用的longjmp也不可避免地需要导入这个地图——env。此外，我们不能平白无故地回城，必须得传达一些信息，longjmp这个传送阵允许我们传送一个整型，其定义为

void longjmp(jmp_buf env, int value)

当使用longjmp之后，就会跳转到最近一次执行的setjmp所在行，同时把value传递给setjmp，作为setjmp的返回值。

接下来举一个最直观的例子

//testJmp.c
#include <stdio.h>
#include <setjmp.h>
int main(){
    jmp_buf env;
    int ret;
    ret = setjmp(env);
    printf("ret=%d\n",ret);
    if(ret==0){
        printf("we'll execute the longjmp and set env=1\n");
        longjmp(env,1);
    }else
        printf("we'll not excute the longjmp because env=1");
    return 0;
}

编译运行的结果为

>gcc testJmp.c
>a.exe
ret=0
we'll execute the longjmp and set env=1
ret=1
we'll not excute the longjmp because env=1

常量库

float.h，描述浮点数并提供了浮点算术的基本信息
limits.h，描述整型并提供了整数计算的基本信息
errno.h，表明错误类型
signal.h：定义了信号宏

float.h

float.h用以描述浮点数并提供了浮点算术的基本信息，这些信息大多是通过宏的形式定义的。

在C语言中，一个浮点数可以表示为

$x=sb^e\sum_{k=1}^pf_kb^{-k}, e_{\min}<e\leq e_{\max}$

其中， $s$ 为符号，取值为 $\pm1$ ； $b$ 是大于1的整数，表示基数； $e$ 为指数； $p$ 为精度； $f_k$ 表示有效数字。记 $M=\sum_{k=1}^pf_kb^{-k}$ ，则可写为

$x=s\times M\times b^e, e_{\min}<e\leq e_{\max}$

在float.h中，FLT_RADIX表示基数，即b，这个b对所有浮点数类型都有效。而float.h的define的值中，绝大多数可分为三类，分别对应float、double和long double类型：

float	double	long double	简要说明
FLT_MANT_DIG	DBL_MANT_DIG	LDBL_MANT_DIG	`b`进制下`M`的最大长度
FLT_DIG( $\ge6$ )	DBL_DIG( $\ge10$ )	LDBL_DIG( $\ge10$ )	小数点后精确数字位数
FLT_MIN_EXP	DBL_MIN_EXP	LDBL_MIN_EXP	`b`进制下`e`的最小值
FLT_MAX_EXP	DBL_MAX_EXP	LDBL_MAX_EXP	`b`进制下`e`的最大值
FLT_MIN_10_EXP	DBL_MIN_10_EXP	LDBL_MIN_10_EXP	十进制下 $e_{\min}\le-37$
FLT_MAX_10_EXP	DBL_MAX_10_EXP	LDBL_MAX_10_EXP	十进制下 $e_{\max}\ge37$
FLT_MAX	DBL_MAX	LDBL_MAX	浮点数最大值 $\geqslant10^{37}$
FLT_MIN	DBL_MIN	LDBL_MIN	浮点数最小值 $\leqslant10^{-37}$
FLT_EPSILON ( $\leqslant10^{-5}$ )	DBL_EPSILON ( $\leqslant10^{-9}$ )	LDBL_EPSILON ( $\leqslant10^{-9}$ )	最小差值

其中，XXX_EPSILON表示1和大于1的最小浮点数之间的差值。

此外，还有三个独立的常量：

FLT_ROUNDS表示浮点加法的舍入模式：

-1：无法确定
0：趋向于零
1：趋向最近的值
2：趋向于正无穷
3：趋向于负无穷

FLT_EVAL_METHOD：指明表达式求值时是否需要提升浮点数类型

-1：不确定
0：使用当前类型
1：将float提升到double
2：将浮点数提升到long double

DECIMAL_DIG：用于long double序列化和反序列化时的十进制精度。简单地说，以不损失精度为前提，能够将long double转换成至少DECIMAL_DIG个十进制数字；反过来，也能将至少DECIMAL_DIG个十进制数字转换成long double。

limits.h

和float.h类似，limits.h中定义了整型数据的取值范围，对于char类型，还额外给出了CHAR_BIT表示char所包含的位数，取值大于等于8，一般为8。另有MB_LEN_MAX表示一个字节字符最多能包含的字节数，需大于等于1。

类型	最大值	最小值	一般取值
`char`	CHAR_MAX	CHAR_MIN
`singed char`	SCHAR_MAX	SCHAR_MIN	$±127 \pm127$
`unsinged char`	UCHAR_MAX		$255$
`short int`	SHRT_MAX	SHRT_MIN	$±32767 \pm32767$
`unsigned` `short int`	USHRT_MAX		$65536$
`int`	INT_MAX	INT_MIN	$±32767 \pm32767$
`unsigned int`	UINT_MAX		$65536$
`long int`	LONG_MAX	LONG_MIN	$\pm(2^{31}-1)$
`unsigned` `long int`	ULONG_MAX		$2^{32}-1$
`long long int`	LLONG_MAX	LLONG_MIN	$\pm(2^{63}-1)$
`unsigned` `long long int`	ULLONG_MAX		$2^{64}-1$

此外，CHAR_MIN的值为0或SCHAR_MIN；此外，CHAR_MAX的值为SCHAR_MAX或UCHAR_MAX。

这些宏并非毫无意义，而是定义了整型在C语言中的编码方式。

首先，最简单的数据类型是无符号整型，乃至于几乎不存在“编码”，只需把整数写为二进制，例如1011就是11。其规范的定义方式为

$\sum^N_ix_i2^i$

其中， $i$ 表示二进制的位数， $x_i$ 表示第 $i$ 位的二进制值，可取0或者1。从而1011写为

$1\cdot2^3+0\cdot2^2+1\cdot2^1+1\cdot2^0=11$

由于在物理层面并不存在类似-1111的负地址，所以负数，或者带有符号的整型需要编码，计算机中常用补码表示负数，其编码方式为

$-x_N2^N+\sum^{N-1}_ix_i2^i$

其中，最高位 $x_N$ 为符号位，当 $x_N=1$ 时，上式即为负数，例如1011表示

$-1\cdot2^3+0\cdot2^2+1\cdot2^1+1\cdot2^0=-5$

所以，在C语言中，int a=-1，则a的二进制编码为1111 1111 1111 1111。

errno.h

errno.h定义了整数变量errno，用于表明错误类型，程序启动时，errno为0。

如果该值不为0，说明发生了错误，操作系统会定义各种错误码所对应的错误类型，例如2表示未找到文件或文件夹等，而错误号所对应的错误类型被封装在string.h中，可通过函数strerror()来搜索。

#include<stdio.h>
#include<errno.h>
#include<string.h>

int main(){
	for(int i=0; i<10; i++)
		printf("%d:%s\n",i,strerror(i));
	return 0;
}

编译运行

>gcc testErr.c
>a.exe
0:No error
1:Operation not permitted
2:No such file or directory
3:No such process
4:Interrupted function call
5:Input/output error
6:No such device or address
7:Arg list too long
8:Exec format error
9:Bad file descriptor

测试一下，若调用一个不存在的文件或文件夹，其main函数改为

int main(){
	FILE *fp;
	fp = fopen("test.txt","r");
	if (fp==NULL)
		printf("%d:%s",errno, strerror(errno));
	return 0;
}

>gcc errFile.c
>a.exe
2:No such file or directory

位于stdio.h中的函数void perror(const char *str)可以把字符串str写入标准错误stderr，例如

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main(){
	FILE *fp;
	fp = fopen("test.txt","r");
	if (fp==NULL){
        perror("Error");
    }
	return 0;
}

输出为

>gcc errFile.c
>a.exe
Error: No such file or directory

signal.h

signal.h中定义了一系列的信号宏，如下面代码所示。

#define	SIGHUP	1	//挂起
#define	SIGINT	2	//中断
#define	SIGQUIT	3	//退出
#define	SIGILL	4	//非法指令
#define	SIGTRAP	5	//调试异常
#define	SIGABRT 6	//调用abort时产生，表示程序异常终止
#define	SIGIOT	SIGABRT	//实现相关的硬件异常
#define	SIGEMT	7	//EMT指令
#define	SIGFPE	8	//浮点运算时的异常
#define	SIGKILL	9	//无法处理或忽略时中止某个进程
#define	SIGBUS	10	//硬件异常导致的总线错误
#define	SIGSEGV	11	//非法内存访问
#define	SIGSYS	12	//非法系统调用
#define	SIGPIPE	13	//在reader终止之后写入管道
#define	SIGALRM	14	//timer(alarm)或interval timer(setitimer)超时
#define	SIGTERM	15	//请求中止进程而无法调用Kill时
#define	SIGURG	16	/* urgent condition on IO channel */
#define	SIGSTOP	17	/* sendable stop signal not from tty */
#define	SIGTSTP	18	/* stop signal from tty */
#define	SIGCONT	19	//从stop恢复时发送
#define	SIGCHLD	20	//子进程结束时发给其父进程
#define	SIGCLD	20	/* System V name for SIGCHLD */
#define	SIGTTIN	21	/* to readers pgrp upon background tty read */
#define	SIGTTOU	22	/* like TTIN for output if (tp->t_local&LTOSTOP) */
#define	SIGIO	23	//IO信号
#define	SIGPOLL	SIGIO	//向可调用设备发送信息时
#define	SIGXCPU	24	//CPU时间间隔超时
#define	SIGXFSZ	25	//文件字节数超限
#define	SIGVTALRM 26	//interval timer(setitimer)超时
#define	SIGPROF	27	//由Setitimer指定的计时器发出
#define	SIGWINCH 28	//终端窗口变化
#define	SIGLOST 29	//资源丢失
#define	SIGPWR  SIGLOST	//掉电
#define	SIGUSR1 30	//用户自定义
#define	SIGUSR2 31	//用户自定义