C语言快速参考手册

一.C语言常用参考表
-1.C语言的32个关键字
-2.C语言中变量的命名规则
-3.C语言中的转义字符
-4.C语言中的运算符
-5.C语言的运算符优先级
-6.printf()函数的输出控制符
-7.ASCⅡ码表
二.C语言控制流
-1.for循环
-2.while循环
-3.跳出循环
-4.if-else结构
-5.switch-case结构
-6.选择结构补充
三.C语言的复合数据类型
-1.数组
-2.结构体
-3.枚举
-4.共用体
四.C语言常用库函数
-1.标准输入和输出函数
-2.字符串处理函数
-3.字符处理函数
-4.数学函数
-5.实用程序函数
-6.内存管理函数
回到顶部

# C语言快速参考手册

## 一.C语言常用参考表<a name="C语言常用参考表"></a>

### 1.C语言的32个关键字<a name="C语言的32个关键字"></a>

C语言的关键字分为四个大类，一共32个关键字。

第一类：数据类型关键字（12个）。

| 编号  | 关键字      | 功能                   |
|:---:|:--------:| -------------------- |
| 1   | char     | 声明字符型变量或函数           |
| 2   | double   | 声明双精度变量或函数           |
| 3   | enum     | 声明枚举类型               |
| 4   | float    | 声明浮点型变量或函数           |
| 5   | int      | 声明整型变量或函数            |
| 6   | long     | 声明长整型变量或函数           |
| 7   | short    | 声明短整型变量或函数           |
| 8   | signed   | 声明有符号类型变量或函数         |
| 9   | struct   | 声明结构体变量或函数           |
| 10  | union    | 声明共用体（联合）数据类型        |
| 11  | unsigned | 声明无符号类型变量或函数         |
| 12  | void     | 声明函数无返回值或无参数，声明无类型指针 |

第二类：控制语句关键字（12个）。

| 编号  | 关键字      | 功能                        |
|:---:|:--------:| ------------------------- |
| 1   | for      | 一种循环语句，主要用来控制循环语句的执行      |
| 2   | do       | 循环语句的循环体，用在 do...while循环中 |
| 3   | while    | 循环语句的循环条件                 |
| 4   | break    | 跳出当前循环                    |
| 5   | continue | 结束当前循环，开始下一轮循环            |
| 6   | if       | 条件语句                      |
| 7   | else     | 条件语句否定分支（与 if 连用）         |
| 8   | goto     | 无条件跳转语句                   |
| 9   | switch   | 用于开关语句                    |
| 10  | case     | 开关语句分支                    |
| 11  | default  | 开关语句中的默认分支                |
| 12  | return   | 子程序返回语句（可以带参数，也看不带参数）     |

第三类：存储类型关键字（4个）。

| 编号  | 关键字      | 功能            |
|:---:|:--------:| ------------- |
| 1   | auto     | 声明自动变量，一般不使用  |
| 2   | extern   | 声明变量是在其它文件中声明 |
| 3   | register | 声明寄存器变量       |
| 4   | static   | 声明静态变量或者静态函数  |

第四类：其它关键字（4个）。

| 编号  | 关键字      | 功能                |
|:---:|:--------:| ----------------- |
| 1   | const    | 声明只读变量            |
| 2   | sizeof   | 计算数据类型长度          |
| 3   | typedef  | 用以给数据类型取别名        |
| 4   | volatile | 说明变量在程序执行中可被隐含地改变 |

### 2.C语言中变量的命名规则<a name="C语言中变量的命名规则"></a>

1. 变量名必须是单个词；

2. 变量名区分大小写；

3. 变量名最多不超过32个字符（根据编译器版本不同而不同）；

4. 变量名必须以字母或者下划线打头，之后可以是任意字母、数字或下划线；

5. 变量名中不允许使用下划线以外的标点符号；

6. 变量名不能使用C语言的关键字。

### 3.C语言中的转义字符<a name="C语言中的转义字符"></a>

| 转义字符 | 意义               | ASCII码值（十进制） |
| ---- | ---------------- | ------------ |
| \a   | 响铃（警报）           | 007          |
| \b   | 退格符，将当前位置移到前一列   | 008          |
| \f   | 换页符，将当前位置移到下页开头  | 012          |
| \n   | 换行符，将当前位置移到下一行开头 | 010          |
| \r   | 回车符，将当前位置移到本行开头  | 013          |
| \t   | 制表符，跳到下一个TAB位置   | 009          |
| \v   | 垂直制表符            | 011          |
| \\\  | 反斜杠符号            | 092          |
| \'   | 单引号符号            | 039          |
| \"   | 双引号符号            | 034          |
| \?   | 问号符号             | 063          |
| \0   | 空值符号             | 000          |

### 4.C语言中的运算符<a name="C语言中的运算符"></a>

1. **算术运算符**

| 编号 | 运算符 | 含义 | 运算示例 | 运算结果 |
|:---:|:---:| ------------ | ------------ | -------- |
| 1 | + | 加法 | 1+2 | 3 |
| 2 | - | 减法 一元相反数 | 2-1 -(6) | 1 -6 |
| 3 | * | 乘法 | 5*3 | 15 |
| 4 | / | 除法 | 5.0/3.0 | 1.666667 |
| 5 | % | 取模 | 5%3 | 2 |

2. **关系和比较运算符**

| 编号 | 运算符 | 含义 | 运算示例 | 运算结果 |
|:---:|:---:| ---- | ------------- | ------- |
| 1 | > | 大于 | 2>1 2>9 | 1 0 |
| 2 | >= | 大于等于 | 2>=1 2>=9 | 1 0 |
| 3 | < | 小于 | 2<1 2<9 | 0 1 |
| 4 | <= | 小于等于 | 2<=1 2<=9 | 0 1 |
| 5 | == | 等于 | 2==1 2==2 | 0 1 |
| 6 | != | 不等于 | 2!=1 2!=2 | 1 0 |

3. **逻辑运算符**

| 编号 | 逻辑运算符 | 说明 | 示例 | 示例运算结果 |
|:---:|:--------:| --- | ---------------------------- | ------------- |
| 1 | && | 逻辑与 | 1&&1 1&&0 0&&0 | 1 0 0 |
| 2 | '\|''\|' | 逻辑或 | 1\|\|1 1\|\|0 0\|\|0 | 1 1 0 |
| 3 | ! | 非运算 | !1 !0 | 0 1 |

4. **位运算符**

| 编号 | 逻辑运算符 | 说明 | 示例 | 示例运算结果 |
|:---:|:-----:| ---- | ---------------------- | ----------- |
| 1 | & | 按位与 | 1&1 1&0 0&0 | 1 0 0 |
| 2 | '\|' | 按位或 | 1\|1 1\|0 0\|0 | 1 1 0 |
| 3 | ~ | 按位取反 | ~1   ~0 | 0 1 |
| 4 | ^ | 按位异或 | 1^0 1^1 0^0 | 1 0 0 |
| 5 | << | 按位左移 | 0001<<2 | 0100（二进制） |
| 6 | >> | 按位右移 | 0100>>2 | 0001（二进制） |

5. **赋值运算符**

| 编号 | 运算符 | 运算示例 | 等效运算 |
| --- | ----- | ------------ | ----------------- |
| 1 | = | var = expr | 无 |
| 2 | += | var += expr | var = var + expr |
| 3 | -= | var -= expr | var = var - expr |
| 4 | *= | var *= expr | var = var * expr |
| 5 | /= | var /= expr | var = var / expr |
| 6 | %= | var %= expr | var = var % expr |
| 7 | &= | var &= expr | var = var & expr |
| 8 | ‘\|=’ | var \|= expr | var = var \| expr |
| 9 | ^= | var ^= expr | var = var ^ expr |
| 10 | >>= | var >>= expr | var = var >> expr |
| 11 | <<= | var <<= expr | var = var << expr |

### 5.C语言的运算符优先级<a name="C语言的运算符优先级"></a>

| 优先级 | 运算符 | 关联性（结合方式） |
|:---------:|:------------------------------------:|:---------:|
| 1（最高优先级） | () [] -> . | 左到右 |
| 2 | ! ~ ++ -- + - * & sizeof | 右到左 |
| 3 | * / % | 左到右 |
| 4 | + - | 左到右 |
| 5 | << >> | 左到右 |
| 6 | < <= > >= | 左到右 |
| 7 | == != | 左到右 |
| 8 | & | 左到右 |
| 9 | ^ | 左到右 |
| 10 | '\|' | 左到右 |
| 11 | && | 左到右 |
| 12 | '\|''\|' | 左到右 |
| 13 | ?= | 右到左 |
| 14 | = += -= *= /= %= &= ‘\|=’ ^= <<= >>= | 右到左 |
| 15（最低优先级） | , | 左到右 |

### 6.printf()函数的输出控制符<a name="printf()函数的输出控制符"></a>

| 控制符  | 说明                        | 支持的数据类型                                                          |
| ---- | ------------------------- | ---------------------------------------------------------------- |
| %d   | 按十进制整型数据的实际长度输出，常用。       | short int, int, signed short int, signed int, unsigned short int |
| %ld  | 按十进制长整型数据的实际长度输出。         | long int, signed long int                                        |
| %u   | 输出无符号整型数据，常用。             | unsigned int, unsigned short int                                 |
| %lu  | 输出无符号长整型数据。               | unsigned long int                                                |
| %f   | 输出实数，以小数形式输出，常用。          | float, double                                                    |
| %.mf | 输出实数时小数点后保留 m 位。          | float, double                                                    |
| %c   | 输出一个字符，常用。                | char                                                             |
| %s   | 输出字符串，常用。                 | 字符串                                                              |
| %x   | 以十六进制形式输出整数。              | unsigned short int, unsigned int                                 |
| %#x  | 以十六进制形式输出整数，数据前自动添加0x，常用。 | unsigned short int, unsigned int                                 |

通常情况下，整型数使用%d输出（无符合整型数使用%u输出），浮点数使用%f输出，字符使用%c输出，字符串使用%s输出，十六进制整数使用%#x输出。

### 7.ASCⅡ码表<a name="ASCⅡ码表"></a>

| Dec十进制 | Hex十六进制 | 缩写/字符 | 解释 |
|:------:|:-------:|:---------------------------:| ------ |
| 0 | 0x00 | NUL(null) | 空字符 |
| 1 | 0x01 | SOH(start of headline) | 标题开始 |
| 2 | 0x02 | STX (start of text) | 正文开始 |
| 3 | 0x03 | ETX (end of text) | 正文结束 |
| 4 | 0x04 | EOT (end of transmission) | 传输结束 |
| 5 | 0x05 | ENQ (enquiry) | 请求 |
| 6 | 0x06 | ACK (acknowledge) | 收到通知 |
| 7 | 0x07 | BEL (bell) | 响铃 |
| 8 | 0x08 | BS (backspace) | 退格 |
| 9 | 0x09 | HT (horizontal tab) | 水平制表符 |
| 10 | 0x0A | LF (NL line feed, new line) | 换行键 |
| 11 | 0x0B | VT (vertical tab) | 垂直制表符 |
| 12 | 0x0C | FF (NP form feed, new page) | 换页键 |
| 13 | 0x0D | CR (carriage return) | 回车键 |
| 14 | 0x0E | SO (shift out) | 不用切换 |
| 15 | 0x0F | SI (shift in) | 启用切换 |
| 16 | 0x10 | DLE (data link escape) | 数据链路转义 |
| 17 | 0x11 | DC1 (device control 1) | 设备控制1 |
| 18 | 0x12 | DC2 (device control 2) | 设备控制2 |
| 19 | 0x13 | DC3 (device control 3) | 设备控制3 |
| 20 | 0x14 | DC4 (device control 4) | 设备控制4 |
| 21 | 0x15 | NAK (negative acknowledge) | 拒绝接收 |
| 22 | 0x16 | SYN (synchronous idle) | 同步空闲 |
| 23 | 0x17 | ETB (end of trans. block) | 结束传输块 |
| 24 | 0x18 | CAN (cancel) | 取消 |
| 25 | 0x19 | EM (end of medium) | 媒介结束 |
| 26 | 0x1A | SUB (substitute) | 代替 |
| 27 | 0x1B | ESC (escape) | 换码(溢出) |
| 28 | 0x1C | FS (file separator) | 文件分隔符 |
| 29 | 0x1D | GS (group separator) | 分组符 |
| 30 | 0x1E | RS (record separator) | 记录分隔符 |
| 31 | 0x1F | US (unit separator) | 单元分隔符 |
| 32 | 0x20 | (space) | 空格 |
| 33 | 0x21 | ! | 感叹号 |
| 34 | 0x22 | " | 双引号 |
| 35 | 0x23 | # | 井号 |
| 36 | 0x24 | $ | 美元符号 |
| 37 | 0x25 | % | 百分号 |
| 38 | 0x26 | & | 和号 |
| 39 | 0x27 | ' | 闭单引号 |
| 40 | 0x28 | ( | 开括号 |
| 41 | 0x29 | ) | 闭括号 |
| 42 | 0x2A | * | 星号 |
| 43 | 0x2B | + | 加号 |
| 44 | 0x2C | , | 逗号 |
| 45 | 0x2D | - | 减号/破折号 |
| 46 | 0x2E | . | 句号 |
| 47 | 0x2F | / | 斜杠 |
| 48 | 0x30 | 0 | 字符0 |
| 49 | 0x31 | 1 | 字符1 |
| 50 | 0x32 | 2 | 字符2 |
| 51 | 0x33 | 3 | 字符3 |
| 52 | 0x34 | 4 | 字符4 |
| 53 | 0x35 | 5 | 字符5 |
| 54 | 0x36 | 6 | 字符6 |
| 55 | 0x37 | 7 | 字符7 |
| 56 | 0x38 | 8 | 字符8 |
| 57 | 0x39 | 9 | 字符9 |
| 58 | 0x3A | : | 冒号 |
| 59 | 0x3B | ; | 分号 |
| 60 | 0x3C | < | 小于号 |
| 61 | 0x3D | = | 等于号 |
| 62 | 0x3E | > | 大于号 |
| 63 | 0x3F | ? | 问号 |
| 64 | 0x40 | @ | 电子邮件符号 |
| 65 | 0x41 | A | 大写字母A |
| 66 | 0x42 | B | 大写字母B |
| 67 | 0x43 | C | 大写字母C |
| 68 | 0x44 | D | 大写字母D |
| 69 | 0x45 | E | 大写字母E |
| 70 | 0x46 | F | 大写字母F |
| 71 | 0x47 | G | 大写字母G |
| 72 | 0x48 | H | 大写字母H |
| 73 | 0x49 | I | 大写字母I |
| 74 | 0x4A | J | 大写字母J |
| 75 | 0x4B | K | 大写字母K |
| 76 | 0x4C | L | 大写字母L |
| 77 | 0x4D | M | 大写字母M |
| 78 | 0x4E | N | 大写字母N |
| 79 | 0x4F | O | 大写字母O |
| 80 | 0x50 | P | 大写字母P |
| 81 | 0x51 | Q | 大写字母Q |
| 82 | 0x52 | R | 大写字母R |
| 83 | 0x53 | S | 大写字母S |
| 84 | 0x54 | T | 大写字母T |
| 85 | 0x55 | U | 大写字母U |
| 86 | 0x56 | V | 大写字母V |
| 87 | 0x57 | W | 大写字母W |
| 88 | 0x58 | X | 大写字母X |
| 89 | 0x59 | Y | 大写字母Y |
| 90 | 0x5A | Z | 大写字母Z |
| 91 | 0x5B | [ | 开方括号 |
| 92 | 0x5C | \ | 反斜杠 |
| 93 | 0x5D | ] | 闭方括号 |
| 94 | 0x5E | ^ | 脱字符 |
| 95 | 0x5F | _ | 下划线 |
| 96 | 0x60 | ` | 开单引号 |
| 97 | 0x61 | a | 小写字母a |
| 98 | 0x62 | b | 小写字母b |
| 99 | 0x63 | c | 小写字母c |
| 100 | 0x64 | d | 小写字母d |
| 101 | 0x65 | e | 小写字母e |
| 102 | 0x66 | f | 小写字母f |
| 103 | 0x67 | g | 小写字母g |
| 104 | 0x68 | h | 小写字母h |
| 105 | 0x69 | i | 小写字母i |
| 106 | 0x6A | j | 小写字母j |
| 107 | 0x6B | k | 小写字母k |
| 108 | 0x6C | l | 小写字母l |
| 109 | 0x6D | m | 小写字母m |
| 110 | 0x6E | n | 小写字母n |
| 111 | 0x6F | o | 小写字母o |
| 112 | 0x70 | p | 小写字母p |
| 113 | 0x71 | q | 小写字母q |
| 114 | 0x72 | r | 小写字母r |
| 115 | 0x73 | s | 小写字母s |
| 116 | 0x74 | t | 小写字母t |
| 117 | 0x75 | u | 小写字母u |
| 118 | 0x76 | v | 小写字母v |
| 119 | 0x77 | w | 小写字母w |
| 120 | 0x78 | x | 小写字母x |
| 121 | 0x79 | y | 小写字母y |
| 122 | 0x7A | z | 小写字母z |
| 123 | 0x7B | { | 开花括号 |
| 124 | 0x7C | "\|" | 垂线 |
| 125 | 0x7D | } | 闭花括号 |
| 126 | 0x7E | ~ | 波浪线 |
| 127 | 0x7F | DEL (delete) | 删除 |

## 二.C语言控制流<a name="C语言控制流"></a>

### 1.for循环<a name="for循环"></a>

for循环是C语言中最常用的循环结构，简单示例：

```c
int i, sum=0;
for(i=1; i<=100; i++){
 sum += i;
}
printf("%d\n",sum);
```

### 2.while循环<a name="while循环"></a>

while循环是C语言中常用的循环结构，简单示例：

```c
int i=1, sum=0;
while(i<=100){
 sum += i;
 i++;
}
printf("%d\n",sum);
```

do-while循环是一种类似于while循环的循环结构，简单示例：

```c
int i=1, sum=0;
do{
 sum += i;
 i++;
}while(i<=100);
printf("%d\n", sum);
```

### 3.跳出循环<a name="跳出循环"></a>

当 break 关键字用于 while、for 循环时，会终止循环而执行整个循环语句后面的代码。break 关键字通常和 if 语句一起使用，即满足条件时便跳出循环。简单示例：

```c
int i=1, sum=0;
while(1){  //循环条件为死循环
  sum += i;
  i++;
  if(i>100) break;
}
printf("%d\n", sum);
```

continue 语句的作用是跳过循环体中剩余的语句而强制进入下一次循环。continue语句只用在 while、for 循环中，常与 if 条件语句一起使用，判断条件是否成立。

```c
char c = 0;
while(c!='\n'){  //回车键结束循环
  c = getchar();
  if(c=='4' || c=='5'){  //按下的是数字键4或5
    continue;  //跳过当次循环，进入下次循环
  }
  putchar(c);
}
```

break与continue的对比：break 用来结束所有循环，循环语句不再有执行的机会；continue 用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。

### 4.if-else结构<a name="if-else结构"></a>

if-else结构是C语言中最常用的选择结构（也叫分支结构），简单示例：

```c
if(判断条件){
    语句块1
}else{
    语句块2
}
```

当语句块中只有单个语句时，可以省略语句块的大括号，简单示例：

```c
if(age >= 18) printf("恭喜，你已经成年，可以使用该软件！\n");
else printf("抱歉，你还未成年，不宜使用该软件！\n");
```

在if-else结构中，可以省略else，即：

```c
if(判断条件){
    语句块
}
```

if-else 语句也可以多个同时使用，构成多个分支，形式如下：

```c
if(判断条件1){
    语句块1
}else  if(判断条件2){
    语句块2
}else  if(判断条件3){
    语句块3
}else  if(判断条件m){
    语句块m
}else{
     语句块n
}
```

### 5.switch-case结构<a name="switch-case结构"></a>

switch-case结构通常用来代替简单的、多个分支的if-else结构，简单示例：

```c
int a;
printf("Input integer number:");
scanf("%d",&a);
switch(a){
  case 1: printf("Monday\n"); break;
  case 2: printf("Tuesday\n"); break;
  case 3: printf("Wednesday\n"); break;
  case 4: printf("Thursday\n"); break;
  case 5: printf("Friday\n"); break;
  case 6: printf("Saturday\n"); break;
  case 7: printf("Sunday\n"); break;
  default:printf("error\n"); break;
}
```

switch-case结构的两点说明：

1. case 后面必须是一个整数，或者是结果为整数的表达式，但不能包含任何变量。

2. default 不是必须的。当没有 default 时，如果所有 case 都匹配失败，那么就什么都不执行。通常不省略default，而是default后面不写语句，与没有default等效。

### 6.选择结构补充<a name="选择结构补充"></a>

C语言提供了唯一的一个三目运算符即条件运算符?:，条件运算符可以替代简单的if-else结构，示例：

```c
int iMax(int a, int b)
{
  return a >= b ? a : b;
}
```

条件运算符可以使代码看起来更见简练。

## 三.C语言的复合数据类型<a name="C语言的复合数据类型"></a>

### 1.数组<a name="数组"></a>

C语言中一组相同数据类型的集合称为数组，数组所包含的每一个数据叫做数组元素，所包含的数据的个数称为数据长度（Length）。数组的定义方式：

```c
dataType  arrayName[Length];
```

数组定义示例：

```c
int m[10];  //定义一个长度为 10的int型数组
char ch[9];  //定义一个长度为 9 的字符型数组
```

需要注意的是：

1.  数组中每个元素的数据类型必须相同。

2. 数组长度 Length 最好是整数或者常量表达式。

3. 访问数组元素时，下标的取值范围为 0 ≤ index < length，过大或过小都会越界，导致数组溢出，发生不可预测的情况。

4. 数组是一个整体，它的内存是连续的。

数组的初始化有几种方式：

1. 在定义数组的同时赋值，示例：

```c
int a[4] = {20, 345, 700, 22};
```

当赋值的元素少于数组总体元素的时候，剩余的元素自动初始化为 0，示例：

```c
int a[6] = {0};  //所有元素自动初始化为 0
```

当给全部元素赋值时，可以不给出数组长度，示例：

```c
int a[] = {20, 345, 700, 22};  //等价于int a[4] = {20, 345, 700, 22};
```

2. 先定义数组，然后给数组赋值，示例：

```c
int a[10];
for(int i=0; i<10; i++){
 a[i] = 8;
}
```

二维数组定义的一般形式是：

```c
dataType arrayName[length1][length2];
```

为了便于理解，可以将二维数组看做一个表格，有行有列，length1 表示行数，length2 表示列数，要在二维数组中定位某个元素，必须同时指明行和列。

二维数组的初始化可以按行分段赋值，也可按行连续赋值，通常使用按行分段赋值（因为连续赋值容易出错），示例：

```c
int a[5][3]={{80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85}};
```

### 2.结构体<a name="结构体"></a>

在C语言中，可以使用结构体（struct）来存放一组不同类型的数据。结构体的定义形式为：

```c
struct 结构体名{
    结构体所包含的变量或数组
};
```

结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每个这样的变量或数组都称为结构体的成员。一个结构体的示例：

```c
struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在学习小组
    float score;  //成绩
};
```

结构体是一种数据类型，可以用它来定义变量。示例：

```c
struct stu stu1, stu2;
```

也可以在定义结构体的同时定义结构体变量：

```c
struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在学习小组
    float score;  //成绩
} stu1, stu2;
```

结构体和数组类似，也是一组数据的集合，整体使用没有太大的意义。结构体使用点号`.`获取单个成员。获取结构体成员的一般格式为：

```c
结构体变量名.成员名;
```

通过这种方式可以获取成员的值，也可以给成员赋值：

```c
stu1.name = "Tom";
stu1.num = 12;
stu1.age = 18;
stu1.group = 'A';
stu1.score = 136.5;
```

除了可以对成员进行逐一赋值，也可以在定义时整体赋值，例如：

```c
struct{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在小组
    float score;  //成绩
} stu1 = { "Tom", 12, 18, 'A', 136.5 };
```

对于有很多成员的大型结构体，结构体变量整体赋值时很容易出现成员错位的情况，为了避免出现这种情况，C语言还支持下面这种语法，类似于成员逐一赋值的整体赋值：

```c
struct stu Bangbang = {
  .name = "Bangbang",.num = 13,.age = 3,.group = 'A',.score = 98 };
```

不过整体赋值仅限于定义结构体变量的时候，在使用过程中只能对成员逐一赋值，这和数组的赋值非常类似。

需要注意的是，结构体是一种自定义的数据类型，是创建变量的模板，不占用内存空间；结构体变量才包含了实实在在的数据，需要内存空间来存储。

### 3.枚举<a name="枚举"></a>

C语言提供了一种枚举（Enum）类型，能够列出所有可能的取值，并给它们取一个名字。

枚举类型的定义形式为：

```c
enum typeName{ valueName1, valueName2, valueName3, ...... };
```

枚举示例：

```c
enum week{ Mon=1, Tues, Wed, Thurs, Fri, Sat, Sun };
enum week{ Mon=1, Tues=2, Wed=3, Thurs=4, Fri=5, Sat=6, Sun=7 };
```

枚举值默认从 0 开始，往后逐个加 1（递增），如果首个值不等于0的话则需要指定值。枚举类型变量需要存放的是一个整数int，因此枚举类型变量的长度与int相同。

### 4.共用体<a name="共用体"></a>

共用体也称作联合体，共用体的所有成员共同占用（即共用）同一段内存，修改一个成员会影响其余所有成员。共用体示例：

```c
union data{
    int n;
    char ch[4];
    float f;
};
union data a, b, c; //先定义共用体，再创建变量
union data{
    int n;
    char ch[4];
    float f;
} a, b, c;  //在定义共用体的同时创建变量
```

先定义共用体，再创建变量或者在定义共用体的同时创建变量都是正确的。共用体占用的内存等于最长的成员占用的内存，虽然共用体各个成员的长度可以不同，但实际应用中，通常将各个成员的长度设置为一样长，比如上述示例中共用体成员的长度都是4个字节。

共用体使用点号`.`获取单个成员，这一点与结构体相同。

## 四.C语言常用库函数<a name="C语言常用库函数"></a>

### 1.标准输入和输出函数<a name="标准输入和输出函数"></a>

使用标准输入和输出函数需要`#include <stdio.h>`。

| 函数                      | 函数说明                                  |
| ----------------------- | ------------------------------------- |
| scanf()                 | 从标准输入流 stdin（键盘） 读取输入，需要格式控制。         |
| printf()                | 把输出写入到标准输出流 stdout（屏幕） ，需要格式控制。       |
| int getchar(void)       | 读取一个可用的字符，并把它返回为一个整数。                 |
| int putchar(int c)      | 把字符输出到屏幕上，并返回相同的字符。                   |
| char *gets(char *s)     | 从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF。 |
| int puts(const char *s) | 把字符串 s 和一个尾随的换行符写入到 stdout。           |

在C语言中，输出通常使用printf()，读取单个字符通常使用getchar()（常与putchar()配合使用），读取字符串通常使用gets()（因为scanf()无法读取空格使用起来不方便），读取数字（包括整数与小数）则使用scanf()。

### 2.字符串处理函数<a name="字符串处理函数"></a>

使用字符串处理函数需要`#include <string.h>`，假设s和t是char *类型，cs和ct是const char *类型，n的类型为int。

| 函数 | 函数说明 |
| --------------------------------------------- | --------------------------------------------------------------------------- |
| char *strcpy(s, ct) | 字符串ct被复制到字符串s，包括终止空字符，返回值是s。 |
| char *strncpy(s, ct, n) | 从字符串ct复制最多n个字符到字符串s，返回值是s。 |
| char *strcat(s, ct) | 字符串ct被附加（连接）到字符串s，返回值是s。 |
| char *strncat(s, ct, n) | 从字符串ct最多附加（连接）n个字符到字符串s，返回值是s。 |
| int strcmp(cs, ct) | 将字符串cs与字符串ct进行比较。如果cs < ct，则返回值为负，如果cs==ct，则返回值为零，如果cs > ct，则返回值为正。 |
| int strcmp(cs, ct, n) | 将字符串ct中最多n个字符与字符串cs进行比较。如果cs < ct，则返回值为负，如果cs==ct，则返回值为零，如果cs > ct，则返回值为正。 |
| char *strchr(cs, c) | 搜索字符串cs以查找c的出现。返回值是指向cs中第一次出现c的位置的指针，如果在cs中找不到c，则返回NULL值。 |
| char *strrchr(cs, c) | 搜索字符串cs以查找c的出现。返回值是指向cs中最后一次出现c的位置的指针，如果在cs中找不到c，则返回NULL值。 |
| int strspn(cs, ct) | 搜索字符串cs以查找字符串ct中不存在的任何字符。返回值是cs中第一个不在ct中的字符的索引。 |
| int strcspn(cs, ct) | 搜索字符串cs以查找字符串ct中任何字符的出现。返回值是cs中第一个也可以在ct中找到的字符的索引。 |
| char *strpbrk(cs, ct) | 搜索字符串cs以查找字符串ct中任何字符的出现。返回值是指向cs中第一次出现ct字符的位置的指针，如果在cs中找不到ct字符，则返回NULL。 |
| char *strstr(cs, ct) | 搜索字符串cs以查找字符串ct的出现。返回值是指向cs中第一次出现ct的位置的指针，如果在cs中找不到ct，则返回NULL。 |
| int strlen(cs) | 计算字符串cs的长度并返回。 |
| void *memset(void *s, int ch, n) | 初始化函数，将s中当前位置后面的n个字节用 ch 替换，是对大数组进行清零操作的最快方法 。 |
| void *memcpy(void *str1, const void *str2, n) | 从str2所指的内存地址的起始位置开始拷贝n个字节到目标str1所指的内存地址的起始位置中。memcpy可以复制任意内容，例如字符串、数组、结构体等。 |

### 3.字符处理函数<a name="字符处理函数"></a>

使用字符处理函数需要`#include <ctype.h>`，字符处理函数的参数为int，函数的返回值也是int，如果满足条件则函数返回非零值，否则返回零。

| 函数              | 函数说明                             |
| --------------- | -------------------------------- |
| isupper(ch)     | 测试ch是否代表大写字母                     |
| islower(ch)     | 测试ch是否代表小写字母                     |
| isalpha(ch)     | 测试ch是否代表大写或者小写字母                 |
| isdigit(ch)     | 测试ch是否代表十进制数字                    |
| isalnum(ch)     | 测试ch是否代表大写字母、小写字母或者十进制数字         |
| iscntrl(ch)     | 测试ch是否代表控制字符，ASCII值为0到31的字符为控制字符 |
| isgraph(ch)     | 测试ch是否代表除空格外的打印字符                |
| isprint(ch)     | 测试ch是否代表包括空格的打印字符                |
| ispunct(ch)     | 测试ch是否代表空格、字母或数字之外的打印字符          |
| isspace(ch)     | 测试ch是否代表空格、换页、换行、回车、制表符或者垂直制表符   |
| isxdigit(ch)    | 测试ch是否代表十六进制数字                   |
| int tolower(ch) | 如果ch代表大写字母，则转换为小写字母，否则返回时不做任何更改  |
| int toupper(ch) | 如果ch代表小写字母，则转换为大写字母，否则返回时不做任何更改  |

### 4.数学函数<a name="数学函数"></a>

使用数学函数需要`#include <math.h>`和`#include <errno.h>`，假设u和v是求值为double类型常量的表达式。所有这些函数的返回类型都是double，角度的单位是弧度。

| 函数 | 函数说明 |
| ----------- | ----------------------------------------------------------------------------- |
| sin(u) | 计算u的正弦并返回。这里u是弧度表示的角度。 |
| cos(u) | 计算u的余弦并返回。这里u是弧度表示的角度。 |
| tan(u) | 计算u的正切并返回。这里u是弧度表示的角度。 |
| asin(u) | 计算u的反正弦并返回。这里u是-1.0和+1.0之间的正弦值。返回值是-Π/2和+Π/2弧度之间的角度。如果检测到域错误（参数超出范围），则返回值0.0。 |
| acos(u) | 计算u的反余弦并返回。这里u是-1.0和+1.0之间的余弦值。返回值是0和Π弧度之间的角度。如果检测到域错误，则返回值0.0。 |
| atan(u) | 计算u的反正切并返回。这里u是有符号切线值。返回值是-Π/2和+Π/2弧度之间的角度。 |
| atan2(u, v) | 计算u/v的反正切并返回。这里u和v代表任何带符号的值。返回值是-Π和+Π弧度之间的角度，其正切值为u/v。 |
| sinh(u) | 计算u的双曲正弦并返回。这里u是弧度表示的角度。如果发生溢出，则返回±(HUGE_VAL)的值。 |
| cosh(u) | 计算u的双曲余弦并返回。这里u是弧度表示的角度。如果发生溢出，则返回±(HUGE_VAL)的值。 |
| tanh(u) | 计算u的双曲正切并返回。这里u是弧度表示的角度。如果发生溢出，则返回±(HUGE_VAL)的值。 |
| exp(u) | 计算e的u次幂，其中e=2.7182818。如果发生下溢，则返回值0.0。如果发生溢出，则返回值HUGE_VAL。 |
| log(u) | 计算u的自然对数。这里u表示正浮点数，如果参数u为零或负数，则返回值-(HUGE_VAL)。 |
| log10(u) | 计算u的以10为底的对数。这里u表示正浮点数，如果参数u为零或负数，则返回值-(HUGE_VAL)。 |
| pow(u, v) | 计算u的v次幂。如果u==0且v<=0，或者如果u<0且v不是整数，则会发生域错误。如果发生溢出，则返回±(HUGE_VAL)的值。 |
| sqrt(u) | 计算u的平方根。这里u是非负数，如果u是负数，则返回零。 |
| ceil(u) | 计算大于或等于u的最小整数。 |
| floor(u) | 计算小于或等于u的最大整数。 |
| fabs(u) | 计算u的绝对值。 |
| fmod(u, v) | 计算u/v的余数，如果v为0.0，则返回值也为0.0。 |

### 5.实用程序函数<a name="实用程序函数"></a>

使用实用程序函数需要`#include <stdlib.h>`。

| 函数                                                                  | 函数说明                                                                                                               |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| double atof(const char *str)                                        | 将字符串str转换为double类型的数字并返回。例如，字符串"1.234"将转换为数字1.234，然后返回此数字。                                                         |
| int atoi(const char *str)                                           | 将字符串str转换为int类型的数字并返回。例如，字符串"1234"将转换为数字1234，然后返回此数字。                                                              |
| long atol(const char *str)                                          | 将字符串str转换为long类型的数字并返回。例如，字符串"1234"将转换为数字1234，然后返回此数字。                                                             |
| int rand(void)                                                      | 返回0到RAND_MAX范围内的伪随机整数。                                                                                             |
| void srand(unsigned int seed)                                       | 利用seed(一个整数)作为种子，用于通过函数rand()生成新的随机数。                                                                              |
| void abort(void)                                                    | 导致程序异常终止。                                                                                                          |
| void exit(int status)                                               | 导致程序正常终止。给此函数传递整数status以指示程序的状态。例如，传递整数0以指示程序的成功终止。预定义的常量EXIT_SUCCESS和EXIT_FAILURE也传递给该函数，分别表示程序的成功和失败。            |
| int abs(int num)                                                    | 返回int参数num的绝对值。                                                                                                    |
| long abs(long num)                                                  | 返回long参数num的绝对值。                                                                                                   |
| void qsort(void *base, size_t nitems, size_t size, int (*compar)()) | 数组排序函数。base-指向要排序的数组的第一个元素的指针。nitems-由 base 指向的数组中元素的个数。size-数组中每个元素的大小，以字节为单位。compar-用来比较两个元素的函数，通过此函数来实现不同方式的排序。 |

### 6.内存管理函数<a name="内存管理函数"></a>

使用内存管理函数需要`#include <stdlib.h>`。

| 函数                                        | 函数说明                                                                                     |
| ----------------------------------------- | ---------------------------------------------------------------------------------------- |
| void *calloc(int num, int size)           | 在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是0。 |
| void *malloc(int num)                     | 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。                                   |
| void *realloc(void *address, int newsize) | 该函数重新分配内存，把内存扩展到 newsize。                                                                |
| void free(void *address)                  | 该函数释放 address 所指向的内存块，释放的是动态分配的内存空间。                                                     |