C语言知识框架总结

一、数据类型

1、基本数据类型

整形

short（signed、unsigned）

示例：

short a;

short int a;

int（signed、unsigned）

示例：

int a;

long（signed、unsigned）

示例：

short a;

long int a;

浮点型

float

示例：

float a;

double(long)

示例：

long double a;

字符

char（signed、unsigned）

示例：

char a;

字符串（字符指针char*/字符数组char []/字符常量）

示例：

char* a=NULL;（指针最好初始化）

char a[];

"abcdef"(字符常量)

2、聚合数据类型

数组

一维数组（a[2]）

数组名是一个指向第一个元素地址的指针常量

定义：在一段地址连续的内存空间储存相同数据类型的集合

访问元素：下标访问[]，a[1]访问a中索引为1的元素

示例：

int a[2] = {1,2};//初始化一个整形数组

多维数组

数组名是指向第一行向量地址的指针常量

定义：int a[][];

下标运算：最右边[]里先变化

可以看出特殊的一维数组，只是数组中的元素也是数组，例如二维数组可以看成一维数组，其中元素也是一个一维数组

int a[2][2] = {{1,2},{3,4}};//在内存中是按照1,2,3,4存储的

指针数组（其中元素是指针）

char* a[];//将char*看成int一样的数据类型，只是数组元素不是int型而是字符指针类型

指针

 int* a;int i; int b[];

定义：存储地址的变量 

初始化：需要用&给指针赋值，  a = &i;a=b;

间接访问（*）： 访问存储地址上的对象

指针与数组：

*与[]：*（a+1）==a[1]==b[1]；

++: a++ a的地址加一

逻辑运算：指向同一数组的指针可以比较大小（任何指针都可以比较相等不相等）

混淆点：谁在最后就是谁，指针数组就是数组，元素是指针。int* 看做一个整体，相当于int，都是数据类型

指针数组：int * p[];数组元素类型是指针

数组指针：int (*p)[];指向数组的指针

指针函数（返回类型是指针的函数）：int* f();返回指向整形的指针，f是一个函数

函数指针(指向函数的指针)：int (*f)(); f是指向函数的指针 该函数返回整形

指针与地址：指针存放地址

NULL指针：不指向任何地址的指针

注意：.(成员运算符)、->、()、[]优先级最高

结构体(struct)

定义：不同类型数据的集合

struct a {成员表列} 变量表列；

a是标签

成员表列：类型说明符 成员名；

此时编译器不会给a分配内存空间，只有声明变量才会给变量分配地址

3种定义结构体类型变量的方法

1、先声明结构体类型再定义变量名

struct stu{};

struct stu stu1;

2、声明结构体类型的同时定义变量

struct stu{}stu1;

3、直接定义结构体变量

struct {} stu1;

初始化：struct a a1={x=1,x=2};

结构数组：元素类型是结构的数组

struct a a2[];

结构指针：指向结构类型的指针

struct a * a3;

结构成员访问：

a1.x;

a3->x;（*a3）.x

结构体自引用：

struct SELF_REF2{

                            int a;

                            struct SELF_REF2 *b;

                            int c;

};

结构体变量的引用

 结构体变量不能整体输入输出，要使用结构体成员运算符访问成员

printf("%s%c%d",stu1);

stu1.name;

可以整体赋值

stu2 = stu1;

只能对最低级成员进行赋值及运算

stu1.birth.moth;

可以引用结构体变量以及其成员的地址

结构指针变量做函数参数

1、结构体变量成员

2、结构体变量

3、结构体指针

联合（union）

定义：同一地址内存上不同时刻存放不同数据

union a {成员表列} 变量表列；

a：标签

成员表列：int a; float b;

变量表列：

a1,a2

初始化：

union {

int a;

float b;

char a[4];

} x={5};

成员访问：x.a;

枚举（enum）

定义

enum 枚举名{枚举元素1,枚举元素2,...};

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

 注意：第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。

可以在定义枚举类型时改变枚举元素的值：

enum season {spring, summer=3, autumn, winter};

 没有指定值的枚举元素，其值为前一元素加 1。也就说 spring 的值为 0，summer 的值为 3，autumn 的值为 4，winter 的值为 5

枚举变量的定义

前面我们只是声明了枚举类型，接下来我们看看如何定义枚举变量。

我们可以通过以下三种方式来定义枚举变量

1、先定义枚举类型，再定义枚举变量

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;

2、定义枚举类型的同时定义枚举变量

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

3、省略枚举名称，直接定义枚举变量

enum
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

示例

#include 
 
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
 
int main()
{
    enum DAY day;
    day = WED;
    printf("%d",day);
    return 0;
}

结果

3

在C 语言中，枚举类型是被当做 int 或者 unsigned int 类型来处理的，所以按照 C 语言规范是没有办法遍历枚举类型的。

不过在一些特殊的情况下，枚举类型必须连续是可以实现有条件的遍历。

以下实例使用 for 来遍历枚举的元素：

#include 
 
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
int main()
{
    // 遍历枚举元素
    for (day = MON; day <= SUN; day++) {
        printf("枚举元素：%d 
", day);
    }
}

结果

枚举元素：1 
枚举元素：2 
枚举元素：3 
枚举元素：4 
枚举元素：5 
枚举元素：6 
枚举元素：7

以下枚举类型不连续，这种枚举无法遍历。

enum
{
    ENUM_0,
    ENUM_10 = 10,
    ENUM_11
};

枚举在 switch 中的使用：

#include 
#include 
int main()
{
 
    enum color { red=1, green, blue };
 
    enum  color favorite_color;
 
    /* 用户输入数字来选择颜色 */
    printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");
    scanf("%u", &favorite_color);
 
    /* 输出结果 */
    switch (favorite_color)
    {
    case red:
        printf("你喜欢的颜色是红色");
        break;
    case green:
        printf("你喜欢的颜色是绿色");
        break;
    case blue:
        printf("你喜欢的颜色是蓝色");
        break;
    default:
        printf("你没有选择你喜欢的颜色");
    }
 
    return 0;
}

结果

请输入你喜欢的颜色: (1. red, 2. green, 3. blue): 1
你喜欢的颜色是红色

将整数转换为枚举

以下实例将整数转换为枚举：

#include 
#include 
 
int main()
{
 
    enum day
    {
        saturday,
        sunday,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday;
 
    int a = 1;
    enum day weekend;
    weekend = ( enum day ) a;  //类型转换
    //weekend = a; //错误
    printf("weekend:%d",weekend);
    return 0;
}

结果

weekend:1

二、控制流

1、顺序

语句程序块

例：

int i=1;

int a[3];

2、条件

if-else

switch

3、循环

while

do{}while

for()

三、函数

1、声明 函数原型

void printd();

2、定义

返回值类型 函数名 (参数列表)

{

        函数体

}

3、递归

直接间接调用自己，要有停止条件

四、动态存储分配

数组的长度是预定义好的，在整个程序中固定不变。C语言不允许动态数组类型

1、常用的内存管理函数有以下三个

分配内存空间函数 malloc、calloc

释放内存空间函数 free

2、malloc

函数原型:void* malloc(unsigned int size);

其作用是在内存的动态存储区中分配一个长度为size的连续空间(size是一个无符号数)，此函数的返回值是一个指向分配域起始地址的指针（void）

若此函数未能成功地执行（内存不足），返回空指针（NULL）；

int * p = (int*)malloc(200*sizeof(int));

3、calloc

函数原型

void* calloc(unsigned n,unsigned size);

其作用是在内存的动态存储区中分配n个长度为size的连续空间(size是一个无符号数)，此函数的返回值是一个指向分配域起始地址的指针（void）

若此函数未能成功地执行（内存不足），返回空指针（NULL）；用calloc函数可以为一维数组开辟存储空间，n是数组元素个数，每个元素长度为size；

int * p = (int*)malloc(200,sizeof(int));

4、free

函数原型

void free(void* p);

其作用是释放由p指向的内存区，使这个部分内存区能被其他变量使用。p是最近一次调用calloc或malloc函数时返回的值。

free(p);

五、头文件

访问方式

#include <头文件>

 1、输入输出：

定义输入输出函数、类型以及宏的数目占整个标准库的三分之一

流：是与磁盘或其他外围设备关联的数据的源或目的的。文本流、二进制流

打开一个流就是将把该流与一个文件或设备连接起来，关闭流将断开这种连接。

1.1文件操作

FILE *fopen(const char* filename, const char *mode);

fopen打开filename指定的文件，并返回一个与之相关联的流。若打开失败返回NULL。

mode:

"r"：打开文本文件用于读

"w"：创建文本文件用于写，并删除已存在的内容

"a"：追加；打开或创建文本文件，并向文件末尾追加内容

"r+"：打开文本文件用于更新（读和写）

"w+"：创建文本文件用于更新，并删除已存在的内容

"a+"：追加；打开或创建文本文件用于更新，写文件时追加到文件末尾

在上述访问模式之后加入b，如"rb"或"w+b"等，则表示对二进制文件进行操作。

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

freopen以mode打开filename指定的文件，并将该文件关联到stream指定的流。返回stream；若打开失败返回NULL。freopen函数一般用于改变与stdin、stdout、stderr相关联的文件。

int fflush(FILE *stream);

对输出流来说，fflush将已写到缓冲区但尚未写入文件的所有数据写到文件中。对输入流来说，其结果未定义。发生错误，返回EOF，否则返回0。

fflush(NULL)将清洗所有的输出流。

int fclose(FILE *stream);

将所有未写入的数据写入stream中，丢弃缓冲区中的所有未读输入数据，并释放自动分配的全部缓冲区，最后关闭流。若出错则返回EOF，否则返回0。

int remove(const char *filename);

删除filename指定的文件。失败返回非0值。

int rename(const char* oldname, const char *newname);

修改文件的名字。失败返回非0值。

FILE *tmpfile(void);

以模式"wb+"创建一个临时文件，该文件在被关闭或程序正常结束时将被自动删除。若创建成功，返回一个流，失败返回NULL。

1.2格式化输出

printf函数提供格式化输出转换。

int fprintf(FILE *stream, const char *format,...);

按照format说明的格式对输出进行转换，并写到stream流中。返回值是实际写入的字符数。若出错返回一个负值。

格式串由普通字符（将被复制到输出流中）与转换说明（分别决定下一后续参数的转换和打印，以%开头，以转换字符结束[%d]）

在%与转换字符之间可以依次包括下列内容：

标志，用于修改转换说明

         -：指定被转换的参数在其字段内左对齐

         +：指定在输出的数前面加上正负号

         空格：如果第一个字符不是正负号，则在其前面加上一个空格

         0：对于数值转换，当输出长度小于字段宽度时，添加前导0进行填充

         #：指定另一种输出形式。如果为o转换，则第一个数字为零；如果为x或X转换，则指定在输出值的非0值前加0x或0X；对于e、E、f、g或G转换，指定输出总包括一个小数点；           对于g或者G转换，指定输出值尾部无意义的0将被保留。

一个数值，用于指定最小字段宽度。

点号，用于分割字段宽度和精度

表示精度的数。

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

printf(...)等价于fprintf(stdout,...)

int sprintf(char * s, const char *format,...);

sprintf函数与printf函数基本相同，但其输出将被写入字符串s中，并以‘’结尾。

1.3格式化输入

int fscanf(FILE *stream, const char* format,...);

根据格式串format从流stream中读取输入，并把转换后的值赋值给后续各个参数，其中每个参数必须为指针。

int scanf(const char* format,...);

scanf(...)等价于fscanf(stdin,...)

int sscanf(const char *s,const char *format);

sscanf(s,...)函数与scanf(...)等价，不同的是，前者的输入字符来源于字符串s

1.4字符输入输出函数

int fgetc(FILE *stream);

返回stream中下一个字符。若到达文件末尾或发生错误，则返回EOF

char *fgets(char *s, int n, FILE *stream);

最多将下n-1个字符读入数组s中。若到达文件末尾或发生错误，则返回NULL。

int fputc(int c, FILE *stream);

把字符c（转换为unsigned char类型）输出到stream。返回写入的字符，若发生错误，则返回EOF

int fputs(const char *s, FILE *stream);

字符串s（不含' '）输出到stream。返回非负值，若发生错误，则返回EOF。

int getc(FILE *stream);

等价于fgetc，不同的是，当getc函数定义为宏时，他可能多次计算stream的值。

int getchar(void);

等价于getc(stdin)

char* gets(char *s);

把下一个输入行读入数组s中，并把末尾的换行符替换成字符''，返回字符串s，若到达文件末尾或发生错误，则返回NULL。

int putc(int c,FILE *stream);

等价于fputc，不同的是，当putc函数定义为宏时，他可能多次计算stream的值。

int putchar(int c);

putchar(c)==putc(c,stdout);

int puts(const char *s);

把字符串s和一个换行符输出到stdout中。发生错误返回EOF，否则返回非负值。

int ungetc(int c, FILE *stream)

把c写回到流stream中，下次对该流进行读操作时，将返回该字符。

1.5直接输入输出函数

size_t fread(void *ptr, size_t size, size_t nobj, FILE *stream);

从流stream中读取最多nobj个长度为size的对象，并保存到ptr指向的数组中。返回读取的对象数。

size_t fwrite(const void *ptr, size_t size, size_t nobj, FILE *stream);

从ptr指向的数组中读取nobj个长度为size的对象，并输出到流stream中。

1.6文件定位函数

int fseek(FILE *stream, long offset, int origin);

设置流stream的文件位置，后续的读写操作将从新位置开始。

long ftell(FILE *stream);

返回stream流的当前文件位置。

2、字符类别测试：

C 标准库的 ctype.h 头文件提供了一些函数，可用于测试和映射字符。

这些函数接受 int 作为参数，它的值必须是 EOF 或表示为一个无符号字符。

如果参数 c 满足描述的条件，则这些函数返回非零（true）。如果参数 c 不满足描述的条件，则这些函数返回零。

1	int isalnum(int c) 该函数检查所传的字符是否是字母和数字。
2	int isalpha(int c) 该函数检查所传的字符是否是字母。
3	int iscntrl(int c) 该函数检查所传的字符是否是控制字符。
4	int isdigit(int c) 该函数检查所传的字符是否是十进制数字。
5	int isgraph(int c) 该函数检查所传的字符是否有图形表示法。
6	int islower(int c) 该函数检查所传的字符是否是小写字母。
7	int isprint(int c) 该函数检查所传的字符是否是可打印的。
8	int ispunct(int c) 该函数检查所传的字符是否是标点符号字符。
9	int isspace(int c) 该函数检查所传的字符是否是空白字符。
10	int isupper(int c) 该函数检查所传的字符是否是大写字母。
11	int isxdigit(int c) 该函数检查所传的字符是否是十六进制数字。

标准库还包含了两个转换函数，它们接受并返回一个 "int"

1	int tolower(int c) 该函数把大写字母转换为小写字母。
2	int toupper(int c) 该函数把小写字母转换为大写字母。

3、字符串函数<string.h>

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

定义了两组字符串函数，一组函数的名字以str开头，一组以mem开头

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

size_t
这是无符号整数类型，它是 sizeof 关键字的结果

1	void *memchr(const void *str, int c, size_t n) 在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。
2	int memcmp(const void *str1, const void *str2, size_t n) 把 str1 和 str2 的前 n 个字节进行比较。
3	void *memcpy(void *dest, const void *src, size_t n) 从 src 复制 n 个字符到 dest。
4	void *memmove(void *dest, const void *src, size_t n) 另一个用于从 src 复制 n 个字符到 dest 的函数。
5	void *memset(void *str, int c, size_t n) 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
6	char *strcat(char *dest, const char *src) 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。
7	char *strncat(char *dest, const char *src, size_t n) 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。
8	char *strchr(const char *str, int c) 在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。
9	int strcmp(const char *str1, const char *str2) 把 str1 所指向的字符串和 str2 所指向的字符串进行比较。
10	int strncmp(const char *str1, const char *str2, size_t n) 把 str1 和 str2 进行比较，最多比较前 n 个字节。
11	int strcoll(const char *str1, const char *str2) 把 str1 和 str2 进行比较，结果取决于 LC_COLLATE 的位置设置。
12	char *strcpy(char *dest, const char *src) 把 src 所指向的字符串复制到 dest。
13	char *strncpy(char *dest, const char *src, size_t n) 把 src 所指向的字符串复制到 dest，最多复制 n 个字符。
14	size_t strcspn(const char *str1, const char *str2) 检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。
15	char *strerror(int errnum) 从内部数组中搜索错误号 errnum，并返回一个指向错误消息字符串的指针。
16	size_t strlen(const char *str) 计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。
17	char *strpbrk(const char *str1, const char *str2) 检索字符串 str1 中第一个匹配字符串 str2 中字符的字符，不包含空结束字符。也就是说，依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置。
18	char *strrchr(const char *str, int c) 在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。
19	size_t strspn(const char *str1, const char *str2) 检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。
20	char *strstr(const char *haystack, const char *needle) 在字符串 haystack 中查找第一次出现字符串 needle（不包含空结束字符）的位置。
21	char *strtok(char *str, const char *delim) 分解字符串 str 为一组字符串，delim 为分隔符。
22	size_t strxfrm(char *dest, const char *src, size_t n) 根据程序当前的区域选项中的 LC_COLLATE 来转换字符串 src 的前 n 个字符，并把它们放置在字符串 dest 中。

4、数学函数：<math.h>

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

1	double acos(double x) 返回以弧度表示的 x 的反余弦。
2	double asin(double x) 返回以弧度表示的 x 的反正弦。
3	double atan(double x) 返回以弧度表示的 x 的反正切。
4	double atan2(double y, double x) 返回以弧度表示的 y/x 的反正切。y 和 x 的值的符号决定了正确的象限。
5	double cos(double x) 返回弧度角 x 的余弦。
6	double cosh(double x) 返回 x 的双曲余弦。
7	double sin(double x) 返回弧度角 x 的正弦。
8	double sinh(double x) 返回 x 的双曲正弦。
9	double tanh(double x) 返回 x 的双曲正切。
10	double exp(double x) 返回 e 的 x 次幂的值。
11	double frexp(double x, int *exponent) 把浮点数 x 分解成尾数和指数。返回值是尾数，并将指数存入 exponent 中。所得的值是 x = mantissa * 2 ^ exponent。
12	double ldexp(double x, int exponent) 返回 x 乘以 2 的 exponent 次幂。
13	double log(double x) 返回 x 的自然对数（基数为 e 的对数）。
14	double log10(double x) 返回 x 的常用对数（基数为 10 的对数）。
15	double modf(double x, double *integer) 返回值为小数部分（小数点后的部分），并设置 integer 为整数部分。
16	double pow(double x, double y) 返回 x 的 y 次幂。
17	double sqrt(double x) 返回 x 的平方根。
18	double ceil(double x) 返回大于或等于 x 的最小的整数值。
19	double fabs(double x) 返回 x 的绝对值。
20	double floor(double x) 返回小于或等于 x 的最大的整数值。
21	double fmod(double x, double y) 返回 x 除以 y 的余数。

5、实用函数：<stdlib.h>

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

执行数值转换、内存分配以及其他类似工作的函数。

1	double atof(const char *str) 把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。
2	int atoi(const char *str) 把参数 str 所指向的字符串转换为一个整数（类型为 int 型）。
3	long int atol(const char *str) 把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。
4	double strtod(const char *str, char **endptr) 把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。
5	long int strtol(const char *str, char **endptr, int base) 把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。
6	unsigned long int strtoul(const char *str, char **endptr, int base) 把参数 str 所指向的字符串转换为一个无符号长整数（类型为 unsigned long int 型）。
7	void *calloc(size_t nitems, size_t size) 分配所需的内存空间，并返回一个指向它的指针。
8	void free(void *ptr) 释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。
9	void *malloc(size_t size) 分配所需的内存空间，并返回一个指向它的指针。
10	void *realloc(void *ptr, size_t size) 尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。
11	void abort(void) 使一个异常程序终止。
12	int atexit(void (*func)(void)) 当程序正常终止时，调用指定的函数 func。
13	void exit(int status) 使程序正常终止。
14	char *getenv(const char *name) 搜索 name 所指向的环境字符串，并返回相关的值给字符串。
15	int system(const char *string) 由 string 指定的命令传给要被命令处理器执行的主机环境。
16	void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *)) 执行二分查找。
17	void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*)) 数组排序。
18	int abs(int x) 返回 x 的绝对值。
19	div_t div(int numer, int denom) 分子除以分母。
20	long int labs(long int x) 返回 x 的绝对值。
21	ldiv_t ldiv(long int numer, long int denom) 分子除以分母。
22	int rand(void) 返回一个范围在 0 到 RAND_MAX 之间的伪随机数。
23	void srand(unsigned int seed) 该函数播种由函数 rand 使用的随机数发生器。
24	int mblen(const char *str, size_t n) 返回参数 str 所指向的多字节字符的长度。
25	size_t mbstowcs(schar_t *pwcs, const char *str, size_t n) 把参数 str 所指向的多字节字符的字符串转换为参数 pwcs 所指向的数组。
26	int mbtowc(whcar_t *pwc, const char *str, size_t n) 检查参数 str 所指向的多字节字符。
27	size_t wcstombs(char *str, const wchar_t *pwcs, size_t n) 把数组 pwcs 中存储的编码转换为多字节字符，并把它们存储在字符串 str 中。
28	int wctomb(char *str, wchar_t wchar) 检查对应于参数 wchar 所给出的多字节字符的编码。

6、日期与时间函数：<time.h>

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

库变量

1	size_t 是无符号整数类型，它是 sizeof 关键字的结果。
2	clock_t 这是一个适合存储处理器时间的类型。
3	time_t is 这是一个适合存储日历时间类型。
4	struct tm 这是一个用来保存时间和日期的结构。

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;       /* 夏令时                */
};

库函数

1	char *asctime(const struct tm *timeptr) 返回一个指向字符串的指针，它代表了结构 timeptr 的日期和时间。
2	clock_t clock(void) 返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。
3	char *ctime(const time_t *timer) 返回一个表示当地时间的字符串，当地时间是基于参数 timer。
4	double difftime(time_t time1, time_t time2) 返回 time1 和 time2 之间相差的秒数 (time1-time2)。
5	struct tm *gmtime(const time_t *timer) timer 的值被分解为 tm 结构，并用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。
6	struct tm *localtime(const time_t *timer) timer 的值被分解为 tm 结构，并用本地时区表示。
7	time_t mktime(struct tm *timeptr) 把 timeptr 所指向的结构转换为一个依据本地时区的 time_t 值。
8	size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr) 根据 format 中定义的格式化规则，格式化结构 timeptr 表示的时间，并把它存储在 str 中。
9	time_t time(time_t *timer) 计算当前日历时间，并把它编码成 time_t 格式。