在实际应用中，有的变量只有几种可能取值。如人的性别只有两种可能取值，星期只有七种可能取值。在 C 语言中对这样取值比较特殊的变量可以定义为枚举类型。所谓枚举是指将变量的值一一列举出来，变量只限于列举出来的值的范围内取值。
定义一个变量是枚举类型，可以先定义一个枚举类型名，然后再说明这个变量是该枚举类型。
. ?9 t! v6 r* }  b例如：
4 r# @' a0 K: s  v( a

1. 
   
2. enum weekday{sun,mon,tue,wed,thu,fri,sat}；

复制代码

& I, N4 x4 g& X5 h" d
4 i  b7 X' |4 X. Y, J- \. ]
  i* _" `6 z9 a6 f; m) y# X9 P定义了一个枚举类型名 enum weekday，然后定义变量为该枚举类型。例如：
  a" k6 E* m9 c4 l  r

1. 
   
2. enum weekday day；
   

复制代码

$ R+ M2 I, U3 k. ~& y6 |0 w5 k
当然，也可以直接定义枚举类型变量。例如：

1. <font color="#003000">
   
2. enum weekday{sun,mon,tue,wed,thu,fri,sat} day； </font>
   

复制代码

其中，sum,mon,…,sat 等称为枚举元素或枚举常量，它们是用户定义的标识符。
( u. B8 {2 H3 l) @/ ?) b  w% {需要说明的有以下几点：
+ \* `* F$ S9 b8 @$ W& a, X  Q- L7 n
① 枚举元素不是变量，而是常数，因此枚举元素又称为枚举常量。因为是常量，所以不能对枚举元素进行赋值。
② 枚举元素作为常量，它们是有值的，C 语言在编译时按定义的顺序使它们的值为,1,2,…。
' F5 Y3 U$ L$ ^% r3 s+ P& l3 [8 |8 V在上面的说明中，sun 的值为 0，mon 的值为 1，…sat 的值为 6，如果有赋值语句
5 X% C0 a& i) H' G2 k1 Q) z

1. 
   , {3 {4 n- T0 G) K
2. day=mon；

复制代码

( ~, E3 s; T, m则 day 变量的值为 1。当然，这个变量值是可以输出的。例如：

1. <font color="#003000">
   
2. printf ("%d",day)；</font><font face="Tahoma">
   : c) M# [: b# c! h, }* d
3. </font>

复制代码

将输出整数 1。
+ Y- \0 V# |" ^/ ?/ |" R
  t! Z  K* e0 u) @: Y: {- S6 r如果在定义枚举类型时指定元素的值，也可以改变枚举元素的值。例如：
$ E' m7 J8 b! J' z3 a2 q( z

1. 
   9 b& H3 b2 m5 H! z0 i
2. enum weekday{sun=7,mon=1,tue,wed,thu,fri,sat}day；

复制代码

这时，sun 为 7，mon 为 1，以后元素顺次加 1，所以 sat 就是 6 了。
5 F6 ]9 E/ }, |
③ 枚举值可以用来作判断。例如：

1. 
   , o  w( H. ~3 q% }( Z( u5 ]' u+ N
2. if (day==mon) {…}
   , T/ L" o# ^+ R1 V  h
3. if (day>mon) {…}

复制代码

9 f/ I) v* t3 l3 ~  r枚举值的比较规则是：按其在说明时的顺序号比较，如果说明时没有人为指定，则第一个枚举元素的值认作 0。例如，mon>sun，sat>fri。
C 语言教程 ?216?
0 A$ N6 O9 G' _
3 J" p& c3 O' e④ 一个整数不能直接赋给一个枚举变量，必须强制进行类型转换才能赋值。例如：
0 f: k) c% x0 ?5 y/ ^3 b

1. 
   , J) v6 E- u8 F4 v6 ^) F1 C
2. day=(enum weekday)2；

复制代码

这个赋值的意思是，将顺序号为 2 的枚举元素赋给 day，相当于workday=tue；
从键盘输入一个整数，显示与该整数对应的枚举常量的英文名称。

1. 
   
2. # include
   $ p, B1 D8 s# K$ N* E
3. void main( )
   
4. {
   6 ^- m& f8 Z' A: h5 g, E, W
5. enum weekday {sun,mon,tue,wed,thu,fri,sat} day；
   " S) b. f, h- Q" ^0 O9 B4 N
6. int k；
   ( k5 z& `7 b& G2 g) n4 X
7. printf("input a number(0--6)")；
   
8. scanf("%d",&k)；
   
9. day=(enum weekday)k；
   1 W2 f" X! t" c- n) Z
10. switch(day)
    
11. {
    
12. 
    
13. case sun： printf("sunday/n")；break；
    5 i# Z4 g. o1 r' T' Y
14. case mon： printf("monday/n")；break；
    1 z* v$ f! q& R& e& n# E* H8 h* N
15. case tue： printf("tuesday/n")；break；
    $ {3 O* l1 p) r: ?
16. case wed： printf("wednesday/n")；break；
    3 b; P- h$ C2 y- Q
17. case thu： printf("thursday/n")；break；
    1 J! g- A2 j6 b+ f: y
18. case fri： printf("friday/n")；break；
    
19. case sat： printf("satday/n")；break；
    5 }+ J4 J3 V- o' T. d% |; O5 O
20. default： printf("input error/n")；break；
    
21. }
    
22. }

复制代码

程序运行结果为：

1. 
   
2. input a number(0--6)1
   
3. monday

复制代码

在该程序中，枚举常量与枚举变量可以进行比较，但要输出枚举常量对应的英文单词，不能使用以下语句：
2 J) ], ?4 |1 F+ d' i

1. 
   & S7 [6 {4 q: h
2. printf(" %s",mon)；

复制代码

因为枚举常量 mon 为整数值，而非字符串。

在使用枚举变量时，主要关心的不是它的值的大小，而是其表示的状态。

6 e" h5 r5 G6 J- p) d
+ K5 s; K) }, x. J: Z& D注：以下全部代码的执行环境为VC++ 6.0
在程序中，可能需要为某些整数定义一个别名，我们可以利用预处理指令#define来完成这项工作，您的代码可能是：
5 e  t! ?- @  z" S

1. 
   
2. #define MON  1
   " c# m) C4 ^" C' i: \
3. #define TUE   2
   " k0 a! L# F# f$ ]$ ]( P" t5 ]
4. #define WED  3
   " x# K% |! Z) u/ [
5. #define THU   4
   3 c9 E# P# R. p1 b' m$ \
6. #define FRI    5
   : y5 K, n+ {; S2 n: @0 O
7. #define SAT   6
   1 b& h8 e9 N/ R
8. #define SUN   7

复制代码

) L" W, _! b' E$ [' @% v5 {
: L$ `% M, V7 F, @6 f% O; z: l在此，我们定义一种新的数据类型，希望它能完成同样的工作。这种新的数据类型叫枚举型。
* A( W" z6 |1 `& C! m# f ▍1. 定义一种新的数据类型 - 枚举型
/ Y4 X  C7 r9 ^5 f0 M) _" i
, W+ c2 r- x9 A, H% f' u以下代码定义了这种新的数据类型 - 枚举型

1. 
   4 i0 ~3 `! X3 g4 W4 k. i5 `% h4 `
2. enum DAY
   
3. {
   # Q- H, @. k# Y
4.       MON=1, TUE, WED, THU, FRI, SAT, SUN
   
5. };
   

复制代码

6 x6 [. g5 ~0 V+ B6 c: @3 |
(1) 枚举型是一个集合，集合中的元素(枚举成员)是一些命名的整型常量，元素之间用逗号,隔开。
* Z  V, k3 T1 d) P) X
# l' m5 z, a7 H" W! t(2) DAY是一个标识符，可以看成这个集合的名字，是一个可选项，即是可有可无的项。
(3) 第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1。
4 o& n: w4 Z9 x1 C& A* x7 E& K(4) 可以人为设定枚举成员的值，从而自定义某个范围内的整数。
(5) 枚举型是预处理指令#define的替代。

(6) 类型定义以分号;结束。
▍2. 使用枚举类型对变量进行声明
/ k7 R3 @) q5 c4 \
& S3 Y+ ]4 n8 L" M  \, O  i新的数据类型定义完成后，它就可以使用了。我们已经见过最基本的数据类型，如：整型int, 单精度浮点型float, 双精度浮点型double, 字符型char, 短整型short等等。用这些基本数据类型声明变量通常是这样：
& X' K3 z6 e7 M1 f. J

1. 
   
2. char     a; //变量a的类型均为字符型char
   9 ^' d, U/ t+ Z$ u  I8 q
3. char     letter;
   6 \) Y. }' H: e# p4 ~* Z) w8 W/ N
4. int        x,
   , n% o3 E7 _* x* b/ L  n) V
5.            y,
   $ H  f9 s6 U( ]/ g
6.            z; //变量x,y和z的类型均为整型int
   6 m0 G6 ]1 k( Y0 S( y6 N
7. int       number;
   9 P4 Z, p$ m* A" ?
8. double  m, n;
   ; v2 t/ Q7 w4 x% k0 }0 ^3 k  _# V  P
9. double  result; //变量result的类型为双精度浮点型double
   ; R" c9 z) B8 x6 l: {

复制代码

/ s3 M( C& X7 G" }, v6 F/ \8 B
既然枚举也是一种数据类型，那么它和基本数据类型一样也可以对变量进行声明。
  e% x6 \5 q9 j  Y8 z方法一：枚举类型的定义和变量的声明分开
3 F" b/ X5 i3 H9 M' d: q

1. 
   
2. enum DAY
   ) W! T6 X" W+ j: n
3. {
   ' V' w' j4 A! k+ \1 a, L8 i
4.       MON=1, TUE, WED, THU, FRI, SAT, SUN
   
5. };
   / J. j; v* b; H6 f4 ]; h
6. 
   
7. enum DAY yesterday;
   
8. enum DAY today;
   & q6 `; {/ w4 v, ^' B" n% Y
9. enum DAY tomorrow; //变量 tomorrow的类型为枚举型enum DAY
   . w9 ?' b4 w9 S
10. enum DAY good_day, bad_day; //变量good_day和bad_day的类型均为枚举型enum DAY
    

复制代码

方法二：类型定义与变量声明同时进行

1. 
   
2. enum //跟第一个定义不同的是，此处的标号DAY省略，这是允许的。
   
3. {
   $ U5 w0 j8 g# G2 ^/ b4 ?
4.     saturday,
   
5.     sunday = 0,
   1 B" ^7 M. Z% x1 r$ t; q/ |
6.     monday,
   : A. v7 O1 P8 H2 s# U' s
7.     tuesday,
   
8.     wednesday,
   
9.     thursday,
   
10.     friday
    : f# X1 ^0 _3 M7 U- s" W5 |
11. } workday; //变量workday的类型为枚举型enum DAY
    
12. enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} days; //变量days的类型为枚举型enum week
    
13. enum BOOLEAN { false, true } end_flag, match_flag; //定义枚举类型并声明了两个枚举型变量
    6 Y2 s7 ~+ O# g, L$ d: G- T( e

复制代码

' c) ~' P" l# K
. F  [& _1 x1 J; O- n方法三：用typedef关键字将枚举类型定义成别名，并利用该别名进行变量声明
& o, u1 I; b: Y1 ~/ t8 A8 _

1. <font color="#005000"><font face="Tahoma">
   
2. typedef enum workday
   
3. {
   
4.     saturday,
   
5.     sunday = 0,
   
6.     monday,
   ; ]4 v% _) L# y  h7 w) }
7.     tuesday,
   $ k1 B- E5 n0 i6 ^, y% R, n( o8 F: F( z
8.     wednesday,
   * e/ o/ S0 Q+ @: I
9.     thursday,
   9 d- Y: v6 N- a) r# }: x
10.     friday
    ( |/ g+ E4 @- I4 z  F
11. } workday; //此处的workday为枚举型enum workday的别名
    
12. workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday，也即enum workday</font></font><font color="#003000">
    
13. </font>

复制代码

! b" I( D2 W5 U7 v& w3 s- E4 E7 L. T
% L- s: W5 ]8 M, v

enum workday中的workday可以省略：

1. 
   
2. typedef enum
   * M) d3 a4 Z" h& ]: m( O; k+ @2 _
3. {
   
4.     saturday,
   
5.     sunday = 0,
   / G2 y0 @- n; s' t. o* X5 x
6.     monday,
   
7.     tuesday,
   " g0 a) |0 U) A; K
8.     wednesday,
   
9.     thursday,
   
10.     friday
    * D5 {2 ~# g' ]
11. } workday; //此处的workday为枚举型enum workday的别名
    
12. workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday，也即 enum workday
    9 d% r  p- j) A

复制代码

也可以用这种方式：

1. 
     ^/ X! G' \) x
2. typedef enum workday
   
3. {
   
4.     saturday,
   + u! z* Z6 r4 b9 U" s
5.     sunday = 0,
   
6.     monday,
   
7.     tuesday,
   3 Q' ]7 o6 o4 ]6 _% [9 [
8.     wednesday,
   6 w0 O9 r7 u$ J, A5 p
9.     thursday,
   ' U: j' j/ e% u# l* w
10.     friday
    
11. };
    3 N. F) ]% [% d9 {
12. workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday，也即 enum workday
    

复制代码

注意：同一个程序中不能定义同名的枚举类型，不同的枚举类型中也不能存在同名的命名常量。错误示例如下所示：
错误声明一：存在同名的枚举类型

1. 
   & }1 r  P7 h2 V# t1 f
2. typedef enum
   
3. {
   & S9 A" q; m% J. Z1 I  p
4.     wednesday,
   & \& p  H& _( s1 b. \2 s3 p# t. ?
5.     thursday,
   
6.     friday
   , B6 r- H$ K" K+ |, K* A& p
7. } workday;
   
8. typedef enum WEEK
   ( `& \* `7 I+ W  y3 ^0 v% h
9. {
   
10.     saturday,
    , s4 f( R6 Y. J) m+ i7 a
11.     sunday = 0,
    
12.     monday,
    9 D# k' O6 d- H6 c
13. } workday;
    % m$ f7 @3 k# w  ?1 I9 n& s

复制代码

1 D2 M( F3 L3 {8 E4 X
错误声明二：存在同名的枚举成员
" B( D: S( P3 G6 k( b$ \

1. 
   * m; y! _+ ^1 [4 Z+ k
2. typedef enum
   2 z# I1 `" r+ B/ a' i$ r1 T
3. {
   . j" ?8 }: ?! o, N- |
4.     wednesday,
   
5.     thursday,
   # q3 c( J; n  H% h+ B2 ?2 A
6.     friday
   ( O0 E4 ?2 D: V
7. } workday_1;
   
8. typedef enum WEEK
   
9. {
   & ?: R3 s# b. K3 e5 l1 S
10.     wednesday,
    
11.     sunday = 0,
    3 q' u, L# \9 Z( G+ x% S
12.     monday,
    
13. } workday_2;

复制代码

▍3. 使用枚举类型的变量
2 I" {' j: o7 Z  v' R' A2 F3 B& R3.1 对枚举型的变量赋值。
实例将枚举类型的赋值与基本数据类型的赋值进行了对比：
方法一：先声明变量，再对变量赋值

1. 
   
2. #include<stdio.h>
   
3. /* 定义枚举类型 */
   
4. enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
   / g4 Y) @# G6 C) q1 C
5. void main()
   
6. {
   
7.     /* 使用基本数据类型声明变量，然后对变量赋值 */
   9 O0 t* l! o0 C( M
8.     int x, y, z;
   1 O6 g/ e# J7 q! G
9.     x = 10;
   
10.     y = 20;
    
11.     z = 30;
    
12.     /* 使用枚举类型声明变量，再对枚举型变量赋值 */
    + P( }0 ^" H- v- _0 i0 n9 ~9 Y
13.     enum DAY yesterday, today, tomorrow;
    
14.     yesterday = MON;
    2 E( Y, V+ K0 t3 c5 A/ x' ?5 Y  a
15.     today     = TUE;
    ) e' i: ?$ s" G0 v: M" g5 f
16.     tomorrow  = WED;
    3 c* C: q6 y: _0 U; i: e5 {
17.     printf("%d %d %d /n", yesterday, today, tomorrow);
    
18. }

复制代码

方法二：声明变量的同时赋初值

1. 
   ) X0 L- ]" [- ~. Q: y6 v3 p
2. #include <stdio.h>
   - B: {. s  X$ G" D. T
3. 
   9 ]; D( e* P; M# H( d
4. /* 定义枚举类型 */
   
5. 
   
6. enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
   
7. 
   
8. void main()
   
9. {
   
10. 
    
11.     /* 使用基本数据类型声明变量同时对变量赋初值 */
    
12. 
    
13.     int x=10, y=20, z=30;
    
14. 
    
15.     /* 使用枚举类型声明变量同时对枚举型变量赋初值 */
    ( @6 x/ k8 i+ w4 h/ S8 R1 z8 ^) n3 v
16. 
    " j/ N" h1 e) y' m3 P( a  m* k* J
17.     enum DAY yesterday = MON,
    
18. 
    0 M0 ]% y: E7 n" x) j
19.                         today = TUE,
    - q' H# }6 ^9 R7 |" X0 V+ k
20. 
    
21.                    tomorrow = WED;
    8 |, x2 @8 v9 S5 q  Q
22. 
    & |; F. @1 [/ F# ^$ x
23.     printf("%d %d %d /n", yesterday, today, tomorrow);
    
24. }

复制代码

方法三：定义类型的同时声明变量，然后对变量赋值。
9 a+ l( s. E3 J: D

1. 
   
2. #include <stdio.h>
   
3. /* 定义枚举类型，同时声明该类型的三个变量，它们都为全局变量 */
   
4. enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN } yesterday, today, tomorrow;
   
5. /* 定义三个具有基本数据类型的变量，它们都为全局变量 */
   . |9 @; y0 q% e( A/ L+ L+ f
6. int x, y, z;
   0 F. L& A0 ]% d5 @
7. void main()
   
8. {
   & _" M5 i: r& V
9.     /* 对基本数据类型的变量赋值 */
   . L) R/ v: K- e8 `$ c6 k+ U( e3 C
10.     x = 10;  y = 20;  z = 30;
    
11.     /* 对枚举型的变量赋值 */
    
12.     yesterday = MON;
    $ ^% E8 F  Y. u3 p) H. }6 `
13.     today     = TUE;
    
14.     tomorrow  = WED;
    
15.     printf("%d %d %d /n", x, y, z); //输出：10 20 30
    
16.     printf("%d %d %d /n", yesterday, today, tomorrow); //输出：1 2 3
    
17. }

复制代码

/ E/ A/ P, K+ f; R$ Z. X
1 [* h, r# t  ^; {方法四：类型定义，变量声明，赋初值同时进行。
- `) Y1 r2 d# O3 w

1. 
   ' f% M6 [9 X* x6 x; t, L
2. #include <stdio.h>
   ! O% {6 X. Y4 K9 T/ p
3. /* 定义枚举类型，同时声明该类型的三个变量，并赋初值。它们都为全局变量 */
   0 R1 n# R9 c0 o8 V" R+ M
4. enum DAY
   7 r* X$ P, M: F1 Y
5. {
   
6.     MON=1,
   
7.     TUE,
   
8.     WED,
   
9.     THU,
   + y, ^- y& X) B& z: {8 o
10.     FRI,
    
11.     SAT,
    1 f! A+ R; t6 F6 U0 ^4 @$ C
12.     SUN
    
13. }
    
14. yesterday = MON, today = TUE, tomorrow = WED;
    0 m# Q3 c" _& P( ]
15. /* 定义三个具有基本数据类型的变量，并赋初值。它们都为全局变量 */
    
16. int x = 10, y = 20, z = 30;
    
17. void main()
    - W+ [; q, M# h
18. {
    0 R- h1 B" T! }' H) X' ]! J
19.     printf("%d %d %d /n", x, y, z); //输出：10 20 30
    * y! E& c  G4 B$ r% T; H
20.     printf("%d %d %d /n", yesterday, today, tomorrow); //输出：1 2 3
    
21. }

复制代码

3.2 对枚举型的变量赋整数值时，需要进行类型转换。
1 h# X0 V2 |. G& ^2 l7 |& R

1. 
   8 _) V$ C% ?& ?1 X/ ?; G# T' Y
2. #include <stdio.h>
   
3. 
   
4. enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
   * @! J) ?1 B8 N3 }  |1 |' V
5. 
   ! f! n/ W# b% m3 I
6. void main()
   + i7 B  c* @/ P) k2 X% b
7. {
   
8. 
   
9.     enum DAY yesterday, today, tomorrow;
   
10. 
    
11.     yesterday = TUE;
    
12. 
    
13.     today = (enum DAY) (yesterday + 1); //类型转换
    
14. 
    
15.     tomorrow = (enum DAY) 30; //类型转换
    
16. 
    $ T+ I! u* o( l& G% D  Y' ]  h1 o/ C4 I
17.     //tomorrow = 3; //错误
    * m8 i( V5 R5 o% }
18. 
    
19.     printf("%d %d %d /n", yesterday, today, tomorrow); //输出：2 3 30
    
20. 
    
21. }

复制代码

4 U1 e, `2 D/ W3.3 使用枚举型变量
8 S$ x  L5 n  L$ Z* {: r2 Z* k

1. 
   
2. #include<stdio.h>
   , M  ?6 Q3 p1 D. }5 k3 f
3. enum
   ! U% ~$ w: h3 O5 U! f2 ^  D
4. {
   ' x  l: ?! D( x) _5 e
5.     BELL          = '/a',
   8 D$ N$ o; S2 h! z
6.     BACKSPACE = '/b',
   ' [- M! x8 {8 C8 k; D4 v! @' d
7.     HTAB         = '/t',
   
8.     RETURN      = '/r',
   # Q( a9 Y, I1 c
9.     NEWLINE    = '/n',
   % i& z. `. ]9 m8 n, x
10.     VTAB         = '/v',
    - x/ N; ^: B) ?, O1 N5 C# j6 A, L4 W
11.     SPACE       = ' '
    ( M( S, P  Y9 m+ G' M
12. };
    5 J7 N+ J0 |0 {  r" a5 F
13. enum BOOLEAN { FALSE = 0, TRUE } match_flag;
    
14. void main()
    - R; |2 ?! \+ x
15. {
    ' B; m6 o3 ^4 A* [2 u, i& O
16.     int index = 0;
    
17.     int count_of_letter = 0;
    
18.     int count_of_space = 0;
    : g$ m# C% V/ n
19.     char str[] = "I'm Ely efod";
    ; R+ u/ \5 Z5 v  N; w2 z# D0 n3 G
20.     match_flag = FALSE;
    
21.     for(; str[index] != '/0'; index++)
    1 W) m0 Y, W% P
22.         if( SPACE != str[index] )
    . r- L8 s3 p7 f* w+ n; k
23.             count_of_letter++;
    
24.         else
    # W, B6 Y7 J! J" t  x9 c- |
25.         {
    ; U2 _9 C2 G% u
26.             match_flag = (enum BOOLEAN) 1;
    5 {  O0 _; \7 h4 V
27.             count_of_space++;
    
28.         }
    # z1 e1 [) Z) N% o9 Y( B$ ?
29.     printf("%s %d times %c", match_flag ? "match" : "not match", count_of_space, NEWLINE);
    ( r& w3 q1 q3 \. S8 w
30.     printf("count of letters: %d %c%c", count_of_letter, NEWLINE, RETURN);
    8 A* ?( @, [4 P  v! r' K9 c% F0 i
31. }
    

复制代码

9 _, D; m! H! p& p$ Z: k% k
' C" O/ ~  F- W2 j! |) ?, W输出：
/ K/ O" G  U& J6 W8 B. n: S- m

1. 
   
2. match 2 times
   
3. count of letters: 10
   ) N# n8 }2 P, I" E+ [
4. Press any key to continue

复制代码

2 A4 S& ^( n4 ^( d$ H▍4. 枚举类型与sizeof运算符

1. 
   
2. #include <stdio.h>
   3 ?/ R! W; K* q) H# Y6 Q
3. enum escapes
   
4. {
   ; G% l0 Z3 l  ]' C% M  T# P
5.     BELL      = '/a',
   
6.     BACKSPACE = '/b',
   
7.     HTAB      = '/t',
   
8.     RETURN    = '/r',
   
9.     NEWLINE   = '/n',
   
10.     VTAB      = '/v',
    
11.     SPACE     = ' '
    
12. };
    - g' k0 p" S: r: y6 X. y
13. enum BOOLEAN { FALSE = 0, TRUE } match_flag;
    
14. void main()
    5 Z  |5 R: I8 s) f  T
15. {
    $ Q# A8 C" J5 q
16.     printf("%d bytes /n", sizeof(enum escapes)); //4 bytes
    ; w2 `0 v8 ?' F! B, U6 Z# N
17.     printf("%d bytes /n", sizeof(escapes)); //4 bytes
    & B( w; @/ a# P/ D2 ]
18.     printf("%d bytes /n", sizeof(enum BOOLEAN)); //4 bytes
    9 r! e: x, J- E+ i$ S, ~7 ^
19.     printf("%d bytes /n", sizeof(BOOLEAN)); //4 bytes
    3 v& O. y% O5 p8 z  H- J
20.     printf("%d bytes /n", sizeof(match_flag)); //4 bytes
    
21.     printf("%d bytes /n", sizeof(SPACE)); //4 bytes
    
22.     printf("%d bytes /n", sizeof(NEWLINE)); //4 bytes
    
23.     printf("%d bytes /n", sizeof(FALSE)); //4 bytes
    
24.     printf("%d bytes /n", sizeof(0)); //4 bytes
    3 |0 s0 h3 V3 M- i
25. }
    ! r  V* ~+ D. X% o

复制代码

" {: V/ x! C: X2 p: p3 [
▍5. 综合举例

1. 
   
2. #include<stdio.h>
   
3. enum Season
   . L1 m0 S7 R- l
4. {
   ' c4 {% Q, a9 U! f# J9 ~$ C5 K
5.     spring, summer=100, fall=96, winter
   
6. };
   9 D6 v' v4 w; B, j9 g2 z
7. typedef enum
   
8. {
   
9.     Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
   3 h) K6 F" Q" i+ |( h
10. }
    8 h4 b6 g/ m$ w1 k3 c
11. Weekday;
    
12. void main()
    9 Q7 I$ Z. E: D7 D
13. {
    
14.     /* Season */
    
15.     printf("%d /n", spring); // 0
    
16.     printf("%d, %c /n", summer, summer); // 100, d
    
17.     printf("%d /n", fall+winter); // 193
    3 D, f, T7 E. c
18.     Season mySeason=winter;
    
19.     if(winter==mySeason)
    
20.         printf("mySeason is winter /n"); // mySeason is winter
    " V4 d( G! d& c/ g- G- n0 ?! k
21.    
    
22.     int x=100;
    7 k$ c) H' Z( `7 z
23.     if(x==summer)
    5 c, c! f  ]) \6 E8 g+ i
24.         printf("x is equal to summer/n"); // x is equal to summer
    + J, Q7 h" r1 H/ i9 K7 \
25.     printf("%d bytes/n", sizeof(spring)); // 4 bytes
    
26.     /* Weekday */
    
27.     printf("sizeof Weekday is: %d /n", sizeof(Weekday)); //sizeof Weekday is: 4
    
28.     Weekday today = Saturday;
    , f  ?& X: C* M5 Q$ d; O) w2 D
29.     Weekday tomorrow;
    
30.     if(today == Monday)
    $ e# X4 |6 i  v  u+ M2 w5 V  P
31.         tomorrow = Tuesday;
    0 |) o8 J# U' t9 E% x- [
32.     else
    
33.         tomorrow = (Weekday) (today + 1); //remember to convert from int to Weekday
    ( H# M  |" x, f# T6 u
34. }

复制代码