websocket 升级协议时的协议切换点

C语言技能数（知识点汇总）

• C 语言概述
• • 特点
  • • 不足之处
  • 标准
  • 编程机制
• 数据类型
• • 变量
  • • 数据类型
    • 字符类型
    • 整数类型
    • • 符号位
      • 二进制的原码、反码和补码
    • 浮点类型
    • 布尔类型
  • 常量
  • • 字面常量
    • const 修饰的常变量
    • #define定义的标识符常量
    • 枚举常量
  • sizeof
  • • sizeof(结构体)
    • 不要对 void 类型使用 sizeof
    • 不要在子函数中对指针类型使用 sizeof
    • sizeof 的结果取决于环境
• 运算符与表达式
• 语句与控制流
• 函数与程序结构
• • 函数的声明和定义
  • 函数的参数
  • • 形式参数和实际参数
    • 数组作为实参进行传递
  • 函数的返回和嵌套
  • 函数的递归
  • 变量的作用域
  • • 局部变量
    • 全局变量
    • 注意事项
  • 头文件
  • • \#include
    • 头文件的引用
    • 头文件的内容
    • 示例
  • 内部函数和外部函数
  • • 外部函数 (extern)
    • 内部函数 (static)
• 数组
• • 数组的创建
  • 数组的使用
  • 二维数组
  • 变长数组
• 指针
• • 指针的声明
  • 指针的简单应用
  • NULL 指针
  • 指针的算术运算
  • 指针数组
  • 数组指针
  • 指向指针的指针
• 字符串
• • 字符
  • C 的字符串
  • 字符串输入与输出
  • • scanf 函数
    • gets 函数
    • fgets 函数
    • scanf 和 gets 的区别
    • printf 函数
    • puts 函数
    • fputs 函数
  • 字符串函数
  • • strcpy
    • strcat
    • strlen
    • strcmp
    • strchr
    • strstr
  • C++ 的字符串
• 枚举类型
• 结构体
• • 声明与定义
  • 结构体作为参数
  • 指向结构体的指针
  • 结构体占用的内存空间大小
  • 位域
  • 结构体小案例
• 联合体
• • 定义联合体与使用
  • 联合体作为参数
  • 指向联合体的指针
• 位运算
• • 位和字节
  • 进制数
  • • 十进制转二进制
    • 二进制转十进制
    • 八进制
    • 十六进制
  • 位逻辑运算符
  • • 与运算：&
    • 或运算：|
    • 非运算：~
    • 异或运算：^
    • 位移运算：<< 或 >>
    • 位运算赋值运算符
• 预处理器
• • #include
  • #define
  • #ifndef & #ifdef & #endif
  • #if & #elif & #else
  • #undef
• 文件
• 内存管理
• • 存储类别
  • • 自动变量 （auto）
    • 外部变量
    • 静态变量（static）
    • 寄存器变量（register）
    • 相关概念
    • • 作用域(scope)
      • 链接(linkage)
      • 存储期(storage duration)
    • 存储类别小结
  • 内存动态管理
  • • 栈上开辟空间
    • 动态内存函数
  • 常见动态内存错误
• 标准函数库
• • 数学库
  • • 三角函数（Trigonometric functions）
    • 指数函数（Exponential functions）
    • 对数函数（Logarithmic functions）
    • 幂函数（Power functions）
    • 平方根（square root）
    • 立方根（cube root）
    • 求斜边（hypotenuse）
    • 取整函数
    • 绝对值和最值
  • 通用工具库

C 语言概述

特点

1. C语言简洁、紧凑、灵活。C语言的核心内容很少，只有 32 个关键字，9 种控制语句；
2. 表达方式简练、实用。C语言有一套强有力的运算符，达44种
3. 具有丰富的数据类型。
4. 具有低级语言的特点。具有与汇编语言相近的功能和描述方法，如地址运算、二进制数位运算等，对硬件端口等资源直接操作，可充分使用计算机资源。
5. 是一种结构化语言，适合于大型程序的模块化设计。
6. 预处理命令和预处理程序。
7. 可移植性。
8. 生成的目标代码质量高。
9. C语言语法限制不严，程序设计自由度大。

不足之处

1. C程序的错误更隐蔽
2. C程序有时会难以理解
3. C程序有时会难以修改

标准

1. 1978年，丹尼斯·里奇(Dennis Ritchie)和布莱恩·科尔尼干(Brian Kernighan) 发布了 K&R C.
2. 1989年，美国国家标准局为其指定标准，称为 ANSI C，也称 C89.
3. 1990年，国际化标准组织为其指定标准，称为 ISO C，也称 C90.
4. 1999年，发布的ISO/IEC 9899:1999标准，称为 C99.
5. 2011年，美国国家标准局采纳了ISO/IEC 9899:2011标准，称为 C11.
6. 2018年，发布的ISO/IEC 9899:2018标准，称为 C18.

编程机制

1. 输入 .c 和 .h 等源码文件
2. 【预处理】宏展开（#include/#define/…）
3. 【编译器】编译成汇编代码，得到 .s 文件
4. 【汇编器】输出机器代码，得到 .o 或 .obj 文件
5. 【链接器】输出可执行文件，得到 .exe 文件

数据类型

变量

变量使用注意事项

1. 变量表示内存中的一个存储区域（不同的数据类型，占用的空间大小不一样）
2. 该区域有自己的名称和类型
3. 变量必须先声明，后使用
4. 该区域的数据可以在同一类型范围内不断变化
5. 变量在同一个作用域内不能重名
6. 变量三要素 (变量名+值+数据类型) 。

数据类型

注意：

1. 在c中没有字符串类型，使用字符数组 char[] 表示字符串
2. 在不同系统上，部分数据类型字节长度不一样，举例：int可以占两个字节或四个字节

字符类型

注意

1. 字符常量是用单引号括起来的单个字符。 例如： char c1 ='a'; char c3 = '9';
2. C中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n';
3. 在C中， char的本质是一个整数。字符型存储到计算机中，需要将字符对应的码值（整数）找出来。字符和码值的对应关系是通过字符编码表决定的。
4. 可以直接给char赋一个整数，然后输出时，会按照对应的ASCII 字符输出。
5. char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

整数类型

符号位

• 存放signed类型的存储单元中，左边第一位表示符号位。
• 如果该位为0，表示该整数是一个正数；如果该位为1，表示该整数是一个负数。
• 一个32位的整型变量，除去左边第一位符号位，剩下表示值的只有31个比特位。

注意

1. 各种类型的存储大小与操作系统、 系统位数和编译器有关 ，目前通用的以64位系统为主。

2. C语言的整型类型， 分为有符号 (signed) 和无符号 (unsigned) 两种， 默认是有符号的。

3. C程序中整型常声明为 int 型， 除非不足以表示大数， 才使用 long long。

4. 一个 B 等于 8 个 b

   • B 是 Byte 的缩写，意思是字节，是计算机存储容量的最基本的存储单元。
   • b 是 bit 的缩写，意思是比特位，是计算机中的存储数据的最小单位。指的是二进制中的一个位数。

5. 一个字节有八位二进制组成，即 1 Byte = 8 bit。

   • 通常用 Bit 来作数据传输的单位，因为物理层、数据链路层的传输对于用户是透明的。
   • 通常用 Byte 来作应用层的单位，比如表示文件的大小，在用户看来就是可见的数据大小。

二进制的原码、反码和补码

原码

反码

补码

浮点类型

注意

1. 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位 , 浮点数是近视值
2. 尾数部分可能丢失，造成精度损失。

浮点型使用细节

1. 浮点型常量默认为 double 型 ， 声明 float 型常量时， 须后加 f 或 F。
2. 浮点型常量有两种表示形式
   1. 十进制数形式：如： 5.12 512.0f .512 (必须有小数点）
   2. 科学计数法形式:如： 5.12e2 、 5.12E-2
3. 通常情况下，应该使用 double 型，因为它比float型更精确。
4. 格式化输出时，%f 默认输出 6 位小数，%.2f 可指定输出 2 位小数。

布尔类型

C语言标准(C99)提供了_Bool 型， _Bool 仍是整数类型，但与一般整型不同的是，_Bool 变量只能赋值为0或1，非0的值都会被存储为1。

C99还提供了一个头文件 <stdbool.h> 定义了 bool 代表 _Bool， true 代表1， false代表0

只要导入 stdbool.h ，就能方便的操作布尔类型了 , 比如 bool flag = false;

常量

字面常量

const 修饰的常变量

const int n = 10;
int arr[n] = { 0 };

• const 修饰的常变量，本质上是变量。
• 但具有常属性，不能被修改。
• 在C99标准之前，数组的大小只能是常量修饰，不支持变长数组。

#define定义的标识符常量

#define PI 3.14159
#define SIZE 10

• #define 又称宏定义，标识符为所定义的宏名，简称宏。
• 对宏定义而言，预编译的时候会将程序中所有出现“标识符”的地方全部用这个“常量”替换，称为“宏替换”或“宏展开”。
• 被定义的标识符不占内存，只是一个临时的符号，预编译后这个符号就会被宏替换。
• 宏所表示的常量可以是数字、字符、字符串、表达式。其中最常用的是数字。

枚举常量

enum Gender { Male, Female, Secret, Unknown };

在使用枚举常量的时候，需要注意以下几点：

• 不能对枚举常量赋值，只能将它们的值赋给其他的变量。
• 不能再定义与枚举常量名字相同的变量。
• 不能用 & 取得它们的地址。

sizeof

基本使用

• sizeof(object);
• sizeof object
• sizeof(type_name);

例如：

int n = 10;
printf("sizeof(n)=%d\n", sizeof(n));
printf("sizeof n =%d\n", sizeof n );
printf("sizeof(int)=%d\n", sizeof(int));

sizeof(结构体)

• 理论上讲结构体的各个成员在内存中是连续存放的，和数组非常类似，但是，结构体占用内存的总大小不一定等于全部成员变量占用内存大小之和。
• 在编译器的具体实现中，为了提高内存寻址的效率，各个成员之间可能会存在缝隙。
• 用 sizeof 可以得到结构体占用内容在总大小。
• sizeof(结构体名) 或 sizeof(结构体变量名) 都可以。

不要对 void 类型使用 sizeof

#include <stdio.h>

void func() {}

int main() {
	printf("sizeof(func)=%d\n", sizeof(func));
	// 输出结果：sizeof(func)=1
	return 0;
}

void *pv;
printf("sizeof(pv)=%d\n",sizeof(pv));
printf("sizeof(void*)=%d\n",sizeof(void *));
// 输出结果：
// sizeof(pv)=4
// sizeof(void*)=4

不要在子函数中对指针类型使用 sizeof

如果把一个字符串的地址传给子函数，子函数用一个字符指针（如char *pstr）来存放传入的字符串的地址，如果在子函数中用 sizeof(pstr)，得到的不是字符串占用内存的字节数，而是字符指针变量占用内存的字节数。

所以，不能在子函数中对传入的字符串进行初始化，除非字符串的长度也作为参数传入到了子函数中。

#include <stdio.h>

void func(char * pstr) {
	// sizeof(pstr)=4
	printf("sizeof(pstr)=%d\n", sizeof(pstr));
}

int main() {
	func("hello world!");
	return 0;
}

同理，也不要在子函数中对结构体指针用 sizeof，如果把一个结构体（如struct Human h）的地址传给子函数，子函数用一个结构体指针（如struct Human *h）来存放传入的结构体的地址，如果在子函数中用 sizeof(h)，得到的不是结构体占用内存的字节数，而是结构体指针变量占用内存的字节数。

正确的用法是用 sizeof(struct Human) 。

#include <stdio.h>

struct Human {char * name; int age;};

void func(struct Human *h) {
	// 错误的输出：sizeof(h)=4
	printf("sizeof(h)=%d\n", sizeof(h));
	// 正确的输出：sizeof(*h)=8
	printf("sizeof(*h)=%d\n", sizeof(*h));
	// 正确的输出：sizeof(struct Human)=8
	printf("sizeof(struct Human)=%d\n", sizeof(struct Human));
}

int main() {
	struct Human human = {"tom", 23};
	func(&human);
	return 0;
}

sizeof 的结果取决于环境

通过 systeminfo 指令可以获取当前系统的信息，部分如下：

主机名:           THINKPADX1
OS 名称:          Microsoft Windows 11 专业版
OS 制造商:        Microsoft Corporation
OS 配置:          独立工作站
系统制造商:       LENOVO
系统类型:         x64-based PC

可以看出，设备是基于 x64 的芯片，也就是收机器字长是 64。通过下面这段源代码观察不同 gcc 下的结果

#include<stdio.h>

int main() {
	char c = 'A';
	short s = 10; int i = 10; long l = 10L;
	float f = 3.14F; double d = 3.14D;
	int *p = &i;
	printf("char c = %c\t", c);
	printf("short s = %d\t", s);
	printf("int s = %d\t", i);
	printf("long s = %d\n", l);
	printf("float s = %f\t", f);
	printf("double s = %f\n", d);
	printf("*p = %d\n", *p);
	printf(" p = %p\n", p);
	printf("&p = %p\n", &p);
	printf("sizeof(char) = %d\n", sizeof(char));
	printf("sizeof(short) = %d\n", sizeof(short));
	printf("sizeof(int) = %d\n", sizeof(int));
	printf("sizeof(long) = %d\n", sizeof(long));
	printf("sizeof(float) = %d\n", sizeof(float));
	printf("sizeof(double) = %d\n", sizeof(double));
	printf("sizeof(size_t) = %d\n", sizeof(size_t));
    // size_t是一种机器相关的无符号类型，它被设计的足够大以便能表示内存中任意对象的大小。
    return 0;
}

我已经在本机的 D:\Program\MinGW 和 D:\Program\MinGW64 分别安装了 gcc 的32位版本和 64位版本。

在命令行中临时修改环境变量，用以切换 gcc 的寻址路径：

> SET PATH=C:\Windows\System32\;D:\Program\MinGW\bin
> WHERE gcc
D:\Program\MinGW\bin\gcc.exe

也可以通过 gcc -v 指令来查看当前 gcc 的版本，接下来使用 gcc 对上面的程序进行编译和执行，如下：

gcc app.c -o app.exe && app.exe

执行结果：

char c = A      short s = 10    int s = 10      long s = 10
float s = 3.140000      double s = 3.140000
*p = 10
 p = 0061FF04
&p = 0061FF00
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
sizeof(long) = 4
sizeof(float) = 4
sizeof(double) = 8
sizeof(size_t) = 4

然后在命令行中通过再次修改环境变量，来临时切换下 gcc 的寻址位置，如下所示：

> SET PATH=C:\Windows\System32\;D:\Program\MinGW64\bin
> WHERE gcc
D:\Program\MinGW64\bin\gcc.exe

再次使用 gcc 命令对上面的程序进行编码和执行，执行结果如下：

char c = A      short s = 10    int s = 10      long s = 10
float s = 3.140000      double s = 3.140000
*p = 10
 p = 000000000061FE04
&p = 000000000061FDF8
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
sizeof(long) = 4
sizeof(float) = 4
sizeof(double) = 8
sizeof(size_t) = 8

在基于 x64 的操作系统中安装两个不同版本的 gcc ，使用 sizeof 对基础类型测量的占用空间，得到结论如下：

可以明显看到：

• 基础数据类型占用的空间不会因为 gcc 的版本不同而不同的
• 即便是基于 x64 的平台，在 gcc 32 位的环境下，指针的长度也为 8

运算符与表达式

• 赋值运算符号

=、+=、-=、*=、/=、%=

• 算术运算符号

+、-、*、/、%

• 自运算符号：++ 和 --

  • 前缀：先运算后赋值
  • 后缀：先赋值后运算

• 关系运算符号

<、<=、>、>=、==、!=

• 逻辑运算符号

与(&&)、或(||)、非(!)

• 逗号运算符号

#include <stdio.h>

int main() {
	3, 4, 5;//这是一条语句
	int n = (3, 4, 5); // n 的值 5
	printf("n=%d\n", n);
	
	int a=3, b=4, c=5;
	int x=0;
	int y=((x=a+b),(b+c));
	// 等价于 y=b+c 致使 y 的值是 9
	printf("x=%d,y=%d\n", x, y);
	y=(x=a+b),(b+c);
	// 等价于 y=x=a+b 致使 y 的值是 7
	printf("x=%d,y=%d\n", x, y);
	return 0;
}

• 条件运算符号

int num = 2024;
printf("num is %s\n", num % 2 == 0 ? "even" : "odd");

语句与控制流

• 控制语句

// for 循环
for(int i = 0; i < 5; i++) {
	printf("%d\t", i);
}
printf("for end\n");

// do 循环
int i = 0;
do {
	printf("%d\t", i);
	i++;
} while(i < 5);
printf("do end\n");

// while 循环
i = 0;
while(i < 5) {
	printf("%d\t", i);
	i++;
}
printf("while end\n");

• 函数返回(return)

int main() {
	return 0;
}

• 转向语句

// for 循环
for(int i = 0; i < 5; i++) {
	printf("%d\t", i);
	if(i == 2) {
		goto end_flag;
	}
}
printf("for end\n");


end_flag:
printf("finish!\n");

• 函数调用语句

printf(“Hello world.”);

• 表达式语句

i++;

• 空语句

直接只有一个分号的一行语句。

• 复合语句，也称为代码块或者语句块

// 代码块
{
    int i = 10;
    printf("i=%d\n", i);
}
// 复合语句
{
    int i = 20;
    printf("i=%d\n", i);
}

函数与程序结构

函数的声明和定义

在 C 语言中，一般地，一个函数由函数头和函数体两部分组成。一般形式如下：

返回值类型  函数名 (参数1, 参数2, ...) {
    // 代码
}

上述形式中，大括号部分就是函数体，除了大括号的那一部分就被称之为函数头。

如果只有函数的声明，而没有函数的定义，那么程序将会在链接时出错

void fun1() {} // 该行是对函数 fun1 进行的定义
void fun2(); // 该行只是函数声明，并没有对该函数进行定义

int main() {
	return 0;
}

// 如下代码是对 fun2 函数进行具体的定义，如果不定义 fun2, 会在链接环节出现错误。
void fun2() {
	// statements here...
}

函数的参数

形式参数和实际参数

形式参数

实际参数

• 实参与形参必须个数相同
• 对应的形参和实参的类型必须一致

实参的传递方式

传值（值传递）

传址（址传递）

数组作为实参进行传递

传递数组元素

传递数组名称

#include <stdio.h>

void func(int *p) {
	printf("p=%p\n", p);
}
int main() {
	int ns[] = {3,4,5};
	func(ns);
	func(&ns); // warning: expected 'int *' but argument is of type 'int (*)[3]'
	func(&ns[0]);
	return 0;
}

上述三种传递的方式，形参 p 接收到的是同一个地址，如果 p 修改了地址中的值，ns 中的值也会跟着变化。

函数的返回和嵌套

• 如果需要从调用函数带回一个函数值（供主函数使用），被调函数中需包含return语句
• 函数的返回值通过函数中的 return 语句传递到调用行。
• 在定义函数时要指定函数值的类型，函数类型决定返回值的类型

int func(int a, int b) {
	return a + b;
}

函数的递归

#include<stdio.h>

// 阶乘：一个正整数的阶乘是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。
int factorial(int a) {
	if(a < 2) {
		return 1;
	}
	return a * factorial(a - 1);
}

int main() {	
	printf("5!=%d\n", factorial(5));
    return 0;
}

变量的作用域

局部变量

首先，它是一个变量，其次，这个变量只是在程序的局部范围内有效；局部变量定义可以定义在如下位置：

1. 函数的开头；
2. 函数内的复合语句内定义；
3. 形式参数；
4. 函数中间（非开头）；

程序执行到某个函数时，这个函数内部的局部变量将会被分配内存空间；局部变量在函数执行结束后，变量所占内存将会被释放；

全局变量

首先，它是变量，其次，它可以在全局范围内是有意义的变量；

所谓全局也并不是真正的全局，而是在定义处以下的范围内才是有效的；全局变量定义的位置:

1. 文件开头；
2. 函数前；
3. 函数后；
4. 文件结尾；

注意事项

• 为了区别全局变量和局部变量，往往大家在写程序的时候都喜欢将全局变量的首字母大写，而局部变量的首字母小写；

• 全局变量的优点和缺点：

  **优点：**C语言的函数，每次最多只能返回一个值，但是如果定义了全局变量，那么在这个变量的有效范围内，很多函数都能改变这个变量的值，所以增加了函数之间的联系，通过函数的调用可以得到一个或一个以上的值；
  缺点：（大量使用全局变量的情况下）

  1. 占内存：全局变量所占的内存空间不会像局部变量一样会被释放；
  2. 降低程序清晰性：无法随时确定定义的全局变量的值的大小；
  3. 降低通用性：程序设计时要求函数的“内聚性”强，函数与函数之间“耦合性”弱；定义全局变是一定要注意在有效范围内变量不能重名，并且当全局变量被跨文件调用的函数调用时，不能出现全局变量与所跨文件中存在重名变量，否则有可能会出错；所以，为了提高程序的可靠性，可移植性和可读性等，全局变量尽量少用；

头文件

#include

• #include 是C语言的预处理指令之一，在编译之前做的处理，预处理指令一般以 #开头
• #include 指令后面会跟着一个文件名，预处理器发现 #include 指令后，就会根据文件名去查找文件，并把这个文件的内容包含到当前文件中。
• 被包含文件中的文本将替换源文件中的 #include 指令，就像是把被包含文件中的全部内容拷贝到这个 #include 指令所在的位置一样。
• 所以第一行的 #include <stdio.h> 指令的作用是将 stdio.h 文件里面的所有内容拷贝到第一行中。
• 如果被包含的文件拓展名为 .h，我们称之为 头文件 (Header File)
• 头文件可以用来声明函数，要想使用这些函数，就必须先用 #include 指令包含函数所在的头文件
• #include 指令不仅仅限于 .h 文件，可以包含任何编译器能识别的 C/C++ 代码文件，如 .c、.hpp、.cpp 等，甚至 .txt、.abc 等文本文件都可以
• #include 使用的是相对路径，也可以使用绝对路径。比如#include "/Users/apple/Desktop/my.txt"

#include <> 和 #include ""的区别

1. 对于使用双引号 "" 来 include 文件，搜索的时候按以下顺序：

• 先在这条 include 指令所在的文件的所在文件夹内搜索
• 如果上一步找不到，则在该文件的父级目录内搜索；
• 如果上一步找不到，则在编译器设置的 include 路径内搜索；
• 如果上一步找不到，则在系统的 INCLUDE 环境变量内搜索

2. 对于使用尖括号 <> 来 include 文件，搜索的时候按以下顺序：

• 在编译器设置的 include 路径内搜索；
• 如果上一步找不到，则在系统的 INCLUDE 环境变量内搜索

头文件的引用

• include 是可以包含 .c 源文件的，在某些工程里可以看到，但是这样的做法不常见也不推荐；
• include 关键字包含 .c 源文件和 .h 头文件，理解都是一样的，在原地将引用的文件展开；

头文件的内容

头文件名的格式为 "_头文件名_" ，注意要大写

#ifndef 头文件名 	
#define 头文件名

头文件内容

#endif

示例

#ifndef _APP_H 	
#define _APP_H

void func(int n);

#endif

#include <stdio.h>
#include "app.h"

int main() {
	func(10);
	return 0;
}

void func(int n) {
	printf("n=%d\n", n);
}

内部函数和外部函数

外部函数 (extern)

定义外部函数的方式，在函数的返回值类型前面添加 extern 关键字

extern int add(int x,int y);

举例来说外部函数：

• 第一个源文件 other.c

#include <stdio.h>

int add(int a, int b) {
	int c = a + b;
	printf("call add(%d,%d)=%d\n", a, b, c);
	return a + b;
}

• 第二个源文件 app.c

// 该行的 extern 可省略
// 该行也可以直接删除，但不显式声明 add 函数的话，编译器会报警告
extern int add(int x,int y); 

int main() {
	add(3,4);
	return 0;
}

在调用方的源文件中，可以不用 #include 指令来引入定义方的源文件，使用 gcc 对这两个文件进行编译即可：

gcc other.c app.c

编译器通过 extern 关键字会明确地知道，add 函数是定义在其他文件中的外部函数。

在本例中，app.c 作为调用方，省略 extern 关键字也可以正常运行。但是必须在调用方的源文件中声明需要调用的函数的声明，否则会在编译时报警告，但依然能输出调用结果，如下所示：

app.c: In function 'main':
app.c:6:2: warning: implicit declaration of function 'add' [-Wimplicit-function-declaration]
  add(3,4);
  ^~~

内部函数 (static)

举个例子来说明内部函数：

• 第一个源文件 other.c

#include <stdio.h>

void func() {
	printf("func in other.c\n");
}

• 第二个源文件 app.c

#include <stdio.h>

static void func() {
	printf("func in app.c\n");
}

int main() {
	func();
	return 0;
}

在调用方的源文件中，可以不用 #include 指令来引入定义方的源文件，使用 gcc 对这两个文件进行编译即可：

gcc other.c app.c

编译器通过 static 关键字会明确地知道，func 函数是仅供内部使用的。故而在 main 方法中调用 func 函数的时候，输出的结果自然是 func in app.c 。

如果将第二个文件中的 static 去掉，会在编译过程中抛出 multiple definition 的错误信息。致使无法得到最后的目标程序。

如果在 app.c 中直接删除 func 函数的定义，输出的结果就会是 func in other.c 。但同时也会出现警告，因为 main 中的 func 是作为外部函数来进行调用的，而 app.c 中又不存在该函数的声明。

思考：如果在 other.c 中定义一个函数，默认是可以在 app.c 中作为外部函数进行调用的，那使用 static 修饰后，在 app.c 中又显示注明需要调用外部函数，会出现什么结果呢？

• 第一个源文件 other.c

#include <stdio.h>

static void func() {
	printf("func in other.c\n");
}

• 第二个源文件 app.c

extern void func();

int main() {
	func();
	return 0;
}

执行编译后，出现 undefined reference to func' 的异常，编译不通过，删除 other.c 中的 static 关键字删除后，就可以正常编译通过了。编译器通过 extern 关键字知道调用方源文件中需要使用外部函数 func ，但是能够在 other.c 中被找到的 func 函数使用了 static 关键字修饰，也就不能允许外部源文件调用。故而将该函数视作是未定义进而抛出编译时异常。

数组

数组的创建

一维数组创建示例：

int ns[5];
// 数组创建，[]中要给一个常量才可以，不要使用变量。
const int N = 10;
int ms[N];

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。

char cs1[] = "abc";
char cs2[3] = {'a','b','c'};

数组的使用

int ns[] = {2, 5, 4};
int len = sizeof(ns) / sizeof(ns[0]);
printf("sizeof(ns)=%d\n", sizeof(ns));
printf("sizeof(ns[0])=%d\n", sizeof(ns[0]));
printf("len=%d\n", len);

1. 数组的大小可以通过计算得到。
2. 数组在内存中是连续存放的。

二维数组

int ns1[3][4];
// ns1 可视作 3x4 的矩阵，如下所示：
// □ □ □ □
// □ □ □ □
// □ □ □ □
int ns2[2][3] = {3,5,7};
// ns2 可视作 2x3 的矩阵，如下所示：
// 3 5 7
// □ □ □
int ns3[3][3] = {{2,4},{6}};
// ns3 可视作 3x3 的矩阵，如下所示：
// 2 4 □
// 6 □ □
// □ □ □

// 双层循环以遍历二维数组
for(int i=0;i<3;i++) {
    for(int j=0;j<3;j++) {
        printf("(%d,%d)=%d\t", i, j, ns3[i][j]);
    }
    printf("\n");
}

数组越界

• 数组的下标是有范围限制的。
• 数组的下规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。
• 所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
• C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。
• 二维数组的行和列也可能存在越界。

变长数组

数组变量本身表达的就是地址。在 C 中，数组变量就是一个特殊常量指针，也称之为数组指针。

可以利用 malloc 进行动态创建指定长度的数组，如下所示：

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

int main(void) {
    int size = 12, i=0;
    int* const p = (int*)malloc(size*(sizeof(int)));
	
	// 为所有下标位置赋值
    for (i=0;i<size; i++) {
        p[i] = i;
    }
	// 输出所有下标位置的值
    for (i = 0; i <size; i++) {
        printf("%d,", p[i]);
    }
	
    free(p);
    return 0;
}

指针

指针的声明

指针是一个变量，其值是另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：type* var-name; 如下例所示：

#include<stdio.h>

int main() {
	// 声明一个 int 类型的指针
	int* ip;
	// 声明一个 long 类型的指针
	long *lp;
	// 声明一个 double 类型的指针
	double* dp;
	// 声明一个 float 类型的指针
	float* fp;

	printf("size of int pointer is %d.\n", sizeof(ip));
	printf("size of long pointer is %d.\n", sizeof(lp));
	printf("size of double pointer is %d.\n", sizeof(dp));
	printf("size of float pointer is %d.\n", sizeof(fp));
	
	return 0;
}

执行结果：

size of int pointer is 4.
size of long pointer is 4.
size of double pointer is 4.
size of float pointer is 4.

在声明的时候，* 无论是偏向数据类型的关键字还是偏向变量名称，都是被认为是合法的。也就是说：int *ip; 和 int* ip; 都是正确的声明方式。但是当多个变量在同一个声明语句时候，需要使用 *ip 的形式。例如：

int *a, *b;		// 声明两个 int 类型的指针变量，分别是 a 和 b
int a, *b, c;	// 声明一个 int 类型的指针变量 b，变量 a 和 c 都是普通的 int 变量。

因为指针变量存储的值是一个地址值，所以，无论什么类型的指针，都不会影响其本身需要占用内存的空间。由于指针变量接受的是地址值，所以，在给指针变量赋值的时候需使用到取址符 &，如下例所示：

#include<stdio.h>

int main() {
	int number = 10;
	int* ip = &number;
	
	printf("number is %d\n", number);
	printf("&number is %d\n", &number);
	
	printf("ip is %d\n", ip);
	printf("&ip is %d\n", &ip);
	printf("*ip is %d\n", *ip);
	
	return 0;
}

执行结果：

number is 10
&number is 2293564
ip is 2293564
&ip is 2293560
*ip is 10

既然指针也是变量，那根据上面得到的结果对照到表格中来看：

指针是一种特殊的变量，其存储的数据不是一个可以直接被人识别的数字，或者文本，而是某个其他变量的内存地址值。

指针的简单应用

借助指针，可以对该内存地址的数据进行读写。如如下例：

#include<stdio.h>

int main() {
	int a = 10;
	int* ip = &a;
	
	printf("a  is %d,\t &a  is %d\n", a, &a);
	printf("ip is %d \t &ip is %d \t *ip is %d\n", ip, &ip, *ip);
	
	// 修改指针所指向的内存地址（2293564）中的值
	*ip = 100;
	
	printf("a  is %d,\t &a  is %d\n", a, &a);
	printf("ip is %d \t &ip is %d \t *ip is %d\n", ip, &ip, *ip);
		
	return 0;
}

执行结果：

a  is 10,        &a  is 2293564
ip is 2293564    &ip is 2293560          *ip is 10
a  is 100,       &a  is 2293564
ip is 2293564    &ip is 2293560          *ip is 100

这样不需要变量 a 就能实现修改变量 a 所存储的值。

在执行过程中，也可以修改指针的存储的地址值为其他的变量。如下所示：

#include<stdio.h>

int main() {
	int a = 10, b = 20;
	int* ip = &a;
	
	printf("a  is %d,\t &a  is %d\n", a, &a);
	printf("b  is %d,\t &b  is %d\n", b, &b);
	printf("ip is %d \t &ip is %d \t *ip is %d\n", ip, &ip, *ip);
	*ip *= 2;
	printf("a  is %d,\t &a  is %d\n", a, &a);
	printf("b  is %d,\t &b  is %d\n", b, &b);
	printf("ip is %d \t &ip is %d \t *ip is %d\n", ip, &ip, *ip);
	ip = &b;
	*ip *= 3;
	printf("a  is %d,\t &a  is %d\n", a, &a);
	printf("b  is %d,\t &b  is %d\n", b, &b);
	printf("ip is %d \t &ip is %d \t *ip is %d\n", ip, &ip, *ip);
	
	return 0;
}

执行结果：

a  is 10,        &a  is 2293564
b  is 20,        &b  is 2293560
ip is 2293564    &ip is 2293556          *ip is 10
a  is 20,        &a  is 2293564
b  is 20,        &b  is 2293560
ip is 2293564    &ip is 2293556          *ip is 20
a  is 20,        &a  is 2293564
b  is 60,        &b  is 2293560
ip is 2293560    &ip is 2293556          *ip is 60

这里的指针 ip 先指向的是变量 a 的地址，在对该地址的数据进行累乘操作后，指向了变量 b 的地址，又对变量 b 的地址中的值进行了累乘操作。最终 a 的值被乘以 2，b 的值被乘以3。

NULL 指针

如果在声明一个指针的时候，没有为其赋予确切的地址值，那指针可能会指向一个未知的地址。如下例所示：

#include<stdio.h>

int main() {
	int *a, *b;
	printf("a=%d, *a=%d, b=%d, *b=%d\n", a, *a, b, *b);
	return 0;
}

执行结果：

a=2293540, *a=4200720, b=2147344384, *b=0

在没有为指针变量 a 和 b 赋予地址值的时候，既然还能有值，并且能读取到该地址里的值。因为一旦指针存储了地址值后，可以对该地址进行修改操作，可能会出现一些不该出现的现象，比如某个地方的变量的值因为这个指针的原因被修改了之类的。

如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值作为初始值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。

因为在 C 中，把任何非零和非空的值假定为 true，把零或 null 假定为 false，所以，当一个指针是空指针的时候，是可以被判断的。这也有利于后面更加顺利地操作指针。代码如下：

#include<stdio.h>

int main() {
	int a = 10;
	int* ip = NULL;
	printf("a  is %d,\t &a  is %d\n", a, &a);
	
	if(ip) {
		printf("ip is not null pointer.\n");
	} else {
		printf("ip is null pointer.\n");
		ip = &a;
	}
	*ip *= 2;
	printf("ip is %d \t &ip is %d \t *ip is %d\n", ip, &ip, *ip);
	
	return 0;
}

执行结果：

a  is 10,        &a  is 2293564
ip is null pointer.
ip is 2293564    &ip is 2293560          *ip is 20

当然，在该程序中 ip 自然是为空指针，但当 ip 作为一个函数参数的时候，对指针判空的处理就很重要了，因为不知道外部传递的指针到底是否是空的。

指针的算术运算

指针是一种存储其他变量地址值的特殊变量，同时也能进行简单的算数运算和逻辑运算。运用自运算遍历数组一种常见的指针应用。

#include<stdio.h>

int main() {
	int i, size = 7;
	int nums[7] = {101, 202, 303, 404, 505, 606, 707};
	int *p = NULL;
	p = nums;
	for(i = 0; i < size; i++) {
		printf("nums[%d] = %d, p==%d, *p=%d\n", i, nums[i], p, *p);
		p++;
	}
	return 0;
}

执行结果：

nums[0] = 101, p==2293528, *p=101
nums[1] = 202, p==2293532, *p=202
nums[2] = 303, p==2293536, *p=303
nums[3] = 404, p==2293540, *p=404
nums[4] = 505, p==2293544, *p=505
nums[5] = 606, p==2293548, *p=606
nums[6] = 707, p==2293552, *p=707

因为数组变量在内存中是以连续的内存空间来存储数据的，故而，p = nums; 等价于 p = &nums[0]; 也就是说，将数组 nums 的地址值赋予给指针，等价于将数组中第一个元素的地址值赋值给指针。

从输出的结果上来看也会发现，连续的每个元素的地址相差 4 位，这个值正是在开篇使用 sizeof 量出来的指针的大小是一致的。

那既然 p = nums; 等价于 p = &nums[0]; 那将数组中最后一个元素的地址值赋予给指针做自减运算输出会怎么样。代码如下：

#include<stdio.h>

int main() {
	int i, size = 7;
	int nums[7] = {101, 202, 303, 404, 505, 606, 707};
	int *p = NULL;
	p = &nums[size - 1];
	for(i = size - 1; i > -1; i--, p--) {
		printf("nums[%d] = %d, p==%d, *p=%d\n", i, nums[i], p, *p);
	}
	return 0;
}

执行结果：

nums[6] = 707, p==2293552, *p=707
nums[5] = 606, p==2293548, *p=606
nums[4] = 505, p==2293544, *p=505
nums[3] = 404, p==2293540, *p=404
nums[2] = 303, p==2293536, *p=303
nums[1] = 202, p==2293532, *p=202
nums[0] = 101, p==2293528, *p=101

因为数组中每个元素的地址是连续的，当指针指向第一个元素的时候，只要指针指向的地址没有超过最后一位，就能进行循环取值。这里就需要对指针中存储的地址值进行比较，示例代码如下：

#include<stdio.h>

int main() {
	int size = 7;
	int nums[7] = {101, 202, 303, 404, 505, 606, 707};
	int *p = nums; // 等价于 &nums[0]
	while(p <= &nums[size - 1]) {
		printf("%d ", *p);
		p++;
	}
	return 0;
}

执行结果：

101 202 303 404 505 606 707

指针数组

指针数组往往是用于存储一系列相同类型的指针的集合。其声明的一般形式为：type* var-name[size];，例如：

int* ps[3];

在理解指针的时候，可以类比变量，同样的，理解指针数组可以类比数组。

这样一来，很容易理解指针数组了，它就是一系列指针的集合。他们不一定是连续的，就像数组中的数据不一定是连续的数字的道理一样。这里使用一个案例来对指针数组和普通数组进行对比：

#include<stdio.h>

int main() {
	int i, a = 101, b = 202, c = 303, size = 3;
	
	int nums[3];
	nums[0] = a;
	nums[1] = b;
	nums[2] = c;
	
	int* ps[3];
	ps[0] = &a;
	ps[1] = &b;
	ps[2] = &c;
	
	// 输出各个变量的值
	for(i = 0; i < size; i++) {
		printf("nums[%d]=%d, &nums[%d]=%d\n", i, nums[i], i, &nums[i]);
	}	
	printf("\na=%d, &a=%d, b=%d, &b=%d, c=%d, &c=%d\n\n", a, &a, b, &b, c, &c);
	for(i = 0; i < size; i++) {
		printf("ps[%d]=%d, *ps[%d]=%d, &ps[%d]=%d\n", i, ps[i], i, *ps[i], i, &ps[i]);
	}
	
	// 修改指针指向的地址中的值
	for(i = 0; i < size; i++) {
		*ps[i] *= 10;
	}
	
	// 再次输出各个变量的值
	printf("\n------------------\n");
	for(i = 0; i < size; i++) {
		printf("nums[%d]=%d, &nums[%d]=%d\n", i, nums[i], i, &nums[i]);
	}	
	printf("\na=%d, &a=%d, b=%d, &b=%d, c=%d, &c=%d\n\n", a, &a, b, &b, c, &c);
	for(i = 0; i < size; i++) {
		printf("ps[%d]=%d, *ps[%d]=%d, &ps[%d]=%d\n", i, ps[i], i, *ps[i], i, &ps[i]);
	}
	
	return 0;
}

执行结果：

nums[0]=101, &nums[0]=2293536
nums[1]=202, &nums[1]=2293540
nums[2]=303, &nums[2]=2293544

a=101, &a=2293556, b=202, &b=2293552, c=303, &c=2293548

ps[0]=2293556, *ps[0]=101, &ps[0]=2293524
ps[1]=2293552, *ps[1]=202, &ps[1]=2293528
ps[2]=2293548, *ps[2]=303, &ps[2]=2293532

------------------
nums[0]=101, &nums[0]=2293536
nums[1]=202, &nums[1]=2293540
nums[2]=303, &nums[2]=2293544

a=1010, &a=2293556, b=2020, &b=2293552, c=3030, &c=2293548

ps[0]=2293556, *ps[0]=1010, &ps[0]=2293524
ps[1]=2293552, *ps[1]=2020, &ps[1]=2293528
ps[2]=2293548, *ps[2]=3030, &ps[2]=2293532

从执行结果来看，指针数组中存储的三个指针，修改这三个指针对应地址的值，会影响变量 a, b, c，但是不影响数组 nums。因为在给数组赋值的时候，是将变量 a, b, c 的值赋予了数组 nums，也就是 传值。给指针数组赋值的时候，是将变量 a, b, c 的地址值赋予了 ps，也就是 传址。这样就更加好理解指针数组了，数组是一系列相同数据类型的数据的集合，而指针数组是一系列相同数据类型的指针的集合。

数组指针

在 C 中，数组到底是什么？

现象一：

在上文中的 指针的算术运算 段落中的内容可以知道：p = nums; 等价于 p = &nums[0];。

分析：

赋值运算符 = 两边的数据类型在一致的时候才能将右值赋予左边的变量，如果不是因为数据类型发生了隐式转换，那就是符号两边的数据类型本就是一致的。这是不是能说明数组变量 nums 就是一个指针？如果是这样，那这个指针存储的值难道是数组中第一个元素的地址？如果是这样，那就能解释为什么在给指针 p 赋值的时候，nums 不需要 & 作为前缀了。

现象二：

回顾在之前的变量学习中，可以知道，变量的赋值可以是这样的：

int a = 10; int b = 20; b = a;

最终变量 b 的值变成了 20，那同样的代码，数组能这样使用吗？比如：

int a[] = {1, 2}; int b[] = {3, 4}; b = a;

程序在编译的时候会抛出一个错误信息：

error: assignment to expression with array type
  b = a;
    ^

分析：

为什么这里会提示数组类型的变量在声明之后不允许使用赋值表达式？这个现象和常量很相似，常量在定义完成之后，也是不允许为其赋值。这是不是能说明数组是一个常量？

解释：

在 C 中，数组变量就是一个特殊常量指针，也称之为数组指针。它有如下特点：

1. 数组变量本身表达的就是地址。所以 nums == &nums[0]
2. 运算符 [] 可以对数组做运算，也可以对指针做运算。所以 p[0] 等价于 nums[0]
3. 运算符 * 可以对指针做运算，也可以对数组做运算。所以 *nums 是被允许的
4. 数组变量是 const 的指针，所以不允许被赋值。也就是说 int nums[] 等价于 int * const nums

实例：

#include<stdio.h>

#define SIZE 6
int main() {

	int nums[SIZE] = {101, 202, 303, 404, 505, 606};
	int *p = nums;
	
	// nums 和 p 都能使用运算符 *
	printf("*p=%d, *nums=%d\n", *p, *nums);
	printf(" p=%p, nums=%p\n", p, nums);
	printf("&p=%p, &nums=%p\n", &p, &nums);
	
	// nums 和 p 都能使用逻辑运算符
	printf("p <= &nums[1] is %s\n", p <= &nums[1] ? "true" : "false");
	printf("nums < &nums[1] is %s\n", nums < &nums[1] ? "true" : "false");
	
	// nums 和 p 都能使用下标来操作元素
	for(int i = 0; i < SIZE; i++) {
		printf("nums[%d]=%d, &nums[%d]=%p, p[%d]=%d, &p[%d]=%p\n", i, nums[i], i, &nums[i], i, p[i], i, &p[i]);
	}
	
	// nums 是常量指针，故而不能做自运算
	while(p < &nums[SIZE - 1]) {
		p++;
		// error: lvalue required as increment operand
		// nums++;
		printf("p=%p, *p=%d, nums=%p, *nums=%d\n", p, *p, nums, *nums);
	}
	
	return 0;
}

执行结果：

*p=101, *nums=101
 p=0022FF24, nums=0022FF24
&p=0022FF20, &nums=0022FF24
p <= &nums[1] is true
nums < &nums[1] is true
nums[0]=101, &nums[0]=0022FF24, p[0]=101, &p[0]=0022FF24
nums[1]=202, &nums[1]=0022FF28, p[1]=202, &p[1]=0022FF28
nums[2]=303, &nums[2]=0022FF2C, p[2]=303, &p[2]=0022FF2C
nums[3]=404, &nums[3]=0022FF30, p[3]=404, &p[3]=0022FF30
nums[4]=505, &nums[4]=0022FF34, p[4]=505, &p[4]=0022FF34
nums[5]=606, &nums[5]=0022FF38, p[5]=606, &p[5]=0022FF38
p=0022FF28, *p=202, nums=0022FF24, *nums=101
p=0022FF2C, *p=303, nums=0022FF24, *nums=101
p=0022FF30, *p=404, nums=0022FF24, *nums=101
p=0022FF34, *p=505, nums=0022FF24, *nums=101
p=0022FF38, *p=606, nums=0022FF24, *nums=101

指向指针的指针

我们知道指针存储的是其他变量的的地址值，而指针本身也是一个变量，那一个指针指向的变量正好也是一个指针变量呢？这种情况被称之为指向指针的指针。

指向指针的指针在声明的时候必须比被指向的指针变量多一个星号，如下所示：

#include<stdio.h>

int main() {
	int num = 10;
	int *p = &num;
	int **ip = &p;
	int ***ipp = &ip;
	printf("num=%d, &num=%d\n", num, &num);
	printf("p=%d, *p=%d, &p=%d\n", p, *p, &p);
	printf("ip=%d, *ip=%d, &ip=%d\n", ip, *ip, &ip);
	printf("ipp=%d, *ipp=%d, &ipp=%d\n", ipp, *ipp, &ipp);
	return 0;
}

执行结果：

num=10, &num=2293564
p=2293564, *p=10, &p=2293560
ip=2293560, *ip=2293564, &ip=2293556
ipp=2293556, *ipp=2293560, &ipp=2293552

如果上例中的指针 ipp 指向指针 p 会在编译的时候抛出一个警告：

warning: initialization of 'int ***' from incompatible pointer type
 'int **' [-Wincompatible-pointer-types]
  int ***ipp = &p;
               ^

但是还是会编译通过，执行结果是：

num=10, &num=2293564
p=2293564, *p=10, &p=2293560
ip=2293560, *ip=2293564, &ip=2293556
ipp=2293560, *ipp=2293564, &ipp=2293552

指针 ipp 最终还是成功指向了指针 p，虽然这样做是可行的，但不建议这样去写。

如果按照正常的方式去编写，这种指向指针的指针能最多能写多少个星号呢？目前貌似没有找到相关资料来解释这个问题。就下面的案例来看，能写到至少 6 颗星。

#include<stdio.h>

int main() {
	int num = 10;
	int *p = &num;
	int **ip = &p;
	int ***ipp = &ip;
	int ****ippp = &ipp;
	int *****ipppp = &ippp;
	int ******ippppp = &ipppp;
	printf("num=%d, &num=%d\n", num, &num);
	printf("p=%d, *p=%d, &p=%d\n", p, *p, &p);
	printf("ip=%d, *ip=%d, &ip=%d\n", ip, *ip, &ip);
	printf("ipp=%d, *ipp=%d, &ipp=%d\n", ipp, *ipp, &ipp);
	printf("ippp=%d, *ippp=%d, &ippp=%d\n", ippp, *ippp, &ippp);
	printf("ipppp=%d, *ipppp=%d, &ipppp=%d\n", ipppp, *ipppp, &ipppp);
	printf("ippppp=%d, *ippppp=%d, &ippppp=%d\n", ippppp, *ippppp, &ippppp);
	return 0;
}

执行结果：

num=10, &num=2293564
p=2293564, *p=10, &p=2293560
ip=2293560, *ip=2293564, &ip=2293556
ipp=2293556, *ipp=2293560, &ipp=2293552
ippp=2293552, *ippp=2293556, &ippp=2293548
ipppp=2293548, *ipppp=2293552, &ipppp=2293544
ippppp=2293544, *ippppp=2293548, &ippppp=2293540

字符串

字符

关键字 char 可以用来声明一个字符变量。char 变量既是一种整数（最小的整数类型），也是一种特殊的字符类型。如下所示：

#include<stdio.h>

int main() {
	char c = 'A';
	printf("c=%d, c=%c", c, c);
	return 0;
}

执行结果：

c=65, c=A

可以发现，字符 A 在输出的时候，既可以使用数字格式输出，也可以使用字符格式输出，原因是它的数据类型是 char 类型，是一种既是整型又是字符的数据类型。既然是整型，那就能进行算数运算。如下例：

#include<stdio.h>

int main() {
	char c = 'A' + 1;
	printf("c=%d, c=%c", c, c);
	return 0;
}

执行结果：

c=66, c=B

实际上，char 能将字符 A 进行算数运算的原因是它的每个字符都有对应的无符号整型的数据与之对应。从这里的例子中可以知道，字符 A 对应的整数是 65，字符 B 对应的整数就是 66，如果进行 'Z' - 'A' 的运算，能得到与整数 26对应的字符。

这种字符和整数对应关系的标准被称之为 ASCII (American Standard Code for Information Interchange)，即美国信息交换标准代码，ASCII 码表的具体内容如下：

所以，char 类型的数据对应的整型数据的取值范围应该在 [0, 127] 之间。使用循环可以将其全部输出并查看：

#include<stdio.h>

int main() {
	for(char c = 0; c < 128; c++) {
		printf("c=%d, c=%c\n", c, c);
		if(c < 0) {
			break;
		}
	}
	return 0;
}

因为 char 的最大值是 127, 如果当变量 c 是 127 的时候，再执行自增操作，则 c 的最高位会被进位为 1，就被解释为负数了，故而，需要在循环体中做判断 c < 0 就跳出循环的操作，否则该循环将成为无限循环。

C 的字符串

很多资料在描述 C 的字符串的时候，说在 C 中，字符数组就是字符串，其实不完全正确。根据定义，字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。换句话说，如果一个字符数组中的最后一个元素不是 NULL 字符，那这个字符数组不能称之为字符串。示例如下：

#include<stdio.h>

int main() {
	char a[] = {'H', 'e', 'l', 'l', 'o'};
	char b[] = {'H', 'e', 'l', 'l', 'o', '\0'};
	char c[] = "Hello";
	printf("sizeof(a) is %d, &a=%p, a=%s\n", sizeof(a), &a, a);
	printf("sizeof(b) is %d, &b=%p, b=%s\n", sizeof(b), &b, b);
	printf("sizeof(c) is %d, &c=%p, c=%s\n", sizeof(c), &c, c);
	return 0;
}

执行结果：

sizeof(a) is 5, &a=0022FF3B, a=Hello
sizeof(b) is 6, &b=0022FF35, b=Hello
sizeof(c) is 6, &c=0022FF2F, c=Hello

这里的变量 a, b, c 都是字符数组，但变量 a 是不能被称之为是 C 的字符串的，因为根据定义，它的最后一个元素的不是 NULL 字符。

那为什么变量 c 能被称之为是字符串呢？原因是在编写源程序的时候，不需要把 null 字符放在字符串常量的末尾。编译器会在初始化数组时，自动把 '\0' 放在字符串的末尾。也就是说，C 在编译的时候，将字符串字面量 "Hello" 分解成了一个以 NULL 字符结尾的字符数组。这也就是为什么使用 sizeof 运算变量 c 的时候，得到的值是 6 的原因，因为在字符 o 的后面还有一个 NULL 字符。可以简单的理解为 "Hello" 等价于 {'H', 'e', 'l', 'l', 'o', '\0'}。

在之前以 指针 为主题的文章中说：在 C 中，数组变量就是一个特殊常量指针，也称之为数组指针。那也就是说在上面的例子中，变量 a, b, c 也都是指针。换句话说，字符串变量也是一个指针变量。

同样的，把之前数组指针的案例修改下，更改数据类型为 char，然后增加输出格式 %c。得到如下代码：

#include<stdio.h>

#define SIZE 6

int main() {

	char cs[SIZE] = {'H', 'e', 'l', 'l', 'o', '\0'};
	char *p = cs;
	
	// cs 和 p 都能使用运算符 *
	printf("*p=%d, *cs=%d, *cs=%c\n", *p, *cs, *cs);
	printf(" p=%p, cs=%p\n", p, cs);
	printf("&p=%p, &cs=%p\n", &p, &cs);
	
	// cs 和 p 都能使用逻辑运算符
	printf("p <= &cs[1] is %s\n", p <= &cs[1] ? "true" : "false");
	printf("cs < &cs[1] is %s\n", cs < &cs[1] ? "true" : "false");
	
	// cs 和 p 都能使用下标来操作元素
	for(int i = 0; i < SIZE; i++) {
		printf("cs[%d]=%d, cs[%d]=%c, &cs[%d]=%p, p[%d]=%d, &p[%d]=%p\n", i, cs[i], i, cs[i], i, &cs[i], i, p[i], i, &p[i]);
	}
	
	// cs 是常量指针，故而不能做自运算
	while(p < &cs[SIZE - 1]) {
		p++;
		// error: lvalue required as increment operand
		// cs++;
		printf("p=%p, *p=%d, cs=%p, *cs=%d, *cs=%c\n", p, *p, cs, *cs, *cs);
	}
	
	return 0;
}

执行结果：

*p=72, *cs=72, *cs=H
 p=0022FF26, cs=0022FF26
&p=0022FF20, &cs=0022FF26
p <= &cs[1] is true
cs < &cs[1] is true
cs[0]=72, cs[0]=H, &cs[0]=0022FF26, p[0]=72, &p[0]=0022FF26
cs[1]=101, cs[1]=e, &cs[1]=0022FF27, p[1]=101, &p[1]=0022FF27
cs[2]=108, cs[2]=l, &cs[2]=0022FF28, p[2]=108, &p[2]=0022FF28
cs[3]=108, cs[3]=l, &cs[3]=0022FF29, p[3]=108, &p[3]=0022FF29
cs[4]=111, cs[4]=o, &cs[4]=0022FF2A, p[4]=111, &p[4]=0022FF2A
cs[5]=0, cs[5]= , &cs[5]=0022FF2B, p[5]=0, &p[5]=0022FF2B
p=0022FF27, *p=101, cs=0022FF26, *cs=72, *cs=H
p=0022FF28, *p=108, cs=0022FF26, *cs=72, *cs=H
p=0022FF29, *p=108, cs=0022FF26, *cs=72, *cs=H
p=0022FF2A, *p=111, cs=0022FF26, *cs=72, *cs=H
p=0022FF2B, *p=0, cs=0022FF26, *cs=72, *cs=H

从这个简单的案例中证明了，字符串变量也是一个指针变量。原因是因为数组是一个常量指针。那也就是说可以使用声明指针的形式来声明一个字符串。示例如下：

#include<stdio.h>

int main() {
	char *a = "Hello";
	printf("sizeof(a) is %d, &a=%p, a=%s\n", sizeof(a), &a, a);
	return 0;
}

执行结果：

sizeof(a) is 4, &a=0022FF3C, a=Hello

那如果声明两个相同的字符串指针变量，他们的值相同吗？代码如下：

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

int main() {
	char *a = "Hello";
	char *b = "Hello";
	if(a == b) {
		printf("a == b.\n");
	} else {
		printf("a != b.\n");
	}
	printf("a=%s, a=%p, &a[0]=%p, *a=%c, &a=%p\n", a, a, &a[0], *a, &a);
	printf("b=%s, b=%p, &b[0]=%p, *b=%c, &b=%p\n", b, b, &b[0], *b, &b);
	return 0;
}

执行结果：

a == b.
a=Hello, a=00405044, &a[0]=00405044, *a=H, &a=0022FF3C
b=Hello, b=00405044, &b[0]=00405044, *b=H, &b=0022FF38

从这个例子中可以知道的是，两个字符指针指向的地址是同一个地址，也就是说源程序中的两个字面量 Hello 在内存中使用同一个字符数组来进行存储的。换句话讲，这个例子中的变量 a 和变量 b 不是两个长得一样，而是它们就是同一个字符串。

综上可知，字符串的特点有：

1. 字符串变量是使用 NULL 字符作为最后一个元素的一维字符数组
2. 字符串变量也是一个指针变量
3. 字符串指针指向的是字符数组的第一个元素的地址
4. 两个相同的字符串字面量在内存中使用同一个字符数组来进行存储

字符串输入与输出

scanf 函数

scanf 函数可以读取输入的信息到指定的地址值中，配合变量的取值符可以更有效的读入数据：

int age = 1;
scanf("%d", &age);
printf("age = %d\n", age);

如果是指针变量，可以很容易的将地址传递给 scanf 函数，如下：

int *p;
scanf("%d", p);
printf("*p = %d\n", *p);

但是读入数据到指针指定位置的时候，会覆盖所指向的数据，并可能导致程序异常终止。

char *name = "hello";
scanf("%s", name);
printf("name = %s\n", name);

这个是 因为 scanf 把信息复制到由name指定的地址中，而在这种情况下，参数是个未被初始化的指针，name可能指向任何地方。

gets 函数

gets 函数对于交互式程序非常方便，它从系统的标准输入设备（通常是键盘）获得一个字符串。

因为字符串没有预定的长度，所以 gets 函数通过判断遇到的第一个换行符 \n 结束输入，按回车键可以产生这个字符。它读取换行符之前（不包括换行符）的所有字符，并在这些字符后添加一个空字符（\0）。

char n[12];
char *p;
p = gets(n);
printf("n=%s\n", n);
printf("p=%p\n", p);
printf("n=%p\n", n);

如果在 gets 函数在读取字符串时出错或者遇到文件结尾，它就返回一个空(或0)地址，这个空地址被称为空指针，并且 stdio.h 里面定义的常量 NULL 来表示，可以用下面的代码来进行一些错误检测。

char name[1024];
while(get(name) != NULL) {
    // ... do something here ....
}

也可以通过 getchar 函数来完成上面的错误检测。

char ch;
while((ch = getchar()) != EOF) {
    // ... do something ...
}

fgets 函数

fgets 函数也可以读入字符数据到变量中，它和 gets 函数的区别主要有：

• fgets 需要第二个参数来说明最大读入字符数。如果这个参数值为 n，fgets 就会读取最多 n-1 个字符或者读完一个换行符为止(因为会自动添加一个空字符(\n))，由这两者中最先满足的那个结束输入。
• 如果 fgets 读取到换行符，就会把它存到字符串里，而不是像 gets 那样丢弃。
• fgets 还需要第三个参数来说明读哪一个文件，从键盘上读取数据时，可以使用stdin(代表standard input)作为参数，这个标识符在 stdio.h 中被定义。

#include<stdio.h>
#define MAX 1024

int main() {
    char n[MAX];
    char *p;
	
	printf("input:");
	p = gets(n);
	printf("n=%s\n", n);
	printf("p=%p\n", p);
	printf("n=%p\n", n);

	printf("input:");
    p = fgets(n, MAX, stdin);	
	printf("n=%s\n", n);
	printf("p=%p\n", p);
	printf("n=%p\n", n);

    return 0;
}

执行结果：

input:hello
n=hello
p=0061FB1C
n=0061FB1C
input:hello
n=hello

p=0061FB1C
n=0061FB1C

明显看到第二次输入的 hello 后面会带有一个回车符号。

scanf 和 gets 的区别

scanf 函数和 gets 函数的主要区别在于如何决定字符串何时结束。scanf 函数可以使用 %s 来读入一个单词，而 gets 则是读入一个长字符串，以回车键结束。如下所示代码：

char n[1024];
char *p;

printf("input:");
p = gets(n);
printf("n=%s\n", n);

printf("input:");
scanf("%s", n);
printf("n=%s\n", n);

如果输入均为 hello world，则输出结果如下：

input:hello world
n=hello world
input:hello world
n=hello

这两种方法都是以遇到的第一个非空白字符开始的，针对 scanf 函数的结束，可以归纳为：

1. 如果使用 %s 格式，字符串读取到（但不包括）下一个空白字符（比如空格、制表符或换行符）结束
2. 如果指定了字段宽度，比如 %10s，scanf 函数就会读取10个字符或者直到遇到第一个空白字符，由二者最先满足的那一个终止输入

printf 函数

printf 函数接受一个格式控制字符串，格式控制字符串是用双引号括起来的字符串，包括三类信息：

格式字符：格式字符由 % 引导，如 %d、%f等。它的作用是控制输出字符的格式。
转义字符：格式控制字符串里的转义字符按照转义后的含义输出，如换行符\n，即输出回车。
普通字符：普通字符即需要在输出时原样输出的字符，如汉字或者其他普通单词。

puts 函数

puts 函数接受一个字符串参数的地址，它遇到空字符（\0）就会结束输出（所以必须要有空字符）。puts 函数在显示字符串的时候，会自动在其后添加一个换行符（\n）。

#include<stdio.h>
#define STR "learn C++ together!"

int main() {
	char cs[] = "defined by array!";
	char *cp = "defined by pointer!";
	puts("puts string!");
	puts(cs);
	puts(cp);
	puts(STR);
	puts(&cs[3]);
	puts(cs+4);
	puts(&cp[3]);
	puts(cp+4);
    return 0;
}

fputs 函数

fputs 函数 puts 函数面向文件版本，两者主要的区别是：

• fputs 函数需要第二个参数来说明要写的文件，可以使用 stdout (standard output) 作为参数来进行输出显示。
• 与 puts 函数不同，fputs 函数并不为输出自动添加换行符。

读取一行并把它回显在下一行，用下面的两种循环都可以办到

// get & puts
{
    char line[81];
    while(gets(line))
        puts(line);
}
// fgets & fputs
{
    char line[81];
    while(fgets(line,81,stdin))
        fputs(line,stdout);
}

字符串函数

在 C 的标准库中，提供了关于字符串的函数，在使用之前需要引入头文件 string.h。关于这个头文件中包含的函数说明请参考：http://www.cplusplus.com/reference/cstring/

strcpy

函数签名： char * strcpy ( char * destination, const char * source );
函数描述：将 source 所指的 C 字符串复制到 destination 所指的数组中，包括终止的空字符（并在该点停止）。
名称来源： Copy string
使用示例：

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

int main() {
	char a[] = "Hello";
	char b[] = "World";
	
	// strcpy(a, b) 等价于 a = b
	strcpy(a, b);
	
	printf("a=%s\n", a);
	printf("b=%s\n", b);
	
	return 0;
}

执行结果：

a=World
b=World

因为数组是一个常量指针，所以它不能像普通变量那样直接将变量 b 的值赋予给变量 a。这里使用到 C 标准库中提供的 strcpy 函数将 b 的值赋予给 a。当然，如果使用指针变量声明的字符串完成就可以不需要 strcpy 函数了。示例如下：

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

int main() {
	char *a = "Hello";
	char *b = "World";
	a = b;
	printf("a=%s\n", a);
	printf("b=%s\n", b);
	return 0;
}

执行结果：

a=World
b=World

结果虽然一样，但是使用指针的做法实际上就是将 b 的指针指向的地址值赋予了 a，使得 a 的指向发生变化而已。

strcat

函数签名： char * strcat ( char * destination, const char * source );
函数描述： 将 source 字符串的副本追加到 destination 字符串。destination 中的终止空字符被 source 的第一个字符覆盖，并且在由 destination 中的两个字符串联而成的新字符串的末尾包含一个空字符。
名称来源： Concatenate strings
使用示例：

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

int main() {
	char a[] = "Hello";
	char b[] = "World";
	
	strcat(strcat(a, " "), b);
	
	printf("a=%s\n", a);
	printf("b=%s\n", b);
	return 0;
}

执行结果：

a=Hello World
b=World

strlen

函数签名： size_t strlen ( const char * str );
函数描述： 返回 C 字符串 str 的长度。
名称来源： Get string length
使用示例：

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

int main() {
	char a[] = "Hello";
	char b[] = "World";
				
	printf("a=%s, a's length is %d\n", a, strlen(a));
	printf("b=%s, b's length is %d\n", b, strlen(b));
	return 0;
}

执行结果：

a=Hello, a's length is 5
b=World, b's length is 5

strcmp

函数签名： int strcmp ( const char * str1, const char * str2 );
函数描述： 如果每个字符都一致，则返回零，否则比较第一个不同的字符的 ASCII 值。
名称来源： Compare two strings
使用示例：

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

int main() {

	char a[] = "Hello";
	char b[] = "World";
	int c = strcmp(a, b);
	printf("strcmp(\"%s\", \"%s\") is %d\n", a, b, c);
	return 0;
}

执行结果：

strcmp("Hello", "World") is -1

函数 strcmp 比较 Hello 和 World 的结果是 -1，也就是 a < b。那是因为 World 的第一个字符的 ASCII 值比 Hello 的大。如果将 World 更改为 Happy，那就是比较第二个字符的 ASCII 值，结果就是 a > b 了。关于它的更多介绍，可以参考 http://www.cplusplus.com/reference/cstring/strcmp/

strchr

函数签名： char * strchr ( const char * str, int character);
函数描述： 返回指向 C 字符串 str 中 character 的第一个匹配项的指针。
名称来源： Locate first occurrence of character in string
使用示例：

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

int main() {

	char a[] = "Hello World!";
	char *c = strchr(a, 'l');
	printf("c=%p, c=%c, c=%d, c=%s", c, *c, *c, c);
	
	return 0;
}

执行结果：

c=0022FF31, c=l, c=108, c=llo World!

返回的指针 c 指向的是原字符串的一个第一个 l 的字符，可以使用指针运算，统计出该字符串中某个字符的总数。如下例所示：

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

int main() {
	char a[] = "Hello World!";
	char *c = a, ch = 'l';
	int count = 0;
	while(c) {
		c = strchr(c, ch);
		if(!c) {
			// 如果找不到对应的字符，则返回空指针
			break;
		}
		// printf("c=%p, c=%c, c=%d, c=%s\n", c, *c, *c, c);
		c++;
		count++;
	}
	printf("count of '%c' is %d.\n", ch, count);
	return 0;
}

执行结果：

count of 'l' is 3.

strstr

函数签名： char * strstr ( char * str1, const char * str2 );
函数描述： 返回指向 str1 中第一个 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针。
使用示例：

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

int main() {
	char a[] = "The matching process does not include the terminating null-characters, but it stops there.";
	char *c = strstr(a, "null");
	if(c) {
		// c is not null pointer
		printf("c=%p, c=%c, c=%d, c=%s\n", c, *c, *c, c);
	}
	return 0;
}

执行结果：

c=0022FF07, c=n, c=110, c=null-characters, but it stops there.

C++ 的字符串

在 C++ 中，字符串的声明和使用都比 C 中来得简单。示例代码如下：

#include<iostream>
#include<string>
using namespace std;

int main() {
	string str = "Hello World";
	cout << "str's length is " << str.size() << endl;
	str += "!";
	cout << "str's length is " << str.size() << endl;
	cout << str << endl;
	// 在字符串从左开始查找第一次出现指定字符串的位置，并返回下标
	int index = str.find("l");
	cout << "index is " << index << endl;
	// 在字符串从右开始查找第一次出现指定字符串的位置，并返回下标
	index = str.rfind(" ");
	cout << "index is " << index << endl;
	// 从指定下标开始截取字符串，截取指定的长度
	string substring = str.substr(index + 1, 2);
	cout << "substring is " << substring << endl;
	// 从指定下标开始截取字符串，截取到末尾
	substring = str.substr(index + 1);
	cout << "substring is " << substring << endl;
	substring = str.replace(index + 1, 5, "C++");
	cout << "substring is " << substring << endl;
	return 0;
}

执行结果：

str's length is 11
str's length is 12
Hello World!
index is 2
index is 5
substring is Wo
substring is World!
substring is Hello C++!

枚举类型

使用 enum 关键字定义一系列枚举值，表示星期，例如：

enum WEEK { MON, TUE, WED, THU, FRI, SAT, SUN };

接下来就能在程序中使用这些枚举值表示星期了

#include<stdio.h>

enum WEEK { MON, TUE, WED, THU, FRI, SAT, SUN };

int main() {
	enum WEEK w = SAT;
	
	switch(w) {
		case MON:
		case TUE:
		case WED:
		case THU:
		case FRI:
			printf("today is week. ");
			break;
		case SAT:
		case SUN:
			printf("today is weekend. ");
			break;
	}	
	return 0;
}

执行结果：

today is weekend.

非常简单，如果尝试将其以数字的形式输出呢？代码如下：

#include<stdio.h>

enum WEEK { MON, TUE, WED, THU, FRI, SAT, SUN };

int main() {
	enum WEEK w = SAT;
	printf("today is %d. ", w);	
	return 0;
}

执行结果：

today is 5.

会发现，输出的 5 正好与 SAT 在声明枚举的语句中所在的下标是一致的，于是，全部将其输出，查看结果：

printf("MON is %d.\n", MON);
printf("TUE is %d.\n", TUE);
printf("WED is %d.\n", WED);
printf("THU is %d.\n", THU);
printf("FRI is %d.\n", FRI);
printf("SAT is %d.\n", SAT);
printf("SUN is %d.\n", SUN);

其结果是：

MON is 0.
TUE is 1.
WED is 2.
THU is 3.
FRI is 4.
SAT is 5.
SUN is 6.

因为枚举值实际上就是一系列连续的数字，默认从零开始。当然，可以在定义的时候手动更改他们的值。例如：

enum WEEK { MON, TUE, WED=8, THU, FRI, SAT, SUN };

输出对应的数字值分别是：

MON is 0.
TUE is 1.
WED is 8.
THU is 9.
FRI is 10.
SAT is 11.
SUN is 12.

当然，故意将其设置为相同的值是被允许的，但不建议这样做：

反例1：

enum WEEK { MON, TUE, WED=8, THU=8, FRI, SAT, SUN };

反例2：

enum WEEK { MON=5, TUE, WED, THU=3, FRI, SAT, SUN };

这样写都会导致枚举值出现重复的数值，也不利于程序的维护。

结构体

声明与定义

在 C 语言提供的基本数据类型中，只能表示单一的类型的数据类型，如果需要将多个数据类型组合成为一个整体的作为新的类型的话，就需要使用到结构体。

在表达式 int a = 10;中，变量 a 被定义为了 int 类型，无论如何，变量 a 都表示的是一个数。

而实际运用中，需要依赖变量某个变量来表示更多的内容。

例如，需要表示某个人的信息，包括姓名，年龄，体重等。那每个信息可以使用一个基本数据类型来表示。如下代码所示：

#include<stdio.h>

int main() {
	char name[50] = "tom";
	unsigned int age = 27;
	double weight = 57.9;
	printf("name is %s, age is %d, weight is %f\n", name, age, weight);
	return 0;
}

执行结果：

name is tom, age is 27, weight is 57.900000

但是作为某个人的信息，它们应该是一个整体。这时候可以使用结构体定义一个新的类型，这个类型将包含需要表示的某个人的信息的基本类型。如下代码所示：

/**
 * 人
 */
struct Person {
	/**
	 * 姓名
	 */
	char name[50];
	/**
	 * 年龄
	 */
	unsigned int age;
	/**
	 * 体重
	 */
	double weight;
};

这里定义了一个 Person 类型，该类型包含了 C 提供的三个基本类型。而作为整体，该类型将表示某个人的数据。

结构体的定义语法：

struct 结构体名称 {
	member-list
}

定义好的结构体与基本数据类型的使用方式是一样的。如下所示：

char name[50];
unsigned int age;
double weight;
struct Person man;

或者可以在声明的时候为其赋予初始值：

char name[50] = "Tom";
unsigned int age = 27;
double weight = 57.9;
struct Person man = {"Mark", 28, 60.2};

也可以在声明之后，使用运算符 . 来为结构体变量赋值，完整代码如下所示：

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

/**
 * 人
 */
struct Person {
	/**
	 * 姓名
	 */
	char name[50];
	/**
	 * 年龄
	 */
	unsigned int age;
	/**
	 * 体重
	 */
	double weight;
};

int main() {
	// 声明普通的变量
	char name[50];
	unsigned int age;
	double weight;
	// 为普通的变量赋值
	strcpy(name, "Tom");
	age = 27;
	weight = 57.9;
	// 输出变量的值
	printf("name is %s, age is %d, weight is %f\n", name, age, weight);
	
	// 声明结构体变量
	struct Person man;
	// 为结构体变量的内部成员赋值
	strcpy(man.name, "Mark");
	man.age = 28;
	man.weight = 60.2;
	// 输出结构体变量的内部成员的值
	printf("name is %s, age is %d, weight is %f\n", man.name, man.age, man.weight);
	return 0;
}

执行结果：

name is Tom, age is 27, weight is 57.900000
name is Mark, age is 28, weight is 60.200000

可以将结构体看作是将多个基础数据类型的变量进行打包的容器，使得这些只能表示单一信息的单元组合成一个整体，无论是取值还是储值都需要通过变量 man 使用运算符 . 来操作。在阅读代码的时候，可以将运算符 . 理解为汉字 的，比如 man.age = 28 可以理解为 man 的 age 是 28 <==> man's age is 28。也加强了代码的可读性。

当然，结构体的内部成员除了基础数据类型之外，还可以是指针变量，枚举变量和其他结构体，例如：

/**
 * 性别
 */
enum Gender {Girl, Boy};

/**
 * 成绩
 */
struct Score {
	/**
	 * 语文成绩
	 */
	int Chinese;
	/**
	 * 数学成绩
	 */
	int Math;
	/**
	 * 英语成绩
	 */
	int English;
};
/**
 * 人
 */
struct Person {
	/**
	 * 姓名
	 */
	char name[50];
	/**
	 * 年龄
	 */
	unsigned int age;
	/**
	 * 性别
	 */
	enum Gender gender;
	/**
	 * 体重
	 */
	double weight;
	/**
	 * 成绩
	 */
	struct Score score;
};

结构体作为参数

因为结构体类型中包含多个数据类型的成员，以结构体作为函数参数能减少函数的参数列表的长度，使得代码更加简洁。示例如下：

#include<stdio.h>

enum Gender {Girl=0, Boy=1};

/**
 * 人
 */
struct Person {
	/**
	 * 姓名
	 */
	char name[50];
	/**
	 * 年龄
	 */
	unsigned int age;
	/**
	 * 性别
	 */
	enum Gender gender;
	/**
	 * 体重
	 */
	double weight;
};

/**
 * 打印 Person 结构体的成员变量
 */ 
void print(struct Person person) {
	char *gender = person.gender ? "Boy" : "Girl";
	printf("Person{name:%s, age:%d, gender:%s, weight:%f}\n", person.name, person.age, gender, person.weight);
	
}

int main() {
	struct Person man = {"Mary", 16, Girl, 48.2};
	print(man);
	return 0;
}

执行结果：

Person{name:Mary, age:16, gender:Boy, weight:48.200000}

如果结构体中的成员变量较多，使用这种方式传递数据相比较把所有的成员变量列举到形参列表中而言显得更加方便简洁。

指向结构体的指针

同样的，声明一个指向结构体的指针，也能作为函数参数进行数据的传递。但是作为指针变量，需要访问结构体中的成员变量时，需要使用 -> 运算符。如下所示：

#include<stdio.h>

enum Gender {Girl=0, Boy=1};

/**
 * 人
 */
struct Person {
	/**
	 * 姓名
	 */
	char name[50];
	/**
	 * 年龄
	 */
	unsigned int age;
	/**
	 * 性别
	 */
	enum Gender gender;
	/**
	 * 体重
	 */
	double weight;
};

/**
 * 打印 Person 结构体的成员变量
 */ 
void print(struct Person *p) {
	char *gender = p->gender ? "Boy" : "Girl";
	printf("Person{name:%s, age:%d, gender:%s, weight:%f}\n", p->name, p->age, gender, p->weight);
}

int main() {
	struct Person man = {"Mary", 16, Girl, 48.2};
	struct Person *p = &man;
	printf("this person's name is %s\n", p->name);
	print(p);
	return 0;
}

执行结果：

this person's name is Mary
Person{name:Mary, age:16, gender:Girl, weight:48.200000}

结构体占用的内存空间大小

使用 sizeof 能够量出某个变量或者类型的占用空间的字节数，那结构体占用多大的内存空间呢？首先来看一段代码：

#include<stdio.h>

int main() {
	printf("sizeof(char) is %d\n", sizeof(char));
	printf("sizeof(int) is %d\n", sizeof(int));
	printf("sizeof(double) is %d\n", sizeof(double));
	printf("========================\n");
	
	struct A{int a; int b;};
	printf("sizeof(A) is %d\n", sizeof(struct A));
	
	struct B{int a; double b;};
	printf("sizeof(B) is %d\n", sizeof(struct B));
	
	struct C{double a; double b;};
	printf("sizeof(C) is %d\n", sizeof(struct C));
	
	struct D{double a; double b; int c;};
	printf("sizeof(D) is %d\n", sizeof(struct D));
	
	struct E{double a; double b; int c; int d;};
	printf("sizeof(E) is %d\n", sizeof(struct E));
	
	struct F{double a; double b; int c; int d; char e;};
	printf("sizeof(F) is %d\n", sizeof(struct F));
	
	return 0;
}