第五章 数组&字符串&结构

一、程序中的内存

温馨提示：点击图片查看大图

1、程序中的内存是从哪里来？
（1）程序执行需要内存的支持
对于程序来说，内存就是程序的立足之地（程序时被放在内存中运行的）；程序运行时需要内存来存储一些临时变量。
（2）内存管理最终是由操作系统完成的

• 内存本身在物理上是一个硬件器件，由硬件系统提供。
• 内存是由操作系统统一管理的。为了省内存管理方便又合理，操作系统提供了多种机制来让我们应用程序使用内存。这些机制彼此不同，各有各的特点，我们程序根据自己的实际情况来选择某种方式获取内存（在操作系统出登记这块内存临时使用权限）、使用内存、释放内存（向操作系统归还这块内存使用权限）。

（3）三种内存来源：栈（stack）、堆（heap）、数据区（.data）在一个C语言中，能够获取内存就是这三种情况。
2、栈内存介绍

（1）运行时自动分配&自动回收：栈是一个自动管理的，程序员不需要用手干预的方法简单。
（2）反复使用：栈内存在程序中其实就是那一块空间，程序反复使用这一块空间。
（3）脏内存：栈内存由于反复使用，每次使用后程序不会去清理，因此分配倒是保留原来的值，所以定义局部变量后必需初始化。
（4） 临时性：函数不能返回栈变量的指针，因为这个空间是临时的
（5）栈会溢出：因为操作系统事先给定了栈的大小，如果在函数中无穷尽的分配栈内存总能使用完。

3、堆内存介绍
（1）void *是指针类型，malloc返回一个void 类型的指针，实质上malloc返回的是堆管理器分配给我本次申请的那块内存空间的首地址（malloc返回的值其实是一个数字，这个数字表示一个内存地址）为什么要使用void作为类型？主要原因是malloc帮助我们分配内存的时值分配了内存空间，至于这段空间将来用来存储什么类型的元素malloc是不关心的，由我们程序自己来决定。
（2）什么事void类型，早期被翻译成空类型，这个翻译不对，void类型不表示没有类型，而表示万能类型。void的意思就是说这个数据类型当前是不确定的，也就是说这个指针可以指向任何类型的元素。
（3）malloc的返回值：成功申请空间后返回这个内存空间的指针，申请失败时返回NULL,所以malloc获取的内存指针使用前一定要先检查是否为NULL.
（4）malloc申请内存时用完后需要free释放。free（p）；会告诉堆管理器这段内存我已经使用完了，你可以回收了。堆管理器回收这段内存后这段内存当前进程就不应该使用了。因为释放后堆管理器就可能把这段内存空间再次分配给别的进程，所以你就不能再使用了。
（5）在调用free归还之前，指向这段内存的指针p不能丢失（也就是不能再给p另外赋值）因为p一旦丢失这段malloc来的内存就会永远的丢失了（内存泄漏），直到当前程序结束时操作系统才会回收这段内存。

int main(void)
{
//第一步：申请内存
int *p = （int *）malloc(1000000*sizeof(int));
//第二步：检测分配是否成功
if (NULL == P)
{  
	printf("malloc error.\n");
	return;
}
//第三步：使用申请到的内存
//p = NULL;
//P = &a;    //如果在free之前给p另赋值，那么malloc申请的那段内存就会丢失了
			//malloc后p和返回内存相绑定，p是那段内存在当前进程的唯一联系人
			//如果p没有free之前就丢失了，那么这段内存就会永远丢失。
			//丢失内存的感念就是在操作系统的堆管理器中这段内存是当前进程拿着的，但是你也用不了
			//所以你想申请新的内存来替换使用，这就叫做程序“吃内存”，学名叫做内存泄漏
*（p+0）= 1；
*（p+1）= 2；
printf("*(p+0) = %d.\n",*(p+0));
printf("*(p+1) = %d.\n",*(p+1));

//第四步：释放
free(p);
return 0;
}

4、数据段
代码段、数据段、bss段
（1）编译器在编译程序时，将程序中所有的元素分成了一些组成部分，各部分构成一个段，所以说段是可执行程序的组成部分。
（2）代码段：就是程序中可执行的部分，直观理解代码段就是函数堆叠组成的。
（3）数据段：（也称为数据区，静态数据区，静态区）程序中的数据，直观理解就是C语言中的全局变量。（注意：全局变量才算是程序中的数据，局部变量不算程序中的数据，只能算是函数的数据）
（4）bss段:（又叫做ZI（zero initial）段）特点就是被初始化为0，bss段本质也是属于数据段，bss段就是被初始化为0的数据段。
**注意区分：**数据段（,data）和bss段的区别和联系：二者没有本质的区别，都是用来存放C程序中的全局变量的。区别在于把显示初始化为零的全局变量存放在.data段中，而把显示初始化为0或者并未显示初始化（c语言规定未显示初始化的全局变量值默认为0）的全局变量存在bss段。
（5）有些特殊的数据会被放到代码段
（6）const型常量：C语言中const关键字用来定义常量，常量是不能被改变的。const的实现方法至少有两种；第一种就是编译器将const修饰的变量放在代码段去实现不能修改（普遍见于单片机的编译器）；第二种就是由编译器来检查以确保const常量不会被修改，实际上const型的常量还是和普通变量是一样放在数据段的（gcc中就是这样实现的）。
(7)显示初始化为非零的全局变量和静态局部变量放在数据段
放在 .data段的变量有两种：

• 第一种是显示初始化为非零的全局变量。
• 第二种静态局部变量，也就是static修饰的局部变量。（普通局部变量分配在栈上，静态局部变量分配在 .data段）

（8）未初始化或者显示初始化为0的全局变量放在bss段 bss段和.data段并没有本质区别，几乎可以不用明确区分这两种。
申请内存的三种方法：

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

int a = 5;
int b;
int c = 0;
int array[1000];
	
char str[] = "linux";		// 第二种方法：定义成全局变量，放在数据段

int main(void)
{
	char a[] = "linux";		// 第一种方法：定义成局部变量，放在栈上
	char *p = (char *)malloc(10);	
	if (NULL == p)
	{
		printf("malloc error.\n");
		return -1;
	}
	memset(p, 0, 10);		// 第三种方法： 放在malloc申请的堆内存中
	strcpy(p, "linux");
	
	printf("%s\n", a);
	printf("%s\n", str);
	printf("%s\n", p);
	printf("%p\n", a);
	printf("%p\n", str);
	printf("%p\n", p);
	return 0;
}

总结：

• 相同点就是三种获取内存的方法，都可以给程序提供可用的内存，都可以用来定义变量给程序使用。
• 不同点就是，栈内存对应C中的普通局部变量，（别的变量不能使用栈，而且栈是自动的，由编译器运行时环境共同来提供服务，程序员无法手工控制）；堆内存全是独立于我们的程序存在和管理的，程序需要内存时可以手工申请malloc，使用完之后必需尽快free释放。

二、C语言中的字符串类型

1、C语言没有原生的字符串类型
（1）很多高级语言像JAVA、C#等就有字符串类型，有一个string来表示字符串，用法和int类型这些很像，可以是string S1 = “Linux”；来定义字符串类型变量。
（2）C语言没有string类型，C语言中的字符串是通过字符指针类型来间接管理实现的。
2、C语言使用指针来管理字符串
（1）C语言中定义字符串方法：char *p = “Linux”；此时p就叫做字符串，但实际上p只是一个字符指针（本质上就是一个指针变量，只是p指向了一个字符串的起始地址而已）。
3、C语言中字符串的本质：指针指向头，固定尾部的地址相连的一段内存
（1）字符串就是一串字符。字符串反应在现实中就是文字、符号、数字，等人用来表达的字符，反应在编程中就是字符类型的变量。C语言中使用ASCII编码对字符进行编程，编程后可以用char类型变量表示一个字符串。字符串就是多个字符串打包在一起组成的。
（2）字符串在内存中其实就是多个字节连续分布构成的（类似于数组，字符串和字符数组非常像）
（3）C语言中字符串有3个核心要点：

• 第一个是用一个指针指向字符串头；
• 第二个及时固定尾部（字符串总是以“\0”来结尾的）；
• 第三是组成字符串的各字符串彼此地址相连。

（4）“ \0 ”反斜杠0是一个ASCII字符，其实就是编码为0的那个字符（正真的0，和数字0是不同的，数字0有他自己的ASCII编码）。要注意区分‘ \0 ’和‘ 0 ’还有0，（0等于‘ \0 ’，‘0’等于48）
（5）“ \0 ”作为一个特殊的数字被字符串定义为结尾标志。
4、注意：指向字符串的指针和字符串本身是分开的两个东西
char *p = “linux”；//在代码中，p本质就是一个字符串指针，占4个字节，“linux”分配在代码段，占6个字节，实际上耗费了10个字节。

• 4个字节的指针p叫做字符串指针（用来指向字符串的，理解为字符串的引子，但是本生不是字符串）
• 5字节用来存储linux这5个字符的内存才是真正的字符串
• 一个用来存储“ \0 ”是字符串结尾标志（本质上也不属于字符串）

5、存储多个字符串的2种方法：字符串和字符数组
6、字符数组初始化与sizeof、strlen
（1）sizeof是C语言中一个关键字，也是C语言的一个运算符（sizeof使用时是一个sizeof（类型或者变量名）他不是一个函数），sizeof运算符用来返回一个类型或者是变量所占用的内存字节数。为什么需要sizeof？主要原因是int double 等原生类型占几个字节和平台有关；
（2）strlen是C语言的一个库函数，这个库函数的原型是：size_t strlen(const char *s);
这个函数接收一个字符串的指针，返回这个字符串的长度（以字节为单位）。
注意：strlen返回的字符串长度不包括字符串结尾的‘\0’的。
（3）字符串数组初始化

char a[5] = "windows";  //初始化长度大于数组长度，多余的被截掉了
printf("sizeof(a) = %d.\n",sizeof(a));  // = 5
printf("strlen(a) = %d.\n",strlen(a));  // = 5

char a[5] = "lin";
printf("sizeof(a) = %d.\n",sizeof(a));  // = 5
printf("strlen(a) = %d.\n",strlen(a));  // = 3

char a[5] = {2,3};
printf("sizeof(a) = %d.\n",sizeof(a));  // = 5
printf("strlen(a) = %d.\n",strlen(a));  // = 2

char a[5] = {0};  //初始化为0，后面的元素都是0
printf("sizeof(a) = %d.\n",sizeof(a));  // = 5
printf("strlen(a) = %d.\n",strlen(a));  // = 0  ，因为第一个为0，就会误以为是“ \0 ”所以长度位0

char a[5];  //没有初始化，所以这个数组里面的值是随机的
printf("sizeof(a) = %d.\n",sizeof(a));  // = 5
printf("strlen(a) = %d.\n",strlen(a));  // = 5，第六个为“ \0 ”

总结：
<1>. sizeof（数组名）得到的永远是数组的元素个数（也就是数组的大小）和数组中有无初始化，初始化多少等没有关系
<2>. strlen是用来计算字符串长度的，只能传递合法的字符串进去才有意义，如果随便传递一个字符指针，但是这个字符指针并不是字符串时没有意义的。
（4）当我们定义数组时如果没有明确的给出数组的大小，则必须同时给出初始化式，编译器会根据初始化式去自动计算数组大小（数组定义的时候必须给定大小，要么直接给，要么给初始化式）

7、字符串初始化与sizeof 、strlen
（1）char *p = “linux”；
sizeof（p）得到的永远是4，因为这时候sizeof测的是字符指针p的本生长度，和字符串的长度无关的
（2）strlen刚好用来计算字符串的长度

8、字符数组与字符串的本质差异（内存分配角度）
（1）字符数组 char a [ ] = “linux”；
来说定义了一个数组a，数组a 占用6个字节，右值“linux”本身只存在编译器中，编译器将它用来初始化字符数组a后丢弃掉（也就是说内存中是没有“linux”这个字符串的）；这句话相当于是：char a[ ]= {‘l’,‘i’,‘n’,‘u’,‘x’,’\0’};
（2）字符串char *p = “linux”；
定义了一个字符指正p，p占4个字节，分配在栈上；同时还定义了一个字符串“linux”，分配在点码段上，然后代码段中的字符串（占了6个字节）的首地址（也就是“ l ”的地址）赋值给了p。

//字符串存放在栈上
char a[7];
char *p = a;

//字符串存放在数据段上
char *p = b;

//字符串存放在堆空间
char *p = (char *)malloc(5);

总结对比： 字符数组本身就是数组，数组自身带有内存空间，可以用来存放东西，（所以说数组类似于容器）；而字符串本身是指针，本身永远只占用4个字节，而且这4个字节不能用来存放有效数据，所以只能把有效的数据存放到别的地方，然后把地址存放到p中。也就是说字符数组自己存放那些字符，字符串一定需要额外的内存来存放那些字符，字符串本身只能存放真正的那些字符所在的内存空间的首地址。

三、C语言之结构体概述

1、结构体类型是一种自定义类型，C语言有两种类型：原生类型和自定义类型
2、结构体的定义
结构体使用时先定义结构体类型，然后再用类型来定义变量，也可以在定义结构体类型同时定义变量。

//先定义结构体类型
struct people
｛
	char name [20];
	int age;
｝；
//类型和变量一块定义
struct people
｛
	char name [20];
	int age;
｝s1；          //全局变量

//将类型struct student重命名为s1，s1是一个类型名，不是变量
 typedef struct student
｛
	char name [20];
	int age;
｝s1；          //是一个类型名，

int main(void)
{
	struct people p1;   //使用结构体类型定义变量
	s1.age = 23;
}

3、从数组到结构体的进步之处
（1）结构体也可以认为是从数组发展而来的。其实数组和结构体都算是数据结构的范畴了，数组就是最简单的数据结构，结构体比数组更为复杂一些，链表、哈希表之类比结构体更复杂；二叉树、图又更为复杂。
（2）数组有两个缺陷，定义时候必须明确给出大小，且这个大小在以后不能更改；第二个是数组要求所有元素的类型必须一致。
（3）而结构体用来解决数组的缺陷
4、结构体中元素的的访问
（1）数组中元素的访问方式：表面上有两种方式（下标访问和指针访问）
（2）结构体变量中的元素访问方式：只有一种，用.或者->的方式来访问。（.和->访问结构体元素其实质是一样的，只是C语言规定用结构体变量来访问元素用. 用结构体变量的指针来访问元素用->。实际上在高级语言中已经不区分了，都用.）
（3）结构体的访问方式有点类似于数组下标方式
思考：结构体变量的点号或者 ->访问元素的实质是什么？
其实实质还是用指针来访问的。
5、结构体对齐访问
（1）结构体对齐访访问主要是为了配合硬件也就是说硬件本身有物理限制，如果对齐排布和访问会提高效率，否则会大大降低效率。
（2）内存本身是一个物理器件，（DDR内存芯片，SoC上的DDR控制器），本身有一定的局限性：如果内存每次访问时按照4字节对齐访问，那么效率是最高的；如果不对齐访问效率就会降低。
（3）对比对齐访问和不对齐访问：对齐访问牺牲了内存空间，换取了性能和速度；而非对齐访问牺牲了访问速度性能，换取了内存空间的完全利用。
6、结构体对齐的规则和运算
编译器本身可以设置内存对齐的规则，有以下的规则需要记住：
第一个：32位编译器，一般编译器默认对齐方式是4字节对齐。

总结： 结构体对齐的分析要点和关键：
<1>.结构体对齐要考虑：结构体整体本身必须安置在4字节对齐处，结构体对齐后的大小必须4的倍数（编译器设置为4字节对齐时，如果编译器设置为8字节对齐，则这里的4是8）
<2>.结构体中每个元素本身都必须对其存放，而每个元素本身都有自己的对齐规则。
<3>.编译器考虑结构体存放时，以满足以上2点要求的最少内存需要的排布来算。
7、gcc支持但不推荐的对齐指令：#pragma pack() #pragma pack(n) (n=1/2/4/8)
（1）#pragma是用来指挥编译器，或者说设置编译器的对齐方式的。编译器的默认对齐方式是4字节，但是有时候我不希望对齐方式是4字节，而希望是别的（譬如希望1字节对齐，也可能希望是8字节，甚至可能希望128字节对齐）。
（2）常用的设置编译器编译器对齐命令有2种：第一种是#pragma pack()，这种就是设置编译器1字节对齐（有些人喜欢讲：设置编译器不对齐访问，还有些讲：取消编译器对齐访问）；第二种是#pragma pack(4)，这个括号中的数字就表示我们希望多少字节对齐。
（3）我们需要#prgama pack(n)开头，以#pragma pack()结尾，定义一个区间，这个区间内的对齐参数就是n。
（4）#prgma pack的方式在很多C环境下都是支持的，但是gcc虽然也可以不过不建议使用。
8、gcc推荐的对齐指令 attribute((packed)) attribute((aligned(n)))
(1)attribute((packed))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。packed的作用就是取消对齐访问。
(2)attribute((aligned(n)))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。它的作用是让整个结构体变量整体进行n字节对齐（注意是结构体变量整体n字节对齐，而不是结构体内各元素也要n字节对齐）
参考阅读blog：结构体博文

typedef struct mystruct2

{				//1字节对齐      //4字节对齐
	char  a;    //1				//4(1+3)
	int   b;    //4				//4
	short c;	//2				//4(2+2)
}

四、offsetof宏与container_of宏

1、由结构体指针进而访问各元素的原理
通过结构体整体变量来访问其中各个元素，本质上是通过指针方式来访问的，形式上是通过.的方式来访问的（这时候其实是编译器帮我们自动计算了偏移量）。
2、offsetof宏：
(1)offsetof宏的作用是：用宏来计算结构体中某个元素和结构体首地址的偏移量（其实质是通过编译器来帮我们计算）。
(2)offsetof宏的原理：我们虚拟一个type类型结构体变量，然后用type.member的方式来访问那个member元素，继而得到member相对于整个变量首地址的偏移量。
(3)学习思路：第一步先学会用offsetof宏，第二步再去理解这个宏的实现原理。
(TYPE *)0 这是一个强制类型转换，把0地址强制类型转换成一个指针，这个指针指向一个TYPE类型的结构体变量。 （实际上这个结构体变量可能不存在，但是只要我不去解引用这个指针就不会出错）。
((TYPE *)0)->MEMBER (TYPE *)0是一个TYPE类型结构体变量的指针，通过指针指针来访问这个结构体变量的member元素

&((TYPE *)0)->MEMBER 等效于&(((TYPE *)0)->MEMBER)，意义就是得到member元素的地址。但是因为整个结构体变量的首地址是0，
3、container_of宏：
(1)作用：知道一个结构体中某个元素的指针，反推这个结构体变量的指针。有了container_of宏，我们可以从一个元素的指针得到整个结构体变量的指针，继而得到结构体中其他元素的指针。
(2)typeof关键字的作用是：typepef(a)时由变量a得到a的类型，typeof就是由变量名得到变量数据类型的。
(3)这个宏的工作原理：先用typeof得到member元素的类型定义成一个指针，然后用这个指针减去该元素相对于整个结构体变量的偏移量（偏移量用offsetof宏得到的），减去之后得到的就是整个结构体变量的首地址了，再把这个地址强制类型转换为type *即可。

五、共用体（union）

1、共用体类型的定义、变量定义和使用
(1)共用体union和结构体struct在类型定义、变量定义、使用方法上很相似。
(2)共用体和结构体的不同：结构体类似于一个包裹，结构体中的成员彼此是独立存在的，分布在内存的不同单元中，他们只是被打包成一个整体叫做结构体而已；共用体中的各个成员其实是一体的，彼此不独立，他们使用同一个内存单元。可以理解为：有时候是这个元素，有时候是那个元素。更准确的说法是同一个内存空间有多种解释方式。
(3)共用体union就是对同一块内存中存储的二进制的不同的理解方式。
(4)在有些书中把union翻译成联合（联合体），这个名字不好。现在翻译成共用体比较合适。
(5)union的sizeof测到的大小实际是union中各个元素里面占用内存最大的那个元素的大小。因为可以存的下这个就一定能够存的下其他的元素。
(6)union中的元素不存在内存对齐的问题，因为union中实际只有1个内存空间，都是从同一个地址开始的（开始地址就是整个union占有的内存空间的首地址），所以不涉及内存对齐。
2、共用体和结构体的相同和不同
(1)相同点就是操作语法几乎相同。
(2)不同点是本质上的不同。struct是多个独立元素（内存空间）打包在一起；union是一个元素（内存空间）的多种不同解析方式。
3、共用体的主要用途
(1)共用体就用在那种对同一个内存单元进行多种不同规则解析的这种情况下。
(2)C语言中其实是可以没有共用体的，用指针和强制类型转换可以替代共用体完成同样的功能，但是共用体的方式更简单、更便捷、更好理解。

六、大小端模式

1、什么是大小端模式
(1)大端模式（big endian）和小端模式（little endian）。最早是小说中出现的词，和计算机本来没关系的。
(2)后来计算机通信发展起来后，遇到一个问题就是：在串口等串行通信中，一次只能发送1个字节。这时候我要发送一个int类型的数就遇到一个问题。int类型有4个字节，我是按照：byte0 byte1 byte2 byte3这样的顺序发送，还是按照byte3 byte2 byte1 byte0这样的顺序发送。规则就是发送方和接收方必须按照同样的字节顺序来通信，否则就会出现错误。这就叫通信系统中的大小端模式。这是大小端这个词和计算机挂钩的最早问题。
(3)现在我们讲的这个大小端模式，更多是指计算机存储系统的大小端。在计算机内存/硬盘/Nnad中。因为存储系统是32位的，但是数据仍然是按照字节为单位的。于是乎一个32位的二进制在内存中存储时有2种分布方式：高字节对应高地址（大端模式）、高字节对应低地址（小端模式）
(4)大端模式和小端模式本身没有对错，没有优劣，理论上按照大端或小端都可以，但是要求必须存储时和读取时按照同样的大小端模式来进行，否则会出错。
(5)现实的情况就是：有些CPU公司用大端（譬如C51单片机）；有些CPU用小端（譬如ARM）。（大部分是用小端模式，大端模式的不算多）。于是乎我们写代码时，当不知道当前环境是用大端模式还是小端模式时就需要用代码来检测当前系统的大小端。
经典笔试题：用C语言写一个函数来测试当前机器的大小端模式。

• 用union来测试机器的大小端模式
• 指针方式来测试机器的大小端
  2、大小端模式
  看似可行实则不行的测试大小端方式：位与、移位、强制类型转化
  (1)位与运算。
  结论：位与的方式无法测试机器的大小端模式。（表现就是大端机器和小端机器的&运算后的值相同的）
  理论分析：位与运算是编译器提供的运算，这个运算是高于内存层次的（或者说&运算在二进制层次具有可移植性，也就是说&的时候一定是高字节&高字节，低字节&低字节，和二进制存储无关）。
  (2)移位
  结论：移位的方式也不能测试机器大小端。
  理论分析：原因和&运算符不能测试一样，因为C语言对运算符的级别是高于二进制层次的。右移运算永远是将低字节移除，而和二进制存储时这个低字节在高位还是低位无关的。
  (3)强制类型转换
  同上
  3、通信系统中的大小端（数组的大小端）
  (1)譬如要通过串口发送一个0x12345678给接收方，但是因为串口本身限制，只能以字节为单位来发送，所以需要发4次；接收方分4次接收，内容分别是：0x12、0x34、0x56、0x78.接收方接收到这4个字节之后需要去重组得到0x12345678（而不是得到0x78563412）.
  (2)所以在通信双方需要有一个默契，就是：先发/先接的是高位还是低位？这就是通信中的大小端问题。
  (3)一般来说是：先发低字节叫小端；先发高字节就叫大端。（我不能确定）实际操作中，在通信协议里面会去定义大小端，明确告诉你先发的是低字节还是高字节。
  (4)在通信协议中，大小端是非常重要的，大家使用别人定义的通信协议还是自己要去定义通信协议，一定都要注意标明通信协议中大小端的问题。

七、枚举

1、枚举是用来干嘛的？
(1)枚举在C语言中其实是一些符号常量集。直白点说：枚举定义了一些符号，这些符号的本质就是int类型的常量，每个符号和一个常量绑定。这个符号就表示一个自定义的一个识别码，编译器对枚举的认知就是符号常量所绑定的那个int类型的数字。
(2)枚举中的枚举值都是常量，怎么验证？
(3)枚举符号常量和其对应的常量数字相对来说，数字不重要，符号才重要。符号对应的数字只要彼此不相同即可，没有别的要求。所以一般情况下我们都不明确指定这个符号所对应的数字，而让编译器自动分配。（编译器自动分配的原则是：从0开始依次增加。如果用户自己定义了一个值，则从那个值开始往后依次增加）
2、C语言为何需要枚举
(1)C语言没有枚举是可以的。使用枚举其实就是对1、0这些数字进行符号化编码，这样的好处就是编程时可以不用看数字而直接看符号。符号的意义是显然的，一眼可以看出。而数字所代表的含义除非看文档或者注释。
(2)宏定义的目的和意义是：不用数字而用符号。从这里可以看出：宏定义和枚举有内在联系。宏定义和枚举经常用来解决类似的问题，他们俩基本相当可以互换，但是有一些细微差别。
3、宏定义和枚举的区别
(1)枚举是将多个有关联的符号封装在一个枚举中，而宏定义是完全散的。也就是说枚举其实是多选一。
(2)什么情况下用枚举？当我们要定义的常量是一个有限集合时（譬如一星期有7天，譬如一个月有31天，譬如一年有12个月····），最适合用枚举。（其实宏定义也行，但是枚举更好）
(3)不能用枚举的情况下（定义的常量符号之间无关联，或者无限的）用宏定义。

总结： 宏定义先出现，用来解决符号常量的问题；后来人们发现有时候定义的符号常量彼此之间有关联（多选一的关系），用宏定义来做虽然可以但是不贴切，于是乎发明了枚举来解决这种情况。