一、typedef的用法
转载地址：
http://www.2cto.com/kf/201404/296683.html
typedef可以看作type define的缩写，顾名思义就是类型定义，也就是说它只是给已有的类型重新定义了一个方便使用的别名，并没有产生新的数据类型。
typedef的使用与宏定义define有些许的相似，但两者又有以下不同：
1、与#define不同，typedef给出的符号名称仅限于对类型，而不是对值。
2、typedef的解释由编译器，而不是预处理器执行。
3、typedef比#define更灵活。
既然typedef没有定义新的数据类型，那么为什么还要使用它呢？使用typedef有其自身的优势：
1、它使得定义更加直观，从定义就可了解变量的某些信息。如
typedef unsigned int BYTE；
BYTE x, y[10], *z;
2、它可以使程序参数化，以提高程序的可移植性。如
time_t time(time_t *);
该函数返回的是time_t 类型的返回值，有些系统中 time_t 被定义为unsigned long类型，而另外一些系统中，可能被定义为unsignedint 类型，这样，在移植到不同的系统中时，只要改变typedef定义，就可以在不同的系统中进行移植了。
3、表达方式更加简洁。如
使用typedef命名一个结构体时，
typedef struct
{
double x;
double y;
}rect;
rect r1 = {3.0, 6.0};
如果不使用typedef则显得复杂，
struct
{
double x;
double y;
}r1 = {3.0, 6.0};
使用typedef定义的作用域取决于typedef语句所在的位置，如果定义是在一个函数内部，它的作用域就是局部的，限定在那个函数里。如果定义是在函数外部，它将具有全局作用域。typedef中声明的类型在变量名的位置出现，而不是紧接在关键字typedef之后。typedef在语法上类似于存储类中的extern、static等，所以不能同时对一个变量类型使用typedef和static等。建立好数据类型名之后，可以使用它来进行类型声明、类型转换等。如：
typedef char *String;
String p, lineptr[MAXLINES], alloc(int); //类型声明
int strcmp(String, String);
p = (String)malloc(100); //类型转换
typedef的常用范例如下：
1、简单的定义变量的别名。
typedef char * PChar;
PChar a, b; //相当于char *a; char *b;
2、与结构体的结合使用。
typedef struct Node
{
int a;
char *b;
}*PNode;
PNode a, b;
3、对复杂的变量定义一个类型别名。
下面是参考别的博客的内容：
typedef int (*PF) (const char *, const char *)；
这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个 int 类型的返回值。对复杂变量建立一个类型别名的方法很简单，你只要在传统的变量声明表达式里用类型名替代变量名，然后把关键字typedef加在该语句的开头就行了。比如：
void (*signal (int signr,void (*handler)(int))) (int)；
可以通过两次typedef来进行定义。
typedef void sigfunc(int);
sigfunc *signal(int signr,sigfunc *handler);
其中typedef定义了一个有一个整型参数无返回值的函数类型。void (*handler)(int)表示一个有一个整型参数无返回值的函数指针，这个指针名为handler，所以其可以用sigfunc进行说明，此时sigfunc就相当于前面的int signr中int的作用；同理这个函数也是这样。
理解复杂声明可用的“右左法则”：从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。举例：
int (*func)(int *p);
首先找到变量名func，外面有一对圆括号，而且左边是一个*号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值类型是int。
int (*func[5])(int *);
func右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个*，说明func的元素是指针（注意这里的*不是修饰func，而是修饰func[5]的，原因是[]运算符优先级比*高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指针，它指向的函数具有int*类型的形参，返回值类型为int。
二、struct的用法
转载：
http://www.cnblogs.com/qyaizs/articles/2039101.html
在C中定义一个结构体类型要用typedef:
typedef struct Student
{
int a;
}Stu;
于是在声明变量的时候就可：Stu stu1;(如果没有typedef就必须用struct Student stu1;来声明)
这里的Stu实际上就是struct Student的别名。Stu==struct Student
另外这里也可以不写Student（于是也不能struct Student stu1;了，必须是Stu stu1;）
typedef struct
{
int a;
}Stu;
struct Student
{
int a;
};
于是就定义了结构体类型Student，声明变量时直接Student stu2；
======================================================================================
2、其次：
在c++中如果用typedef的话，又会造成区别：
struct Student
{
int a;
}stu1;//stu1是一个变量
typedef struct Student2
{
int a;
}stu2;//stu2是一个结构体类型=struct Student
使用时可以直接访问stu1.a
但是stu2则必须先 stu2 s2;
然后 s2.a=10;
======================================================================================
3 掌握上面两条就可以了，不过最后我们探讨个没多大关系的问题
如果在c程序中我们写：
typedef struct
{
int num;
int age;
}aaa,bbb,ccc;
这算什么呢？
我个人观察编译器（VC6）的理解，这相当于
typedef struct
{
int num;
int age;
}aaa；
typedef aaa bbb;
typedef aaa ccc;
也就是说aaa,bbb,ccc三者都是结构体类型。声明变量时用任何一个都可以,在c++中也是如此。但是你要注意的是这个在c++中如果写掉了typedef关键字，那么aaa，bbb，ccc将是截然不同的三个对象。
int iNum;
long lLength;
} MyStruct;
{
int iNum;
long lLength;
};
{
int iNum;
long lLength;
} MyStruct;
1、 首先：//注意在C和C++里不同
但在c++里很简单，直接
//此处不是很理解。
typedef struct和struct的区别：
typedef struct tagMyStruct
{
上面的tagMyStruct是标识符，MyStruct是变量类型（相当于（int,char等））。
这语句实际上完成两个操作：
1) 定义一个新的结构类型
struct tagMyStruct
分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，不论是否有typedefstruct 关键字和tagMyStruct一起，构成了这个结构类型，这个结构都存在。
我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。
2) typedef为这个新的结构起了一个名字，叫MyStruct。
typedef struct tagMyStruct MyStruct;
因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。
2.
typedef struct tagMyStruct
在C中，这个申明后申请结构变量的方法有两种：
（1）struct tagMyStruct 变量名
（2）MyStruct 变量名
在c++中可以有
（1）struct tagMyStruct 变量名
（2）MyStruct 变量名
（3）tagMyStruct 变量名
三、union的用法
转载：
http://blog.csdn.net/huqinwei987/article/details/23597091
1.联合体union的基本特性——和struct的同与不同
union，中文名“联合体、共用体”，在某种程度上类似结构体struct的一种数据结构，共用体(union)和结构体(struct)同样可以包含很多种数据类型和变量。
不过区别也挺明显：
结构体(struct)中所有变量是“共存”的——优点是“有容乃大”，全面；缺点是struct内存空间的分配是粗放的，不管用不用，全分配。
而联合体(union)中是各变量是“互斥”的——缺点就是不够“包容”；但优点是内存使用更为精细灵活，也节省了内存空间。
一个例子了然：
- //example
- #include<stdio.h>
- union var{
- long int l;
- int i;
- }
- main(){
- union var v;
- v.l = 5;
- printf("v.l is %d\n",v.i);
- v.i = 6;
- printf("now v.l is %ld! the address is %p\n",v.l,&v.l);
- printf("now v.i is %d! the address is %p\n",v.i,&v.i);
- }
- 结果：
- v.l is 5
- now v.l is 6! the address is 0xbfad1e2c
- now v.i is 6! the address is 0xbfad1e2c
所以说，管union的叫共用体还真是贴切——完全就是共用一个内存首地址，并且各种变量名都可以同时使用，操作也是共同生效。如此多的access内存手段，确实好用，不过这些“手段”之间却没法互相屏蔽——就好像数组+下标和指针+偏移一样。
上例中我改了v.i的值，结果v.l也能读取，那么也许我还以为v.l是我想要的值呢，因为上边提到了union的内存首地址肯定是相同的，那么还有一种情况和上边类似：
一个int数组变量a，一个long int(32位机中，long int占4字节，与int相同)变量b，我即使没给int变量b赋值，因为数据类型相同，我使用int变量b也完全会拿出int数组a中的a[0]来，一些时候一不小心用上，还以为用的就是变量b呢~
这种逻辑上的错误是很难找出来的（只有当数据类型相去甚远的时候稍好，出个乱码什么的很容易发现错误）。
3.联合体union和大小端（big-endian、little-endian）：
- #include<stdio.h>
- union var{
- char c[4];
- int i;
- };
- int main(){
- union var data;
- data.c[0] = 0x04;//因为是char类型，数字不要太大，算算ascii的范围~
- data.c[1] = 0x03;//写成16进制为了方便直接打印内存中的值对比
- data.c[2] = 0x02;
- data.c[3] = 0x11;
- //数组中下标低的，地址也低，按地址从低到高，内存内容依次为：04,03,02,11。总共四字节！
- //而把四个字节作为一个整体（不分类型，直接打印十六进制），应该从内存高地址到低地址看，0x11020304，低位04放在低地址上。
- printf("%x\n",data.i);
- }
结果：
11020304
证明我的32位linux是小端（little-endian）
4.联合体union所占内存空间大小：
前边说了，首先，union的首地址是固定的，那么，union到底总共有多大？根据一些小常识，做个不严谨不高深的基础版验证吧。
根据：分配栈空间的时候内存地址基本上是连续的，至少同类型能保证在一起，连续就说明，我如果弄三个结构体出来，他们三个地址应该连着，看一下三个地址的间隔就知道了。
- #include<stdio.h>
- union sizeTest{
- int a;
- double b;
- }
- main(){
- union sizeTest unionA;
- union sizeTest unionB;
- union sizeTest unionC;
- printf("the initial address of unionA is %p\n",&unionA);
- printf("the initial address of unionB is %p\n",&unionB);
- printf("the initial address of unionC is %p\n",&unionC);
- }
打印，可以看到结果：
the initial address of unionA is 0xbf9b8df8
the initial address of unionB is 0xbf9b8e00
the initial address of unionC is 0xbf9b8e08
很容易看出，8,0,8，这间隔是8字节，按double走的。
怕不保险，再改一下，把int改成数组，其他不变：
- union sizeTest{
- int a[10];
- double b;
- }
打印
the initial address of unionA is 0xbfbb7738
the initial address of unionB is 0xbfbb7760
the initial address of unionC is 0xbfbb7788
88-60=28
60-38=28
算错了？我说的可是16进制0x。那么0x28就是40个字节，正好是数组a的大小。
似乎忘了一个功能——sizeof()
用sizeof直接看，就知道union的大小了
- printf("the sizeof of unionA is %d\n",sizeof(unionA));
- printf("the sizeof of unionB is %d\n",sizeof(unionB));
- printf("the sizeof of unionC is %d\n",sizeof(unionC));
- printf("the sizeof of union is %d\n",sizeof(union sizeTest));
5.联合体union适用场合：
有了前边那个验证，基本可以确认，union的内存是照着里边占地儿最大的那个变量分的。
也就可以大胆的推测一下，这种union的使用场合，是各数据类型各变量占用空间差不多并且对各变量同时使用要求不高的场合（单从内存使用上，我觉得没错）。
像上边做的第二个测试，一个数组（或者更大的数组int a[100]），和一个或者几个小变量写在一个union里，实在没什么必要，节省的空间太有限了，还增加了一些风险（最少有前边提到的逻辑上的风险）。所以，从内存占用分析，这种情况不如直接struct。
不过话说回来，某些情况下虽然不是很节约内存空间，但是union的复用性优势依然存在啊，比如方便多命名，这种“二义性”，从某些方面也可能是优势。这种方法还有个好处，就是某些寄存器或通道大小有限制的情况下，可以分多次搬运。
6.本质&进阶：
根据union固定首地址和union按最大需求开辟一段内存空间两个特征，可以发现，所有表面的定义都是虚的，所谓联合体union，就是在内存给你划了一个足够用的空间，至于你怎么玩~它不管~！（何止是union和struct，C不就是玩地址么，所以使用C灵活，也容易犯错）
没错，union的成员变量是相当于开辟了几个接口（即union包含的变量）！但是，没开辟就不能用了？当然也能用！
写个小测试：
- #include<stdio.h>
- union u{
- int i;
- double d;//这个union有8字节大小
- };
- main(){
- union u uu;
- uu.i = 10;
- printf("%d\n",uu.i);
- char * c;
- c = &uu;//把union的首地址赋值、强转成char类型
- c[0] = 'a';
- c[1] = 'b';
- c[2] = 'c';
- c[3] = '\0';
- c[4] = 'd';
- c[5] = 'e';
- //最多能到c[7]
- printf("%s\n",c);//利用结束符'\0'打印字符串"abc"
- printf("%c %c %c %c %c %c\n",c[0],c[1],c[2],c[3],c[4],c[5]);
- }
有些东西，熟悉编译原理和编译器工作过程的话，解决会更容易点，虽然我现在这方面技能不太强，不过一般问题也足够分析了。
========================================================================================================================================================================================================================================================================
以上仅属于个人心得和推测，重点在于学习思维和推理验证过程，不保证正确性与权威性。有兴趣讨论或者有发现错误的，欢迎留言交流指正。
#include <stdio.h>
/*第一种：直接定义一种联合体mux1并定义变量m1*/
union mux1
{
int a;
char b;
};
union mux1 m1;
//等同于下边：
union mux5
{
int a;
char b;
}m5;
/*第二种：定义联合体mux2的别名defmux,可以有标签*/
typedef union mux2
{
int a;
char b;
}defmux;
defmux m2; //别名定义
union mux2 m3; //直接定义同第一种
/*第三种：定义联合体mux3的别名defmux2,可以没有标签*/
typedef union
{
int a;
char b;
}defmux2;
defmux2 m4; //只能用别名定义
TestBigEndian()
{
union mux1 m;
m.a = 0x12345678;
if( m.b == 0x12)
{
printf("小端\n");
}
else if(m.b == 0x78)
{
printf("大端\n");
}
}
int main(int argc, char *argv[])
{
TestBigEndian();
}
四、enum的用法
在实际应用中，有的变量只有几种可能取值。如人的性别只有两种可能取值，星期只有七种可能取值。在 C 语言中对这样取值比较特殊的变量可以定义为枚举类型。所谓枚举是指将变量的值一一列举出来，变量只限于列举出来的值的范围内取值。
定义一个变量是枚举类型，可以先定义一个枚举类型名，然后再说明这个变量是该枚举类型。
例如：
enum weekday{sun,mon,tue,wed,thu,fri,sat}；
定义了一个枚举类型名 enum weekday，然后定义变量为该枚举类型。例如：
enum weekday day；
当然，也可以直接定义枚举类型变量。例如：
enum weekday{sun,mon,tue,wed,thu,fri,sat} day；
其中，sum,mon,…,sat 等称为枚举元素或枚举常量，它们是用户定义的标识符。
需要说明的有以下几点。
① 枚举元素不是变量，而是常数，因此枚举元素又称为枚举常量。因为是常量，所以不能对枚举元素进行赋值。
② 枚举元素作为常量，它们是有值的，C 语言在编译时按定义的顺序使它们的值为,1,2,…。
在上面的说明中，sun 的值为 0，mon 的值为 1，…sat 的值为 6，如果有赋值语句
day=mon；
则 day 变量的值为 1。当然，这个变量值是可以输出的。例如：
printf ("%d",day)；
将输出整数 1。
如果在定义枚举类型时指定元素的值，也可以改变枚举元素的值。例如：
enum weekday{sun=7,mon=1,tue,wed,thu,fri,sat}day；
这时，sun 为 7，mon 为 1，以后元素顺次加 1，所以 sat 就是 6 了。
③ 枚举值可以用来作判断。例如：
if (day==mon) {…}
if (day>mon) {…}
枚举值的比较规则是：按其在说明时的顺序号比较，如果说明时没有人为指定，则第一个枚举元素的值认作 0。例如，mon>sun，sat>fri。
④ 一个整数不能直接赋给一个枚举变量，必须强制进行类型转换才能赋值。例如：
day=(enum weekday)2；
这个赋值的意思是，将顺序号为 2 的枚举元素赋给 day，相当于workday=tue；
【例 11.6】从键盘输入一个整数，显示与该整数对应的枚举常量的英文名称。
# include
void main( )
{
enum weekday {sun,mon,tue,wed,thu,fri,sat} day；
int k；
printf("input a number(0--6)")；
scanf("%d",&k)；
day = (enum weekday)k；
switch(day)
{
case sun： printf("sunday/n")；break；
case mon： printf("monday/n")；break；
case tue： printf("tuesday/n")；break；
case wed： printf("wednesday/n")；break；
case thu： printf("thursday/n")；break；
case fri： printf("friday/n")；break；
case sat： printf("satday/n")；break；
default： printf("input error/n")；break；
}
}
程序运行结果为：
input a number(0--6)1
monday
在该程序中，枚举常量与枚举变量可以进行比较，但要输出枚举常量对应的英文单词，不能使用以下语句：
printf(" %s",mon)；
因为枚举常量 mon 为整数值，而非字符串。
在使用枚举变量时，主要关心的不是它的值的大小，而是其表示的状态。
------------------------------------------------------------------
注：以下全部代码的执行环境为VC++ 6.0
在程序中，可能需要为某些整数定义一个别名，我们可以利用预处理指令#define来完成这项工作，您的代码可能是：
#define MON 1
#define TUE 2
#define WED 3
#define THU 4
#define FRI 5
#define SAT 6
#define SUN 7
在此，我们定义一种新的数据类型，希望它能完成同样的工作。这种新的数据类型叫枚举型。
1. 定义一种新的数据类型 - 枚举型
以下代码定义了这种新的数据类型 - 枚举型
enum DAY
{
MON=1, TUE, WED, THU, FRI, SAT, SUN
};
(1) 枚举型是一个集合，集合中的元素(枚举成员)是一些命名的整型常量，元素之间用逗号,隔开。
(2) DAY是一个标识符，可以看成这个集合的名字，是一个可选项，即是可有可无的项。
(3) 第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1。
(4) 可以人为设定枚举成员的值，从而自定义某个范围内的整数。
(5) 枚举型是预处理指令#define的替代。
(6) 类型定义以分号;结束。
2. 使用枚举类型对变量进行声明
新的数据类型定义完成后，它就可以使用了。我们已经见过最基本的数据类型，如：整型int, 单精度浮点型float, 双精度浮点型double, 字符型char, 短整型short等等。用这些基本数据类型声明变量通常是这样：
char a; //变量a的类型均为字符型char
char letter;
int x,
y,
z; //变量x,y和z的类型均为整型int
int number;
double m, n;
double result; //变量result的类型为双精度浮点型double
既然枚举也是一种数据类型，那么它和基本数据类型一样也可以对变量进行声明。
方法一：枚举类型的定义和变量的声明分开
enum DAY
{
MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY yesterday;
enum DAY today;
enum DAY tomorrow; //变量 tomorrow的类型为枚举型enum DAY
enum DAY good_day, bad_day; //变量good_day和bad_day的类型均为枚举型enum DAY
方法二：类型定义与变量声明同时进行：
enum //跟第一个定义不同的是，此处的标号DAY省略，这是允许的。
{
saturday,
sunday = 0,
monday,
tuesday,
wednesday,
thursday,
friday
} workday; //变量workday的类型为枚举型enum DAY
enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} days; //变量days的类型为枚举型enum week
enum BOOLEAN { false, true } end_flag, match_flag; //定义枚举类型并声明了两个枚举型变量
方法三：用typedef关键字将枚举类型定义成别名，并利用该别名进行变量声明：
typedef enum workday
{
saturday,
sunday = 0,
monday,
tuesday,
wednesday,
thursday,
friday
} workday; //此处的workday为枚举型enum workday的别名
workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday，也即enum workday
enum workday中的workday可以省略：
typedef enum
{
saturday,
sunday = 0,
monday,
tuesday,
wednesday,
thursday,
friday
} workday; //此处的workday为枚举型enum workday的别名
workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday，也即 enum workday
也可以用这种方式：
typedef enum workday
{
saturday,
sunday = 0,
monday,
tuesday,
wednesday,
thursday,
friday
};
workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday，也即 enum workday
注意：同一个程序中不能定义同名的枚举类型，不同的枚举类型中也不能存在同名的命名常量。错误示例如下所示：
错误声明一：存在同名的枚举类型
typedef enum
{
wednesday,
thursday,
friday
} workday;
typedef enum WEEK
{
saturday,
sunday = 0,
monday,
} workday;
错误声明二：存在同名的枚举成员
typedef enum
{
wednesday,
thursday,
friday
} workday_1;
typedef enum WEEK
{
wednesday,
sunday = 0,
monday,
} workday_2;
3. 使用枚举类型的变量
3.1 对枚举型的变量赋值。
实例将枚举类型的赋值与基本数据类型的赋值进行了对比：
方法一：先声明变量，再对变量赋值
#include<stdio.h>
/* 定义枚举类型 */
enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
void main()
{
/* 使用基本数据类型声明变量，然后对变量赋值 */
int x, y, z;
x = 10;
y = 20;
z = 30;
/* 使用枚举类型声明变量，再对枚举型变量赋值 */
enum DAY yesterday, today, tomorrow;
yesterday = MON;
today = TUE;
tomorrow = WED;
printf("%d %d %d /n", yesterday, today, tomorrow);
}
方法二：声明变量的同时赋初值
#include <stdio.h>
/* 定义枚举类型 */
enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
void main()
{
/* 使用基本数据类型声明变量同时对变量赋初值 */
int x=10, y=20, z=30;
/* 使用枚举类型声明变量同时对枚举型变量赋初值 */
enum DAY yesterday = MON,
today = TUE,
tomorrow = WED;
printf("%d %d %d /n", yesterday, today, tomorrow);
}
方法三：定义类型的同时声明变量，然后对变量赋值。
#include <stdio.h>
/* 定义枚举类型，同时声明该类型的三个变量，它们都为全局变量 */
enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN } yesterday, today, tomorrow;
/* 定义三个具有基本数据类型的变量，它们都为全局变量 */
int x, y, z;
void main()
{
/* 对基本数据类型的变量赋值 */
x = 10; y = 20; z = 30;
/* 对枚举型的变量赋值 */
yesterday = MON;
today = TUE;
tomorrow = WED;
printf("%d %d %d /n", x, y, z); //输出：10 20 30
printf("%d %d %d /n", yesterday, today, tomorrow); //输出：1 2 3
}
方法四：类型定义，变量声明，赋初值同时进行。
#include <stdio.h>
/* 定义枚举类型，同时声明该类型的三个变量，并赋初值。它们都为全局变量 */
enum DAY
{
MON=1,
TUE,
WED,
THU,
FRI,
SAT,
SUN
}
yesterday = MON, today = TUE, tomorrow = WED;
/* 定义三个具有基本数据类型的变量，并赋初值。它们都为全局变量 */
int x = 10, y = 20, z = 30;
void main()
{
printf("%d %d %d /n", x, y, z); //输出：10 20 30
printf("%d %d %d /n", yesterday, today, tomorrow); //输出：1 2 3
}
3.2 对枚举型的变量赋整数值时，需要进行类型转换。
#include <stdio.h>
enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
void main()
{
enum DAY yesterday, today, tomorrow;
yesterday = TUE;
today = (enum DAY) (yesterday + 1); //类型转换
tomorrow = (enum DAY) 30; //类型转换
//tomorrow = 3; //错误
printf("%d %d %d /n", yesterday, today, tomorrow); //输出：2 3 30
}
3.3 使用枚举型变量
#include<stdio.h>
enum
{
BELL = '/a',
BACKSPACE = '/b',
HTAB = '/t',
RETURN = '/r',
NEWLINE = '/n',
VTAB = '/v',
SPACE = ' '
};
enum BOOLEAN { FALSE = 0, TRUE } match_flag;
void main()
{
int index = 0;
int count_of_letter = 0;
int count_of_space = 0;
char str[] = "I'm Ely efod";
match_flag = FALSE;
for(; str[index] != '/0'; index++)
if( SPACE != str[index] )
count_of_letter++;
else
{
match_flag = (enum BOOLEAN) 1;
count_of_space++;
}
printf("%s %d times %c", match_flag ? "match" : "not match", count_of_space, NEWLINE);
printf("count of letters: %d %c%c", count_of_letter, NEWLINE, RETURN);
}
输出：
match 2 times
count of letters: 10
Press any key to continue
4. 枚举类型与sizeof运算符
#include <stdio.h>
enum escapes
{
BELL = '/a',
BACKSPACE = '/b',
HTAB = '/t',
RETURN = '/r',
NEWLINE = '/n',
VTAB = '/v',
SPACE = ' '
};
enum BOOLEAN { FALSE = 0, TRUE } match_flag;
void main()
{
printf("%d bytes /n", sizeof(enum escapes)); //4 bytes
printf("%d bytes /n", sizeof(escapes)); //4 bytes
printf("%d bytes /n", sizeof(enum BOOLEAN)); //4 bytes
printf("%d bytes /n", sizeof(BOOLEAN)); //4 bytes
printf("%d bytes /n", sizeof(match_flag)); //4 bytes
printf("%d bytes /n", sizeof(SPACE)); //4 bytes
printf("%d bytes /n", sizeof(NEWLINE)); //4 bytes
printf("%d bytes /n", sizeof(FALSE)); //4 bytes
printf("%d bytes /n", sizeof(0)); //4 bytes
}
5. 综合举例
#include<stdio.h>
enum Season
{
spring, summer=100, fall=96, winter
};
typedef enum
{
Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
}
Weekday;
void main()
{
/* Season */
printf("%d /n", spring); // 0
printf("%d, %c /n", summer, summer); // 100, d
printf("%d /n", fall+winter); // 193
Season mySeason=winter;
if(winter==mySeason)
printf("mySeason is winter /n"); // mySeason is winter
int x=100;
if(x==summer)
printf("x is equal to summer/n"); // x is equal to summer
printf("%d bytes/n", sizeof(spring)); // 4 bytes
/* Weekday */
printf("sizeof Weekday is: %d /n", sizeof(Weekday)); //sizeof Weekday is: 4
Weekday today = Saturday;
Weekday tomorrow;
if(today == Monday)
tomorrow = Tuesday;
else
tomorrow = (Weekday) (today + 1); //remember to convert from int to Weekday
}