C语言学习记录总结

骑猪看日落 2022-06-06 19:58 217阅读 0赞

一、C语言

【

1、C标准库

（C 语言是一种通用的、面向过程式的计算机程序设计语言。1972 年，为了移植与开发 UNIX 操作系统，丹尼斯·里奇在贝尔电话实验室设计开发了 C 语言。）

\#include <stdio.h>

\---<assert.h>：提供了一个名为 assert 的宏，它可用于验证程序做出的假设，并在假设为假时输出诊断消息。

\---<ctype.h>：提供了一些函数，可用于测试和映射字符。

\---<errno.h>：定义了整数变量 errno，它是通过系统调用设置的，在错误事件中的某些库函数表明了什么发生了错误。

\---<float.h>：文件包含了一组与浮点值相关的依赖于平台的常量。

\---<limits.h>：文件决定了各种变量类型的各种属性。定义在该头文件中的宏限制了各种变量类型（比如 char、int 和 long）的值。

\---文件定义了特定地域的设置，比如日期格式和货币符号。接下来我们将介绍一些宏，以及一个重要的结构 struct lconv 和两个重要的函数。

\---<math.h>：文件定义了各种数学函数和一个宏。在这个库中所有可用的功能都带有一个 double 类型的参数，且都返回 double 类型的结果。

\---<setjmp.h>：文件定义了宏 setjmp()、函数 longjmp() 和变量类型 jmp\_buf，该变量类型会绕过正常的函数调用和返回规则。

\---<signal.h>：文件定义了一个变量类型 sig\_atomic\_t、两个函数调用和一些宏来处理程序执行期间报告的不同信号。

\---<stdarg.h>：文件定义了一个变量类型 va\_list 和三个宏，这三个宏可用于在参数个数未知（即参数个数可变）时获取函数中的参数。

\---<stddef.h>：文件定义了各种变量类型和宏。这些定义中的大部分也出现在其它头文件中。

\---<stdio.h>：文件定义了三个变量类型、一些宏和各种函数来执行输入和输出。

\---<stdlib.h>：文件定义了四个变量类型、一些宏和各种通用工具函数。

\---<string.h>：文件定义了一个变量类型、一个宏和各种操作字符数组的函数。

\---<time.h>：文件定义了四个变量类型、两个宏和各种操作日期和时间的函数。

2、基础理论知识

\---程序结构：预处理器指令、函数、变量、语句&表达式、注释。 return 0; ---退出main()函数。

\---关键字：auto else long switch break enum register typedef  case extern return union  char float short unsigned  const for signed void  continue goto sizeof volatile  default if static while  do int struct \_Packed  double

\---数据类型：

@1：基本类型<char、unsigned char、signed char、int、unsigned int、short、unsigned short、long、unsigned long>

@2：枚举类型<float、double、long double>

@3：Void类型<函数返回为空、函数参数为空、指针指向 void>

@4：派生类型<指针类型、数组类型、结构类型、共用体类型和函数类型>

\---变量：变量的定义-type variable\_list; 变量的声明<extern>-extern int i; //变量的声明 int i；//变量的定义 --除非有extern关键字，否则都是变量的定义。

\---常量：字符常量<\\\\--\\ \\'--' \\"--" \\?--? \\a--警报铃声 \\b--退格键 \\f--换页符 \\n--换行符 \\r--回车 \\t--水平制表符

\\v--垂直制表符 \\ooo--一到三位的八进制数 \\xhh--一个或多个数字的十六进制数>

定义常量：@1：使用 \#define 预处理器<\#define identifier value --\#define LENGTH 10 >

@2：使用 const 关键字<const type variable = value;--const int LENGTH = 10;>。

\---存储类：存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。<auto、register、static、extern>

@1 auto：是所有局部变量默认的存储类。auto 只能用在函数内，即 auto 只能修饰局部变量。

@2 register：用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

@3 static：指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。 static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。 static 是全局变量的默认存储类，以下两个变量 (count 和 road) 都有一个 static 存储类。

@4 extern：extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候。

(auto 是局部变量的默认存储类, 限定变量只能在函数内部使用；

static是全局变量的默认存储类,表示变量在程序生命周期内可见；

extern 表示全局变量，即对程序内所有文件可见，类似于Java中的public关键字； )

\---运算符：(算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、杂项运算符)\{

@1：逻辑运算符--&&、||、！

@2：位运算符--&(与)、|<或>、^<异或>、>>、<<

@3：杂项运算符--sizeof()<返回变量的大小>、&<返回变量的地址>、\*<指向一个变量>、?:<条件表达式>

\--循环：while 循环、for 循环、do...while 循环、嵌套循环\{

@1:循环控制语句：break 语句、continue 语句、goto 语句

@2：无限循环---for( ; ; )

\--函数：返回类型、函数名称、参数、函数主体

\--作用域规则：\{ 局部变量、全局变量和形式参数

@1：局部变量的值会覆盖全局变量的值。

@2：当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动对其初始化。

\--数组：存储一个固定大小的相同类型元素的顺序集合。

\--指针\{--指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。

每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址。

@1使用指针： int \*ip; /\* 指针变量的声明 \*/ ip = &var; /\* 在指针变量中存储 var 的地址 \*/

printf("Address stored in ip variable: %p\\n", ip ); /\* 在指针变量中存储的地址 \*/

printf("Value of \*ip variable: %d\\n", \*ip ); /\* 使用指针访问值 \*/

@2空指针：赋为 NULL 值的指针被称为空指针。NULL 指针是一个定义在标准库中的值为零的常量。程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。所以大多情况下要做非空判断。

\- \-函数指针和回调函数\{

@1：函数指针--是指向函数的指针变量。可以像一般函数一样，用于调用函数、传递参数。 声明：typedef int (\*fun\_ptr)(int,int); // 声明一个指向同样参数、返回值的函数指针类型

实例： /\* p 是函数指针 \*/ int (\* p)(int, int) = & max; // &可以省略

/\* 与直接调用函数等价，d = max(max(a, b), c) \*/ d = p(p(a, b), c);

@2：回调函数--函数指针作为某个函数的参数，函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。 简单讲：回调函数是由别人的函数执行时调用你实现的函数。

// 回调函数： void populate\_array(int \*array, size\_t arraySize, int (\*getNextValue)(void)) \{ \}

\--字符串\{

@1：在 C 语言中，字符串实际上是使用 null 字符 '\\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。 字符串操作函数。。。

\--结构体\{

@1定义：C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。 struct 语句定义了一个包含多个成员的新的数据类型。

@2访问结构成员：使用成员访问运算符（.）。

struct Books\{ char title\[50\]; char author\[50\]; char subject\[100\]; int book\_id; \};

struct Books Book1; /\* 声明 Book1，类型为 Books \*/

/\* Book1 详述 \*/ strcpy( Book1.title, "C Programming"); Book1.book\_id = 6495407;

/\* 输出 Book1 信息 \*/ printf( "Book 1 title : %s\\n", Book1.title);

@3结构作为函数参数： /\* 函数声明 \*/ void printBook( struct Books book ); printBook( Book1 );

@4指向结构的指针： 定义指向结构的指针，方式与定义指向其他类型变量的指针相似--struct Books \*struct\_pointer;

指针变量中存储结构变量的地址：struct\_pointer = &Book1;

使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符：struct\_pointer->title;

实例： /\* 函数声明 \*/ void printBook( struct Books \*book );

struct Books Book1; /\* 声明 Book1，类型为 Books \*/

/\* 通过传 Book1 的地址来输出 Book1 信息 \*/ printBook( &Book1 );

@5：位域

\--共用体\{

@1说明：共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。

@2定义：使用 union 语句，方式与定义结构类似。union 语句定义了一个新的数据类型，带有多个成员。

union Data\{ int i; float f; char str\[20\]; \} data;

@3访问共用体成员： union Data data; data.i = 10; strcpy( data.str, "C Programming"); printf( "data.i : %d\\n", data.i);

\--位域\{ 如果程序的结构中包含多个开关量，只有 TRUE/FALSE 变量。

@1定义位域：/\* 定义位域结构 \*/ struct\{ unsigned int widthValidated : 1; unsigned int heightValidated : 1; \} status2;

@2位域声明：struct\{ type \[member\_name\] : width ;\}; 带有预定义宽度的变量被称为位域。

\--typedef\{

typedef 关键字，您可以使用它来为类型取一个新的名字。下面的实例为单字节数字定义了一个术语 BYTE： typedef unsigned char BYTE; ---- BYTE b1, b2;

typedef vs \#define --\#define 是 C 指令，用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同：

@1：typedef 仅限于为类型定义符号名称，\#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。

@2：typedef 是由编译器执行解释的，\#define 语句是由预编译器进行处理的。

\--输入 & 输出\{

标准文件：<标准输入 stdin 键盘 | 标准输出 stdout 屏幕 | 标准错误 stderr 屏幕>

C 语言中的 I/O (输入/输出) 通常使用 printf() 和 scanf() 两个函数。 scanf() 函数用于从标准输入（键盘）读取并格式化， printf() 函数发送格式化输出到标准输出（屏幕）。

@ 格式化数据形式： %d 格式化输出整数 %f 格式化输出浮点型数据

@ getchar() & putchar() 函数：

\--int getchar(void) 函数从屏幕读取下一个可用的字符，并把它返回为一个整数。这个函数在同一个时间内只会读取一个单一的字符。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。

\--int putchar(int c) 函数把字符输出到屏幕上，并返回相同的字符。这个函数在同一个时间内只会输出一个单一的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符。

@ gets() & puts() 函数：

\--char \*gets(char \*s) 函数从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF。 int puts(const char \*s) 函数把字符串 s 和一个尾随的换行符写入到 stdout。

@ scanf() 和 printf() 函数：

\--int scanf(const char \*format, ...) 函数从标准输入流 stdin 读取输入，并根据提供的 format 来浏览输入。

\--int printf(const char \*format, ...) 函数把输出写入到标准输出流 stdout ，并根据提供的格式产生输出。

\--format 可以是一个简单的常量字符串，但是您可以分别指定 %s、%d、%c、%f 等来输出或读取字符串、整数、字符或浮点数。还有许多其他可用的格式选项，可以根据需要使用。

\--文件读写\{

@ 1 打开文件：使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型 FILE 的一个对象，类型 FILE 包含了所有用来控制流的必要的信息。 FILE \*fopen( const char \* filename, const char \* mode ); <mode：r、w、a、r+、w+、a+>

@ 2 关闭文件 -- ;为了关闭文件，请使用 fclose( ) 函数。函数的原型如下：int fclose( FILE \*fp );

@ 如果成功关闭文件，fclose( ) 函数返回零，如果关闭文件时发生错误，函数返回 EOF。

@ 3、写入文件：字符写入到流中的最简单的函数：int fputc( int c, FILE \*fp ); 函数 fputc() 把参数 c 的字符值写入到 fp 所指向的输出流中。如果写入成功，它会返回写入的字符，如果发生错误，则会返回 EOF。

int fputs( const char \*s, FILE \*fp ); 函数 fputs() 把字符串 s 写入到 fp 所指向的输出流中。如果写入成功，它会返回一个非负值，如果发生错误，则会返回 EOF。

@ 4、读取文件：int fgetc( FILE \* fp ); fgetc() 函数从 fp 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回 EOF。 char \*fgets( char \*buf, int n, FILE \*fp ); 函数 fgets() 从 fp 所指向的输入流中读取 n - 1 个字符。它会把读取的字符串复制到缓冲区 buf，并在最后追加一个 null 字符来终止字符串。

@5、二进制 I/O 函数：size\_t fread(void \*ptr, size\_t size\_of\_elements, size\_t number\_of\_elements, FILE \*a\_file);

size\_t fwrite(const void \*ptr, size\_t size\_of\_elements, size\_t number\_of\_elements, FILE \*a\_file);

\--预处理器\{

@1、定义：C 预处理器不是编译器的组成部分，但是它是编译过程中一个单独的步骤。简言之，C 预处理器只不过是一个文本替换工具而已，它们会指示编译器在实际编译之前完成所需的预处理。我们将把 C 预处理器（C Preprocessor）简写为 CPP。

所有的预处理器命令都是以井号（\#）开头。它必须是第一个非空字符，为了增强可读性，预处理器指令应从第一列开始。

<\#define 定义宏

\#include 包含一个源代码文件

\#undef 取消已定义的宏

\#ifdef 如果宏已经定义，则返回真

\#ifndef 如果宏没有定义，则返回真

\#if 如果给定条件为真，则编译下面代码

\#else \#if 的替代方案

\#elif 如果前面的 \#if 给定条件不为真，当前条件为真，则编译下面代码

\#endif 结束一个 \#if……\#else 条件编译块

\#error 当遇到标准错误时，输出错误消息

\#pragma 使用标准化方法，向编译器发布特殊的命令到编译器中

@2、预处理器实例：

\--\#define MAX\_ARRAY\_LENGTH 20 宏定义

\--\#include <stdio.h> 引进系统文件

\--\#include "myheader.h" 引进本地文件

\--\#undef FILE\_SIZE 取消宏定义

\--\#define FILE\_SIZE 42 重新定义宏

\--\#ifndef MESSAGE \#define MESSAGE "You wish!" \#endif 只有当未定义时，才重新定义。

\--\#ifdef DEBUG /\* Your debugging statements here \*/ \#endif 判断如果定义了，执行。。

@3、预定义宏：

\_\_DATE\_\_ 当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。

\_\_TIME\_\_ 当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。

\_\_FILE\_\_ 这会包含当前文件名，一个字符串常量。

\_\_LINE\_\_ 这会包含当前行号，一个十进制常量。

\_\_STDC\_\_ 当编译器以 ANSI 标准编译时，则定义为 1。

@4、预处理器运算符

\--宏延续运算符（\\）:一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（\\）。例如：

\#define message\_for(a, b) \\

printf(\#a " and " \#b ": We love you!\\n")

\--字符串常量化运算符（\#）：在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（\#）。在宏中使用的该运算符有一个特定的参数或参数列表。例如：\#define message\_for(a, b) \\ printf(\#a " and " \#b ": We love you!\\n")

==调用： message\_for(Carole, Debra);

\--标记粘贴运算符（\#\#）：宏定义内的标记粘贴运算符（\#\#）会合并两个参数。它允许在宏定义中两个独立的标记被合并为一个标记。例如：\#define tokenpaster(n) printf ("token" \#n " = %d", token\#\#n) tokenpaster(34);

\--defined() 运算符：

\--头文件\{

@1、头文件：头文件是扩展名为 .h 的文件，包含了 C 函数声明和宏定义，被多个源文件中引用共享。有两种类型的头文件：程序员编写的头文件和编译器自带的头文件。 =在程序中要使用头文件，需要使用 C 预处理指令 \#include 来引用它。 =引用头文件相当于复制头文件的内容。 =C 或 C++ 程序中，建议把所有的常量、宏、系统全局变量和函数原型写在头文件中，在需要的时候随时引用这些头文件。

@2、引用头文件的方法：使用预处理指令 \#include 可以引用用户和系统头文件。它的形式有以下两种：\#include <file>--这种形式用于引用系统头文件。它在系统目录的标准列表中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

=\#include "file"--这种形式用于引用用户头文件。它在包含当前文件的目录中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

@3、只引用一次头文件：如果一个头文件被引用两次，编译器会处理两次头文件的内容，这将产生错误。为了防止这种情况，标准的做法是把文件的整个内容放在条件编译语句中，如下：

\#ifndef HEADER\_FILE

\#define HEADER\_FILE

the entire header file file

\#endif

@4、有条件引用：有时需要从多个不同的头文件中选择一个引用到程序中。例如，需要指定在不同的操作系统上使用的配置参数。您可以通过一系列条件来实现这点，如下：

\#if SYSTEM\_1

\# include "system\_1.h"

\#elif SYSTEM\_2

\# include "system\_2.h"

\#elif SYSTEM\_3

...

\#endif

\--强制类型转换\{

@1、强制类型转换：强制类型转换是把变量从一种类型转换为另一种数据类型。即把高精度的数据类型转换成低精度的数据类型。(type\_name) expression

@2、整数提升：整数提升是指把小于 int 或 unsigned int 的整数类型转换为 int 或 unsigned int 的过程。char c = 'c'; /\* ascii 值是 99 \*/

@3、常用的算数转换：常用的算术转换是隐式地把值强制转换为相同的类型。编译器首先执行整数提升，如果操作数类型不同。常用的算术转换不适用于赋值运算符、逻辑运算符 && 和 ||。

\--错误处理\{

@1、错误处理：C 语言不提供对错误处理的直接支持，但是作为一种系统编程语言，它以返回值的形式允许您访问底层数据。在发生错误时，大多数的 C 或 UNIX 函数调用返回 1 或 NULL，同时会设置一个错误代码 errno，该错误代码是全局变量，表示在函数调用期间发生了错误。您可以在 <error.h> 头文件中找到各种各样的错误代码。

=C 程序员可以通过检查返回值，然后根据返回值决定采取哪种适当的动作。开发人员应该在程序初始化时，把 errno 设置为 0，这是一种良好的编程习惯。0 值表示程序中没有错误。

@2、errno、perror() 和 strerror()：C 语言提供了 perror() 和 strerror() 函数来显示与 errno 相关的文本消息。

=perror() 函数显示您传给它的字符串，后跟一个冒号、一个空格和当前 errno 值的文本表示形式。

=strerror() 函数，返回一个指针，指针指向当前 errno 值的文本表示形式。

@3、被零除的错误：在进行除法运算时，如果不检查除数是否为零，则会导致一个运行时错误。为了避免这种情况发生，下面的代码在进行除法运算前会先检查除数是否为零：

if( divisor == 0)\{

fprintf(stderr, "除数为 0 退出运行...\\n");

exit(-1);

@4、程序退出状态：通常情况下，程序成功执行完一个操作正常退出的时候会带有值 EXIT\_SUCCESS。在这里，EXIT\_SUCCESS 是宏，它被定义为 0。 =如果程序中存在一种错误情况，当您退出程序时，会带有状态值 EXIT\_FAILURE，被定义为 -1。所以，上面的程序可以写成：

if( divisor == 0)\{

fprintf(stderr, "除数为 0 退出运行...\\n");

exit(EXIT\_FAILURE);

\--递归\{

@1、递归：递归指的是在函数的定义中使用函数自身的方法。即函数自己调用自己，关键是满足某条件时的递归出口，否则会造成死循环。 形式如：void recursion()\{ recursion(); /\* 函数调用自身 \*/ \} int main()\{ recursion();\}

=递归函数在解决许多数学问题上起了至关重要的作用，比如计算一个数的阶乘、生成斐波那契数列，等等。

@2、数的阶乘：

\#include <stdio.h>

double factorial(unsigned int i)

if(i <= 1)

return 1;

return i \* factorial(i - 1);

int main()

int i = 15;

printf("%d 的阶乘为 %f\\n", i, factorial(i));

return 0;

@3、斐波那契数列：

\--可变参数\{

@1、可变参数：希望函数带有可变数量的参数，而不是预定义数量的参数。C 语言为这种情况提供了一个解决方案，它允许您定义一个函数，能根据具体的需求接受可变数量的参数。下面的实例演示了这种函数的定义。

int func(int, ... )

int main()

func(1, 2, 3);

func(1, 2, 3, 4);

函数 func() 最后一个参数写成省略号，即三个点号（...），省略号之前的那个参数是 int，代表了要传递的可变参数的总数。为了使用这个功能，您需要使用 stdarg.h 头文件，该文件提供了实现可变参数功能的函数和宏。

\--内存管理\{

@1、内存管理：C 语言为内存的分配和管理提供了几个函数。这些函数可以在 <stdlib.h> 头文件中找到。

=void \*calloc(int num, int size);--在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num\*size 个字节长度的内存空间，并且每个字节的值都是0。

=void free(void \*address);--该函数释放 address 所指向的内存块,释放的是动态分配的内存空间。

=void \*malloc(int num);--在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。

=void \*realloc(void \*address, int newsize);--该函数重新分配内存，把内存扩展到 newsize。

@2、动态分配内存：编程时，如果您预先知道数组的大小，那么定义数组时就比较容易。例如：char name\[100\];

=但是，如果您预先不知道需要存储的文本长度，例如您向存储有关一个主题的详细描述。在这里，我们需要定义一个指针，该指针指向未定义所学内存大小的字符，后续再根据需求来分配内存，如下所示：/\* 动态分配内存 \*/ description = malloc( 200 \* sizeof(char) ); =上面的程序也可以使用 calloc() 来编写，只需要把 malloc 替换为 calloc 即可，如下所示：calloc(200, sizeof(char)); =当动态分配内存时，有完全控制权，可以传递任何大小的值。而那些预先定义了大小的数组，一旦定义则无法改变大小。

@3、重新调整内存的大小和释放内存：当程序退出时，操作系统会自动释放所有分配给程序的内存，但是，建议在不需要内存时，都应该调用函数 free() 来释放内存。 =或者，可以通过调用函数 realloc() 来增加或减少已分配的内存块的大小。让我们使用 realloc() 和 free() 函数，再次查看上面的实例 /\* 使用 free() 函数释放内存 \*/ free(description);

\--命令行参数\{

@1、命令行参数：执行程序时，可以从命令行传值给 C 程序。这些值被称为命令行参数，它们对程序很重要，特别是当您想从外部控制程序，而不是在代码内对这些值进行硬编码时，就显得尤为重要了。

\-- 标准库 - <assert.h>\{

@1、简介：C 标准库的 assert.h头文件提供了一个名为 assert 的宏，它可用于验证程序做出的假设，并在假设为假时输出诊断消息。已定义的宏 assert 指向另一个宏 NDEBUG，宏 NDEBUG 不是 <assert.h> 的一部分。如果已在引用 <assert.h> 的源文件中定义 NDEBUG 为宏名称，则 assert 宏的定义如下：\#define assert(ignore) ((void)0)

@2、库宏：void assert(int expression)----这实际上是一个宏，不是一个函数，可用于在 C 程序中添加诊断。

\-- 标准库 - <ctype.h>\{

@1、简介：C 标准库的 ctype.h 头文件提供了一些函数，可用于测试和映射字符。 =这些函数接受 int 作为参数，它的值必须是 EOF 或表示为一个无符号字符。 =如果参数 c 满足描述的条件，则这些函数返回非零（true）。如果参数 c 不满足描述的条件，则这些函数返回零。

@2、

\--标准库 - <ctype.h>\{

@2、库函数：

=int isalnum(int c)----该函数检查所传的字符是否是字母和数字。

=int isalpha(int c)-----该函数检查所传的字符是否是字母。

=int iscntrl(int c)------该函数检查所传的字符是否是控制字符。

=int isdigit(int c)------该函数检查所传的字符是否是十进制数字。

=int isgraph(int c)-----该函数检查所传的字符是否有图形表示法。

=int islower(int c)-----该函数检查所传的字符是否是小写字母。

=int isprint(int c)------该函数检查所传的字符是否是可打印的。

=int ispunct(int c)-----该函数检查所传的字符是否是标点符号字符。

=int isspace(int c)-----该函数检查所传的字符是否是空白字符。

=int isupper(int c)-----该函数检查所传的字符是否是大写字母。

=int isxdigit(int c)-----该函数检查所传的字符是否是十六进制数字。

=int tolower(int c)-----该函数把大写字母转换为小写字母。

=int toupper(int c)----该函数把小写字母转换为大写字母。

@3、字符类：

=数字

=十六进制数字

=小写字母

=大写字母

=字母

=字母数字字符

=标点符字符

=图像字符

=空格字符

=可打印字符

=控制字符

=空白字符

=字母字符

\--标准库 - <errno.h>\{

@1、简介：C 标准库的 errno.h 头文件定义了整数变量 errno，它是通过系统调用设置的，在错误事件中的某些库函数表明了什么发生了错误。该宏扩展为类型为 int 的可更改的左值，因此它可以被一个程序读取和修改。 =在程序启动时，errno 设置为零，C 标准库中的特定函数修改它的值为一些非零值以表示某些类型的错误。您也可以在适当的时候修改它的值或重置为零。 =errno.h 头文件也顶了以一系列表示不同错误代码的宏，这些宏应扩展为类型为 int 的整数常量表达式。

@2、库宏：

=extern int errno-----这是通过系统调用设置的宏，在错误事件中的某些库函数表明了什么发生了错误。

=EDOM Domain Error----这个宏表示一个域错误，它在输入参数超出数学函数定义的域时发生，errno 被设置为 EDOM。

=ERANGE Range Error----这个宏表示一个范围错误，它在输入参数超出数学函数定义的范围时发生，errn。

\--标准库 - <float.h>\{

@1、简介：C 标准库的 float.h 头文件包含了一组与浮点值相关的依赖于平台的常量。这些常量是由 ANSI C 提出的，这让程序更具有可移植性。在讲解这些常量之前，最好先弄清楚浮点数是由下面四个元素组成的：

=S 符号 ( +/- )

=b 指数表示的基数，2 表示二进制，10 表示十进制，16 表示十六进制，等等...

=e 指数，一个介于最小值 emin 和最大值 emax 之间的整数。

=p 精度，基数 b 的有效位数

\--标准库 - <limits.h>\{

@1、简介：limits.h 头文件决定了各种变量类型的各种属性。定义在该头文件中的宏限制了各种变量类型（比如 char、int 和 long）的值。 =这些限制指定了变量不能存储任何超出这些限制的值，例如一个无符号可以存储的最大值是 255。

@2、库宏：

=CHAR\_BIT 8 定义一个字节的比特数。

=SCHAR\_MIN -128 定义一个有符号字符的最小值。

=SCHAR\_MAX 127 定义一个有符号字符的最大值。

=UCHAR\_MAX 255 定义一个无符号字符的最大值。

=CHAR\_MIN 0 定义类型 char 的最小值，如果 char 表示负值，则它的值等于 SCHAR\_MIN，否则等于 0。

=CHAR\_MAX 127 定义类型 char 的最大值，如果 char 表示负值，则它的值等于 SCHAR\_MAX，否则等于 UCHAR\_MAX。

=MB\_LEN\_MAX 1 定义多字节字符中的最大字节数。

=SHRT\_MIN -32768 定义一个短整型的最小值。

=SHRT\_MAX +32767 定义一个短整型的最大值。

=USHRT\_MAX 65535 定义一个无符号短整型的最大值。

=INT\_MIN -32768 定义一个整型的最小值。

=INT\_MAX +32767 定义一个整型的最大值。

=UINT\_MAX 65535 定义一个无符号整型的最大值。

=LONG\_MIN -2147483648 定义一个长整型的最小值。

=LONG\_MAX +2147483647 定义一个长整型的最大值。

=ULONG\_MAX 4294967295 定义一个无符号长整型的最大值。

\--标准库 - <locale.h>\{

@1、简介：locale.h 头文件定义了特定地域的设置，比如日期格式和货币符号。接下来我们将介绍一些宏，以及一个重要的结构 struct lconv 和两个重要的函数。

@2、库宏：

=LC\_ALL----设置下面的所有选项。

=LC\_COLLATE-----影响 strcoll 和 strxfrm 函数。

=LC\_CTYPE-----影响所有字符函数。

=LC\_MONETARY--影响 localeconv 函数提供的货币信息。

=LC\_NUMERIC---影响 localeconv 函数提供的小数点格式化和信息。

=LC\_TIME------影响 strftime 函数。

@3、库函数：

=char \*setlocale(int category, const char \*locale)----设置或读取地域化信息。

=struct lconv \*localeconv(void)------设置或读取地域化信息。

\--标准库 - <math.h>\{

@1、简介：math.h 头文件定义了各种数学函数和一个宏。在这个库中所有可用的功能都带有一个 double 类型的参数，且都返回 double 类型的结果。

@2、库宏：

=HUGE\_VAL-----当函数的结果不可以表示为浮点数时。如果是因为结果的幅度太大以致于无法表示，则函数会设置 errno 为 ERANGE 来表示范围错误，并返回一个由宏 HUGE\_VAL 或者它的否定（- HUGE\_VAL）命名的一个特定的很大的值。 如果结果的幅度太小，则会返回零值。在这种情况下，error 可能会被设置为 ERANGE，也有可能不会被设置为 ERANGE。

@3、库函数：

=double acos(double x)-----返回以弧度表示的 x 的反余弦。

=double asin(double x)-----返回以弧度表示的 x 的反正弦。

=double atan(double x)-----返回以弧度表示的 x 的反正切。

=double atan2(double y, double x)----返回以弧度表示的 y/x 的反正切。y 和 x 的值的符号决定了正确的象限。

=double cos(double x)------返回弧度角 x 的余弦。

=double cosh(double x)-----返回 x 的双曲余弦。

=double sin(double x)------返回弧度角 x 的正弦。

=double sinh(double x)-----返回 x 的双曲正弦。

=double tanh(double x)-----返回 x 的双曲正切。

=double exp(double x)------返回 e 的 x 次幂的值。

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

=double ldexp(double x, int exponent)------返回 x 乘以 2 的 exponent 次幂。

=double log(double x)------返回 x 的自然对数（基数为 e 的对数）。

=double log10(double x)----返回 x 的常用对数（基数为 10 的对数）。

=double modf(double x, double \*integer)----返回值为小数部分（小数点后的部分），并设置 integer 为整数部分。

=double pow(double x, double y)------------返回 x 的 y 次幂。

=double sqrt(double x)-----返回 x 的平方根。

=double ceil(double x)-----返回大于或等于 x 的最小的整数值。

=double fabs(double x)-----返回 x 的绝对值。

=double floor(double x)----返回小于或等于 x 的最大的整数值。

=double fmod(double x, double y)-----------返回 x 除以 y 的余数。

\--标准库 - <setjmp.h>\{

@1、简介：setjmp.h 头文件定义了宏 setjmp()、函数 longjmp() 和变量类型 jmp\_buf，该变量类型会绕过正常的函数调用和返回规则。

@2、库变量：

=jmp\_buf ------这是一个用于存储宏 setjmp() 和函数 longjmp() 相关信息的数组类型。

@3、库宏：

=int setjmp(jmp\_buf environment)----这个宏把当前环境保存在变量 environment 中，以便函数 longjmp() 后续使用。如果这个宏直接从宏调用中返回，则它会返回零，但是如果它从 longjmp() 函数调用中返回，则它会返回一个非零值。

@4、库函数：

=void longjmp(jmp\_buf environment, int value)----该函数恢复最近一次调用 setjmp() 宏时保存的环境，jmp\_buf 参数的设置是由之前调用 setjmp() 生成的。

\--标准库 - <signal.h> \{

@1、简介：signal.h 头文件定义了一个变量类型 sig\_atomic\_t、两个函数调用和一些宏来处理程序执行期间报告的不同信号。

@2、库变量：

=sig\_atomic\_t-----这是 int 类型，在信号处理程序中作为变量使用。它是一个对象的整数类型，该对象可以作为一个原子实体访问，即使存在异步信号时，该对象可以作为一个原子实体访问。

@3、库宏：

=SIG\_DFL----默认的信号处理程序。

=SIG\_ERR----表示一个信号错误。

=SIG\_IGN----忽视信号。

=SIGABRT----程序异常终止。

=SIGFPE-----算术运算出错，如除数为 0 或溢出。

=SIGILL-----非法函数映象，如非法指令。

=SIGINT-----中断信号，如 ctrl-C。

=SIGSEGV----非法访问存储器，如访问不存在的内存单元。

=SIGTERM----发送给本程序的终止请求信号。

@4、库函数：

=void (\*signal(int sig, void (\*func)(int)))(int)----该函数设置一个函数来处理信号，即信号处理程序。

=int raise(int sig)-----该函数会促使生成信号 sig。sig 参数与 SIG 宏兼容。

\--标准库 - <stdarg.h>\{

@1、简介：stdarg.h 头文件定义了一个变量类型 va\_list 和三个宏，这三个宏可用于在参数个数未知（即参数个数可变）时获取函数中的参数。 =可变参数的函数通在参数列表的末尾是使用省略号(,...)定义的。

@2、库变量：

=va\_list -----这是一个适用于 va\_start()、va\_arg() 和 va\_end() 这三个宏存储信息的类型。

@3、库宏：

=void va\_start(va\_list ap, last\_arg)-----这个宏初始化 ap 变量，它与 va\_arg 和 va\_end 宏是一起使用的。last\_arg 是最后一个传递给函数的已知的固定参数，即省略号之前的参数。

=type va\_arg(va\_list ap, type)-----这个宏检索函数参数列表中类型为 type 的下一个参数。

=void va\_end(va\_list ap)-----这个宏允许使用了 va\_start 宏的带有可变参数的函数返回。如果在从函数返回之前没有调用 va\_end，则结果为未定义。

\--标准库 - <stddef.h>\{

@1、简介：stddef .h 头文件定义了各种变量类型和宏。这些定义中的大部分也出现在其它头文件中。

@2、库变量：

=ptrdiff\_t----这是有符号整数类型，它是两个指针相减的结果。

=size\_t ------这是无符号整数类型，它是 sizeof 关键字的结果。

=wchar\_t -----这是一个宽字符常量大小的整数类型。

@3、库宏：

=NULL-----这个宏是一个空指针常量的值。

=offsetof(type, member-designator)-----这会生成一个类型为 size\_t 的整型常量，它是一个结构成员相对于结构开头的字节偏移量。成员是由 member-designator 给定的，结构的名称是在 type 中给定的。

\--标准库 - <stdio.h>\{

@1、简介：stdio .h 头文件定义了三个变量类型、一些宏和各种函数来执行输入和输出。

@2、库变量：

=size\_t ----这是无符号整数类型，它是 sizeof 关键字的结果。

=FILE ------这是一个适合存储文件流信息的对象类型。

=fpos\_t ----这是一个适合存储文件中任何位置的对象类型。

@3、库宏：

=NULL----这个宏是一个空指针常量的值。

=\_IOFBF、\_IOLBF 和 \_IONBF ----这些宏扩展了带有特定值的整型常量表达式，并适用于 setvbuf 函数的第三个参数。

=BUFSIZ----这个宏是一个整数，该整数代表了 setbuf 函数使用的缓冲区大小。

=EOF ------这个宏是一个表示已经到达文件结束的负整数。

=FOPEN\_MAX ----这个宏是一个整数，该整数代表了系统可以同时打开的文件数量。

=FILENAME\_MAX --这个宏是一个整数，该整数代表了字符数组可以存储的文件名的最大长度。如果实现没有任何限制，则该值应为推荐的最大值。

=L\_tmpnam ------这个宏是一个整数，该整数代表了字符数组可以存储的由 tmpnam 函数创建的临时文件名的最大长度。

=SEEK\_CUR、SEEK\_END 和 SEEK\_SET ---这些宏是在These macros are used in the fseek 函数中使用，用于在一个文件中定位不同的位置。

=TMP\_MAX -------这个宏是 tmpnam 函数可生成的独特文件名的最大数量。

=stderr、stdin 和 stdout ----------这些宏是指向 FILE 类型的指针，分别对应于标准错误、标准输入和标准输出流。

@4、库函数：

=int fclose(FILE \*stream)------关闭流 stream。刷新所有的缓冲区。

=void clearerr(FILE \*stream)---清除给定流 stream 的文件结束和错误标识符。

=int feof(FILE \*stream)--------测试给定流 stream 的文件结束标识符。

=int ferror(FILE \*stream)------测试给定流 stream 的错误标识符。

=int fflush(FILE \*stream)------刷新流 stream 的输出缓冲区。

=int fgetpos(FILE \*stream, fpos\_t \*pos)-----获取流 stream 的当前文件位置，并把它写入到 pos。

=FILE \*fopen(const char \*filename, const char \*mode)-----使用给定的模式 mode 打开 filename 所指向的文件。

=size\_t fread(void \*ptr, size\_t size, size\_t nmemb, FILE \*stream)-----从给定流 stream 读取数据到 ptr 所指向的数组中。

=FILE \*freopen(const char \*filename, const char \*mode, FILE \*stream)-----把一个新的文件名 filename 与给定的打开的流 stream 关联，同时关闭流中的旧文件。

=int fseek(FILE \*stream, long int offset, int whence)-----设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。

=int fsetpos(FILE \*stream, const fpos\_t \*pos)------设置给定流 stream 的文件位置为给定的位置。参数 pos 是由函数 fgetpos 给定的位置。

=long int ftell(FILE \*stream)---------返回给定流 stream 的当前文件位置。

=size\_t fwrite(const void \*ptr, size\_t size, size\_t nmemb, FILE \*stream)-----把 ptr 所指向的数组中的数据写入到给定流 stream 中。

=int remove(const char \*filename)-------删除给定的文件名 filename，以便它不再被访问。

=int rename(const char \*old\_filename, const char \*new\_filename)-----把 old\_filename 所指向的文件名改为 new\_filename。

=void rewind(FILE \*stream)------设置文件位置为给定流 stream 的文件的开头。

=void setbuf(FILE \*stream, char \*buffer)------定义流 stream 应如何缓冲。

=int setvbuf(FILE \*stream, char \*buffer, int mode, size\_t size)-----另一个定义流 stream 应如何缓冲的函数。

=FILE \*tmpfile(void)-----以二进制更新模式(wb+)创建临时文件。

=char \*tmpnam(char \*str)----生成并返回一个有效的临时文件名，该文件名之前是不存在的。

=int fprintf(FILE \*stream, const char \*format, ...)-----发送格式化输出到流 stream 中。

=int printf(const char \*format, ...)------发送格式化输出到标准输出 stdout。

=int sprintf(char \*str, const char \*format, ...)-----发送格式化输出到字符串。

=int vfprintf(FILE \*stream, const char \*format, va\_list arg)------使用参数列表发送格式化输出到流 stream 中。

=int vprintf(const char \*format, va\_list arg)-----使用参数列表发送格式化输出到标准输出 stdout。

=int vsprintf(char \*str, const char \*format, va\_list arg)---------使用参数列表发送格式化输出到字符串。

=int fscanf(FILE \*stream, const char \*format, ...)--------从流 stream 读取格式化输入。

=int scanf(const char \*format, ...)------从标准输入 stdin 读取格式化输入。

=int sscanf(const char \*str, const char \*format, ...)-----从字符串读取格式化输入。

=int fgetc(FILE \*stream)------从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。

=char \*fgets(char \*str, int n, FILE \*stream)--------从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

=int fputc(int char, FILE \*stream)------把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。

=int fputs(const char \*str, FILE \*stream)-------把字符串写入到指定的流 stream 中，但不包括空字符。

=int getc(FILE \*stream)------从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。

=int getchar(void)------从标准输入 stdin 获取一个字符（一个无符号字符）。

=char \*gets(char \*str)---从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

=int putc(int char, FILE \*stream)------把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。

=int putchar(int char)-----把参数 char 指定的字符（一个无符号字符）写入到标准输出 stdout 中。

=int puts(const char \*str)-----把一个字符串写入到标准输出 stdout，直到空字符，但不包括空字符。换行符会被追加到输出中。

=int ungetc(int char, FILE \*stream)-------把字符 char（一个无符号字符）推入到指定的流 stream 中，以便它是下一个被读取到的字符。

=void perror(const char \*str)------把一个描述性错误消息输出到标准错误 stderr。首先输出字符串 str，后跟一个冒号，然后是一个空格。

\--标准库 - <stdlib.h> \{

@1、简介：stdlib .h 头文件定义了四个变量类型、一些宏和各种通用工具函数。

@2、库变量：

=size\_t ----- 这是无符号整数类型，它是 sizeof 关键字的结果。

=wchar\_t ----- 这是一个宽字符常量大小的整数类型。

=div\_t ----- 这是 div 函数返回的结构。

=ldiv\_t ----- 这是 ldiv 函数返回的结构。

@3、库宏：

=NULL ---- 这个宏是一个空指针常量的值。

=EXIT\_FAILURE ----- 这是 exit 函数失败时要返回的值。

=EXIT\_SUCCESS ----- 这是 exit 函数成功时要返回的值。

=RAND\_MAX ----- 这个宏是 rand 函数返回的最大值。

=MB\_CUR\_MAX ----- 这个宏表示在多字节字符集中的最大字符数，不能大于 MB\_LEN\_MAX。

@4、库函数：

=double atof(const char \*str)---- 把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。

=int atoi(const char \*str) ----- 把参数 str 所指向的字符串转换为一个整数（类型为 int 型）。

=long int atol(const char \*str) ----- 把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。

=double strtod(const char \*str, char \*\*endptr) ------ 把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。

=long int strtol(const char \*str, char \*\*endptr, int base) ----- 把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。

=unsigned long int strtoul(const char \*str, char \*\*endptr, int base) ----- 把参数 str 所指向的字符串转换为一个无符号长整数（类型为 unsigned long int 型）。

=void \*calloc(size\_t nitems, size\_t size) ----- 分配所需的内存空间，并返回一个指向它的指针。

=void free(void \*ptr) ----- 释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。

=void \*malloc(size\_t size) ----- 分配所需的内存空间，并返回一个指向它的指针。

=void \*realloc(void \*ptr, size\_t size) ------ 尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。

=void abort(void) ------ 使一个异常程序终止。

=int atexit(void (\*func)(void)) ----- 当程序正常终止时，调用指定的函数 func。

=void exit(int status) ----- 使程序正常终止。

=char \*getenv(const char \*name) ----- 搜索 name 所指向的环境字符串，并返回相关的值给字符串。

=int system(const char \*string) ----- 由 string 指定的命令传给要被命令处理器执行的主机环境。

=void \*bsearch(const void \*key, const void \*base, size\_t nitems, size\_t size, int (\*compar)(const void \*, const void \*)) ---- 执行二分查找。

void qsort(void \*base, size\_t nitems, size\_t size, int (\*compar)(const void \*, const void\*)) ----- 数组排序。

=int abs(int x) ----- 返回 x 的绝对值。

=div\_t div(int numer, int denom) ----- 分子除以分母。

=long int labs(long int x) ----- 返回 x 的绝对值。

=ldiv\_t ldiv(long int numer, long int denom) ----- 分子除以分母。

=int rand(void) ----- 返回一个范围在 0 到 RAND\_MAX 之间的伪随机数。

=void srand(unsigned int seed) ------ 该函数播种由函数 rand 使用的随机数发生器。

=int mblen(const char \*str, size\_t n) ----- 返回参数 str 所指向的多字节字符的长度。

=size\_t mbstowcs(schar\_t \*pwcs, const char \*str, size\_t n) ----- 把参数 str 所指向的多字节字符的字符串转换为参数 pwcs 所指向的数组。

=int mbtowc(whcar\_t \*pwc, const char \*str, size\_t n) ----- 检查参数 str 所指向的多字节字符。

=size\_t wcstombs(char \*str, const wchar\_t \*pwcs, size\_t n) ----- 把数组 pwcs 中存储的编码转换为多字节字符，并把它们存储在字符串 str 中。

=int wctomb(char \*str, wchar\_t wchar) ----- 检查对应于参数 wchar 所给出的多字节字符的编码。

\--标准库 - <string.h>\{

@1、简介：string .h 头文件定义了一个变量类型、一个宏和各种操作字符数组的函数。

@2、库变量：size\_t ----- 这是无符号整数类型，它是 sizeof 关键字的结果。

@3、库宏：NULL ----- 这个宏是一个空指针常量的值。

@4、库函数：

=void \*memchr(const void \*str, int c, size\_t n) ----- 在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。

=int memcmp(const void \*str1, const void \*str2, size\_t n) ----- 把 str1 和 str2 的前 n 个字节进行比较。

=void \*memcpy(void \*dest, const void \*src, size\_t n) ----- 从 src 复制 n 个字符到 dest。

=void \*memmove(void \*dest, const void \*src, size\_t n) ----- 另一个用于从 str2 复制 n 个字符到 str1 的函数。

=void \*memset(void \*str, int c, size\_t n) ----- 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。

=char \*strcat(char \*dest, const char \*src) ---- 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。

=char \*strncat(char \*dest, const char \*src, size\_t n) ----- 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。

=char \*strchr(const char \*str, int c) ---- 在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。

=int strcmp(const char \*str1, const char \*str2) ----- 把 str1 所指向的字符串和 str2 所指向的字符串进行比较。

=int strncmp(const char \*str1, const char \*str2, size\_t n) ----- 把 str1 和 str2 进行比较，最多比较前 n 个字节。

=int strcoll(const char \*str1, const char \*str2) ----- 把 str1 和 str2 进行比较，结果取决于 LC\_COLLATE 的位置设置。

=char \*strcpy(char \*dest, const char \*src) ----- 把 src 所指向的字符串复制到 dest。

=char \*strncpy(char \*dest, const char \*src, size\_t n) ----- 把 src 所指向的字符串复制到 dest，最多复制 n 个字符。

=size\_t strcspn(const char \*str1, const char \*str2) ----- 检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。

=char \*strerror(int errnum) ----- 从内部数组中搜索错误号 errnum，并返回一个指向错误消息字符串的指针。

=size\_t strlen(const char \*str) ----- 计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。

=char \*strpbrk(const char \*str1, const char \*str2) ----- 检索字符串 str1 中第一个匹配字符串 str2 中字符的字符，不包含空结束字符。也就是说，依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置。

=char \*strrchr(const char \*str, int c) ----- 在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。

=size\_t strspn(const char \*str1, const char \*str2) ----- 检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。

=char \*strstr(const char \*haystack, const char \*needle) ----- 在字符串 haystack 中查找第一次出现字符串 needle（不包含空结束字符）的位置。

=char \*strtok(char \*str, const char \*delim) ----- 分解字符串 str 为一组字符串，delim 为分隔符。

=size\_t strxfrm(char \*dest, const char \*src, size\_t n) ----- 根据程序当前的区域选项中的 LC\_COLLATE 来转换字符串 src 的前 n 个字符，并把它们放置在字符串 dest 中。

\--标准库 - <time.h>\{

@1、简介：time.h 头文件定义了四个变量类型、两个宏和各种操作日期和时间的函数。

@2、库变量：

=size\_t ----- 是无符号整数类型，它是 sizeof 关键字的结果。

=clock\_t ----- 这是一个适合存储处理器时间的类型。

=time\_t is --- 这是一个适合存储日历时间类型。

=struct tm ---- 这是一个用来保存时间和日期的结构。

@3、库宏：

=NULL ----- 这个宏是一个空指针常量的值。

=CLOCKS\_PER\_SEC ----- 这个宏表示每秒的处理器时钟个数。

@4、库函数：

=char \*asctime(const struct tm \*timeptr) ----- 返回一个指向字符串的指针，它代表了结构 timeptr 的日期和时间。

=clock\_t clock(void) ----- 返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。

=char \*ctime(const time\_t \*timer) ----- 返回一个表示当地时间的字符串，当地时间是基于参数 timer。

=double difftime(time\_t time1, time\_t time2) ----- 返回 time1 和 time2 之间相差的秒数 (time1-time2)。

=struct tm \*gmtime(const time\_t \*timer) ---- timer 的值被分解为 tm 结构，并用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。

=struct tm \*localtime(const time\_t \*timer) ----- timer 的值被分解为 tm 结构，并用本地时区表示。

=time\_t mktime(struct tm \*timeptr) ----- 把 timeptr 所指向的结构转换为一个依据本地时区的 time\_t 值。

=size\_t strftime(char \*str, size\_t maxsize, const char \*format, const struct tm \*timeptr) ----- 根据 format 中定义的格式化规则，格式化结构 timeptr 表示的时间，并把它存储在 str 中。

=time\_t time(time\_t \*timer) ----- 计算当前日历时间，并把它编码成 time\_t 格式。

】