“枚举类型”与“枚举变量”有什么区别？？

变量别放在头文件里。由于头文件可能被多模快引用，就可能出现重复定义。作为全局变量，在一个模快中定义一次，而在其他模快中用“extern”说明之。按lz情形，应该出现的是“未定义”的错误，因为“extern”不提供实质意义上的变量物理空间的分配。解决的方法是：头文件中放置enumabc{a,b,c};c文件中放置enumabccc;//在某一主模块中externenumabccc;//在其他模块中这样，就可以对cc进行操作了，如：cc=c;

不用这么麻烦吧，直接输出printf("%d",green);就醒了

enum charc{a，b，c} theWeek;中间没有逗号啊？

你可以查找和阅读课文。这里不好开课。简单的定义例子如下：类型定义： enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };变量声明 enum DAY yesterday;变量声明 enum DAY today;变量声明 enum DAY tomorrow;类型定义 + 变量声明： enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} days; //变量days的类型为枚举型enum week

enum是计算机编程语言中的一种数据类型。枚举类型：在实际问题中，有些变量的取值被限定在一个有限的范围内。C语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值，被说明为该“枚举”类型的变量取值不能超过定义的范围。例如，一个星期内只有七天，一年只有十二个月，一个班每周有六门课程等。如果把这些量说明为整型，字符型或其它类型显然是不妥当的。赋值和使用枚举类型在使用中有以下规定：1、枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。2、枚举元素本身由系统定义了一个表示序号的数值，从0开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1，sat值为6。只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如一定要把数值赋予枚举变量，则必须用强制类型转换。以上内容参考：百度百科-ENUM

在c语言中，枚举变量，即以enum关键字定义的变量，是按照整型或者无符号整型来处理的。1如果在枚举变量中，不存在负值，如enumtest{a,b,};这样的定义，系统会将该枚举变量按照无符号整型处理，即unsignedint型。输出的时候使用%u格式即可。enumtestt=a;printf("%u",t);2如果在枚举变量中存在负值，那么系统按整型处理，即int型。如定义enumtest{a=-199,b,};输出时，需要用%d格式：enumtestt=a;printf("%d",t);3由于枚举变量在书写时，一般不会太大，很少有在没有负数的时候，即按照无符号数处理的时候超出有符号数所能表示的正数范围，即一般不会把最高位置一，所以大多数情况下，用%d输出都是没问题的。

1、不同语言的枚举定义关键字有所不，内容大致相同。2、以为vb6为例，所谓枚举变量，就是指用 Enum 类型定义的变量。变量和参数都可以定义为 Enum 类型。Enum 类型中的元素被初始化为 Enum 语句中指定的常数值。所赋给的值可以包括正数和负数，且在运行时不能改变。例如：Enum SecurityLevel IllegalEntry = -1 SecurityLevel1 = 0 SecurityLevel2 = 1End Enum3、vb6枚举量的使用方法：Private Enum MyColor red = &HFF& green = &HFF00& blue = &HFF0000End EnumPrivate Sub Command1_Click()Me.BackColor = MyColor.blueMe.BackColor = blueDim icolor As MyColoricolor = blueMe.BackColor = icolorEnd Sub

枚举类型是当这个变量有几种可能的取值时，实现变量的互斥取值

默认从0开始

从2进制位的角度，去看0000000100000011

enumday{sunday,monday,tuesday,wendsday,thursday,friday,stadurday};这句定义了符号化的常量sunday，monday等等。在下面的程序中，可以声明枚举型变量daytoday，对其赋值，或者判断它的值。定义枚举型的好处主要有二，首先增强程序可读性，sunday、monday肯定比0,1容易理解；其次可以对变量类型与取值进行限定。枚举型常量即某种枚举型的合法取值，此例中，sunday,monday,tuesday,wendsday,thursday,friday,stadurday是枚举型常量。在编译时确定各个常量的对应值。枚举型变量指的是声明为已定义枚举类型的变量。如此例中的today。

枚举变量未分配初始值。默认情况下，第一个枚举成员的默认值为“0”，后续枚举成员值为前一个枚举成员的值（按文本顺序）加一。但是，其值必须在基础类型可以表示的值范围内;枚举类型，通过预定义列出所有值的标识符来定义有序集，其顺序与枚举类型描述中的标识符顺序一致。枚举类型的形式:(标识符1，...，标识符n）。枚举元素只能是标识符，而不是数字常量或字符常量。枚举在C/C++/c#中，是一个被命名的整型常数的集合, 枚举在日常生活中很常见。例如表示星期的SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY，SATURDAY，就是一个枚举。扩展资料使用枚举类型注意：枚举中每个成员(标识符)结束符是"," 不是";", 最后一个成员可省略","。初始化时可以赋负数, 以后的标识符仍依次加1。枚举变量只能取枚举说明结构中的某个标识符常量。参考资料：百度百科-枚举类型参考资料：百度百科-枚举

enumday{sunday,monday,tuesday,wendsday,thursday,friday,stadurday};//申明一个枚举对象//实例化该枚举对象，today就是一个变量，该变量的类型是枚举型daytoday;today=monday;//具体调用带对象，给这个对象赋值

可以

强转

那用GCC 试试， 应该可以的

枚举， 是一系列值，每个都相当于一个整型常量。 枚举类型的变量 其实就是整型变量结构体， 是一组数据的集合， 可以是不同类型所以 二者没有什么相同的唯一相同的 就是都属于自定义类型。

我不是高手哦 才了解了枚举，大概理解下吧~通过使用enum，可以创建一个新的类型，并且制定它可以具有的值（实际上是INT型的，虽然大多用字符来枚举，可是这些字符都代表的是INT型的整数常量）主要的使用目的是为了增加程序的可读性。简单来说，就是我们在选择分支的时候，可以定义一个变量来确定各个分支的顺序，比如0，1,2,3,4，。。。。但是这样不好读，尤其是编写者之外的人读，很让人费解，这个时候可以,0.1.2,3,4.。。赋予一些实际的含义。典型的例子：enum spectrum {red,orange,yellow,green,blue,violet};---enum spectrum color;以上定义了color的可能值red,orange等等。以下是应用：int c;color=blue;if (color == yellow) ....;如果不用枚举量，我们可以用int color;color=1;if (color ==1).....来进行判断，但是明显用枚举可读性比较好。------以上是我暂时的理解，再深刻一点，我怕我理解的错了 ，呵呵~

就是一个一个的全部列举出来，你学C吗？

一、类型定义类型定义的语法格式：type<标识符1>=<类型1>；<标识符2>=<类型2>；……<标识符n>=<类型n>；二、枚举类型通过预定义列出所有值的标识符来定义一个有序集合，这些值的次序和枚举类型说明中的标识符的次序是一致的。枚举类型的形式：(标识符1，……，标识符n)例如： type daystype=(sunday,monday,tuesday,wednesday,thursday,friday,saturday)枚举元素只能是标识符，而不能是数值常量或字符常量。例如以下的定义是错误的：type daystype=("sun","mon","tue","wed","thu","fri","sat")枚举元素是标识符，不要把作为枚举元素的标识符视作变量名，它不能被赋值。同一个枚举元素不能出现在两个或两个以上的枚举类型定义中。例如以下的定义是错误的：type daytype1=(monday,tuesday);daytype2=(monday,wednesday);可以将枚举类型的定义和变量的定义结合在一起。例如：var a:(monday,tuesday,sunday)枚举类型属于顺序类型。根据定义类型时各枚举元素的排列顺序确定它们的序列，序列号从0开始

就是举例子

你先cin到int 中,再把int 赋给r

你需要建立一个表记录各个枚举数据对应的字符串，并与输入字符串逐一比较，第几个字符串就查表得到相应的枚举数据，所以有时还不如就用整型数据来替代枚举数据使用。

在定义变量时直接赋值。

缺省枚举类型的第一个值等于0，后续依次增1，可以认为是整形，其取值可以在类型定义中调整，如：enum u{a=1,b=-1,c=3}f;不能直接用cin直接输入数据到枚举变量，但可以先输入到整形变量，再赋值给枚举变量，也可以直接赋值常量：如：enum u{a=1,b=-1,c=3}f;int n;f = a;printf("%d ",f);//输出1f = b;printf("%d ",f);//输出-1f = 3;printf("%d ",f);//输出3cin>>f;printf("%d ",f);//不论输入什么值，f的值还是3cin>>n;f = n;printf("%d ",f);//输入什么值，f的值就是什么值

　　一、类型定义　　类型定义的语法格式：　　type　　<标识符1>=<类型1>；　　<标识符1>=<类型1>；　　……　　<标识符n>=<类型n>；　　二、枚举类型　　通过预定义列出所有值的标识符来定义一个有序集合，这些值的次序和枚举类型说明中的标识符的次序识一致的。枚举类型的形式：(标识符1，……，标识符n)　　例如： type daystype=(sunday,monday,tuesday,wednesday,thursday,friday,saturday)　　枚举元素只能是标识符，而不能是数值常量或字符常量。例如以下的定义是错误的：　　type daystype=("sun","mon","tue","wed","thu","fri","sat")　　枚举元素是标识符，不要把作为枚举元素的标识符视作变量名，它不能被赋值。同一个枚举元素不能出现在两个或两个以上的枚举类型定义中。例如以下的定义是错误的：　　type daytype1=(monday,tuesday);　　daytype2=(monday,wednesday);　　可以将枚举类型的定义和变量的定义结合在一起。例如：var a:(monday,tuesday,sunday)　　枚举类型属于顺序类型。根据定义类型时各枚举元素的排列顺序确定它们的序列，序列号从0开始　　例如：已经定义daystype　　ord(sunday)=0,succ(sunday)=monday,pred(friday)=thursday　　但是枚举类型中的第一个元素没有前趋，最后一个元素没有后继。Turbo Pascal不允许直接读写枚举值，所以枚举值的输出常用case语句间接的输出。枚举值的输入，则要一一判断读入字符是否是枚举类型的标识符。若是才能赋给枚举变量，否则就会出错。　　例如：枚举值的输出　　case day of　　sunday:write("sunday");　　monday:write("monday");　　tuesday:write("tuesday");　　wednesday:write("wednesday");　　thursday:write("thursday");　　friday:write("friday");　　saturday:write("saturday");　　end;　　三、子界类型　　子界类型是由整型、字符型、枚举型、布尔型的两个常量指定该类型的值域区间。子界类型的形式：　　常量．．常量 两个常量必须是同一种顺序类型。例如：a．．b，要求a<=b　　例如：　　type a=1..3;　　b="a".."d";　　一个子界类型继承它的常量类型的运算符和标准函数，常量类型相容的不同子界类型可以混合运算，可以赋值。可以将子界类型的定义和变量的定义结合在一起。例如：var a:1．．9　　例 按月、日、年顺序读入一日期，输出该日期是这一年中的第几天。　　program date;　　var year:0..2010;　　month,i:1..12;　　day:1..31;　　dayth:integer;　　begin　　read(month,day,year);　　dyath:=0;　　for i:=1 to month-1 do　　case i of　　1,3,5,7,8,10,12:dayth:=dayth+31;　　2:if ((year mod 4=0)and(year mod 100<>0)or(year mod 400 =0)　　then dayth:=dayth+29　　else dayth=:=dayth+28;　　4,6,9,11:dayth:=dayth+30;　　end;　　dayth:=dayth+day;　　writeln(dayth)　　end.　　四、类型相容和赋值相容　　1.类型相容性　　类型相容是对参加同一运算的两个对象的类型要求。设有两个变量，如果满足下列条件之一，就说这两个变量的类型相容。　　(1)两个变量的类型相同　　a.两个变量被同一类型说明。　　例如：var a,b:1..30;　　b.两个变量的类型是同一类型标识符。　　例如：var a:1..30; b:1..30;　　c.两个变量的类型是不同的类型标识符，但在类型定义中已经说明两个标识符相同。　　例如：type date=1..100; range=date;　　var m:data;n:range;　　(2)一个变量的类型是另一个变量的子界。　　(3)两个变量的类型都是同一基类型的子界。　　(4)两个变量的类型是基类型相容的集合类型。　　(5)两个变量的类型是成分相同的串类型。　　2.赋值相容性　　赋值相容是对赋值操作的两个对象的类型要求。设赋值语句“：＝”左边的变量类型为T，右边表达式的类型为E,若类型T和类型E满足下列条件之一，则称他们是赋值相容的。　　(1)T和E是相同的类型，而且类型不是文件类型，也不是具有文件类成分的构造类型。　　(2)T是实型，而E是整型或整型的子界。　　(3)T和E是类型相容的顺序类型，并且E的值不超出T所定义的值的范围　　(4)T和E是类型相容的集合类型，并且E的值不超出T所定义的值的范围　　(5)T和E是类型相容的串类型。　　当T和E是顺序类型或都是集合类型时，不仅要求这两个类型是相容的，而且要求E的值不超出T所定义的值的范围；否则将产生类型溢出，而这种错误只能在你运行程序时进行检查，因此你必须要避免不发生这种错误。

如果一个变量只有集中可能的值，可以定义为枚举类型。所谓“枚举”是指将变量一一列举出来，变量的值只限于列举出来的值的范围内。下面是示意代码:Private Enum Color " 定义名为Color的枚举类型 Black = 1 White = 2 Yellow = 3 Red = 4 Green = 5 Blue = 6 End Enum Private Sub Command1_Click() Dim My_Color As Color " 定义变量My_Color为Color的枚举类型 Dim Back_Color As Color " 定义变量Back_Color为Color的枚举类型 My_Color = Green " 对My_Color赋值 Back_Color = Black " 对Back_Color赋值 Text1.Text = My_Color + Back_Color " 文本框内显示My_Color + Back_Color的值 End Sub

额 貌似 枚举它本身就是一个类型 不过枚举变量中的枚举元素系统是按照常量来处理的，故叫枚举常量

就是一个二进制的编号, 没有任何意义, 根据你枚举的量的多少来定, 比如你枚举2个, 那就是0和1， 枚举3~4个, 就有3位, 枚举60个, 就是6位.枚举一般都是用来表示状态的, 自动机里面用的

枚举类型支持加操作，但不支持++操作。。(day=monday;day<=sunday;day=(枚举类型)(day+1))

顺序没错啊，这两列应该都是枚举变量的值你使用时应该这样用：Rank rk=Rank.Ace;或Rank rk=Rank.Queen; 一个美剧变量只能是枚举中的一种情况

我是vb的初学者我记得c有枚举vb中有没有我就不知道了目前还没听说vb中有枚举我感觉记录和枚举是相似的

枚举类型在使用中有以下规定：枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值： sun=5;mon=2;sun=mon; 都是错误的。枚举元素本身由系统定义了一个表示序号的数值，从0 开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1， …,sat值为6。例如：#include<stdio.h>int main(){enum weekday{sun,mon,tue,wed,thu,fri,sat };weekday a,b,c; //将a，b，c定义为枚举变量a=sun;b=mon;c=tue;printf(%d,%d,%d,a,b,c);return 0;}运行结果为：0,1,2枚举值也可以用来做判断比较。如：if(mon>sun) …枚举变量的值可以由程序员自己定。如：enum weekday{sun=7,mon=1,tue,wed,thu,fri,sat};定义sun为7，mon为1，以后按顺序加1，即wed=3。

枚举是一种规范它规范了参数的形式，这样就可以不用考虑类型的不匹配并且显式的替代了int型参数可能带来的模糊概念 枚举像一个类，又像一个数组。Enum作为Sun全新引进的一个关键字，看起来很象是特殊的class, 它也可以有自己的变量，可以定义自己的方法，可以实现一个或者多个接口。 当我们在声明一个enum类型时，我们应该注意到enum类型有如下的一些特征。 1．它不能有public的构造函数，这样做可以保证客户代码没有办法新建一个enum的实例。 2．所有枚举值都是public , static , final的。注意这一点只是针对于枚举值，我们可以和在普通类里面定义 变量一样定义其它任何类型的非枚举变量，这些变量可以用任何你想用的修饰符。 3．Enum默认实现了java.lang.Comparable接口。 4．Enum覆载了了toString方法，因此我们如果调用Color.Blue.toString()默认返回字符串”Blue”. 5．Enum提供了一个valueOf方法，这个方法和toString方法是相对应的。调用valueOf(“Blue”)将返回Color.Blue.因此我们在自己重写toString方法的时候就要注意到这一点，一把来说应该相对应地重写valueOf方法。 6．Enum还提供了values方法，这个方法使你能够方便的遍历所有的枚举值。 7．Enum还有一个oridinal的方法，这个方法返回枚举值在枚举类种的顺序，这个顺序根据枚举值声明的顺序而定，这里Color.Red.ordinal()返回0。 了解了这些基本特性，我们来看看如何使用它们。 1．遍历所有有枚举值. 知道了有values方法，我们可以轻车熟路地用ForEach循环来遍历了枚举值了。 for (Color c: Color.values()) System.out.println(“find value:” + c); 2．在enum中定义方法和变量，比如我们可以为Color增加一个方法随机返回一个颜色。 public enum Color { Red, Green, Blue; private static int number = Color.values().length ; public static Color getRandomColor(){ long random = System.currentTimeMillis() % number; switch ((int) random){ case 0: return Color.Red; case 1: return Color.Green; case 2: return Color.Blue; default : return Color.Red; } } } 可以看出这在枚举类型里定义变量和方法和在普通类里面定义方法和变量没有什么区别。唯一要注意的只是变量和方法定义必须放在所有枚举值定义的后面，否则编译器会给出一个错误。 3．覆载(Override)toString, valueOf方法 前面我们已经知道enum提供了toString,valueOf等方法，很多时候我们都需要覆载默认的toString方法，那么对于enum我们怎么做呢。其实这和覆载一个普通class的toString方法没有什么区别。 …. public String toString(){ switch (this){ case Red: return "Color.Red"; case Green: return "Color.Green"; case Blue: return "Color.Blue"; default: return "Unknow Color"; } } …. 这时我们可以看到，此时再用前面的遍历代码打印出来的是 Color.Red Color.Green Color.Blue 而不是 Red Green Blue. 可以看到toString确实是被覆载了。一般来说在覆载toString的时候我们同时也应该覆载valueOf方法，以保持它们相互的一致性。 4．使用构造函数 虽然enum不可以有public的构造函数，但是我们还是可以定义private的构造函数，在enum内部使用。还是用Color这个例子。 public enum Color { Red("This is Red"), Green("This is Green"), Blue("This is Blue"); private String desc; Color(String desc){ this.desc = desc; } public String getDesc(){ return this.desc; } } 这里我们为每一个颜色提供了一个说明信息, 然后定义了一个构造函数接受这个说明信息。 要注意这里构造函数不能为public或者protected, 从而保证构造函数只能在内部使用，客户代码不能new一个枚举值的实例出来。这也是完全符合情理的，因为我们知道枚举值是public static final的常量而已。 5．实现特定的接口 我们已经知道enum可以定义变量和方法，它要实现一个接口也和普通class实现一个接口一样，这里就不作示例了。 6．定义枚举值自己的方法。 前面我们看到可以为enum定义一些方法，其实我们甚至可以为每一个枚举值定义方法。这样，我们前面覆载 toString的例子可以被改写成这样。 public enum Color { Red { public String toString(){ return "Color.Red"; } }, Green { public String toString(){ return "Color.Green"; } }, Blue{ public String toString(){ return "Color.Blue"; } }; } 从逻辑上来说这样比原先提供一个“全局“的toString方法要清晰一些。 总的来说，enum作为一个全新定义的类型，是希望能够帮助程序员写出的代码更加简单易懂在Java中，枚举类型本质上其实就是一个类，枚举中的常量都是该枚举类型的实例。虽然枚举类型有一些限制，比如不能再派生出子枚举类型，不能调用构造函数，不过我们仍然可以在枚举类型中定义构造函数、字段和方法

enum其实是用字符串来标志一些值(也就是枚举值)只是从值的大小来考虑的话，enumcolor{red,green,blue,white};类似于：#definered0#definegreen1#defineblue2#definewhite3只不过这些宏定义都是属于color这个统一的类型的(枚举型)所以想通过值来逆推出枚举的枚举元素名来。如果一定要输出的话，只能这么做了：switch((enumcolor)i){case0:printf("red ");break;case1:printf("green ");break;case2:printf("blue ");break;case3:printf("white ");break;default:break;}

枚举变量的值默认从0开始递增，当设置了某个成员的值时，后面的值在此基础上递增。所以enumt{a,b,c=3,d,e=2,f};那么a=0,b=1,c=3,d=4,e=2,f=3但是这样设是没有矛盾的，因为有些值相同了，比如c和f，所以定义enumtx=c;x==c是对的，x==f同样是对的。所以设置时要取不同值

//当然可以输出，枚举变量就是一个整数。//下面有个例子。 #include<stdio.h>int main(){ enum color { red, green, blue=6, white=10, }; enum color c=red; //0 printf("%d ",c); c=white; //10 printf("%d ",c); //1 6 printf("%d %d ",green,blue); return 0; }

11.10 枚举类型在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月，一个班每周有六门课程等等。如果把这些量说明为整型，字符型或其它类型显然是不妥当的。为此，C语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值，被说明为该“枚举”类型的变量取值不能超过定义的范围。应该说明的是，枚举类型是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何基本类型。11.10.1 枚举类型的定义和枚举变量的说明1. 枚举的定义枚举类型定义的一般形式为：enum 枚举名{ 枚举值表 };在枚举值表中应罗列出所有可用值。这些值也称为枚举元素。例如：该枚举名为weekday，枚举值共有7个，即一周中的七天。凡被说明为weekday类型变量的取值只能是七天中的某一天。2. 枚举变量的说明如同结构和联合一样，枚举变量也可用不同的方式说明，即先定义后说明，同时定义说明或直接说明。设有变量a,b,c被说明为上述的weekday，可采用下述任一种方式：enum weekday{ sun,mou,tue,wed,thu,fri,sat };enum weekday a,b,c;或者为：enum weekday{ sun,mou,tue,wed,thu,fri,sat }a,b,c;或者为：enum { sun,mou,tue,wed,thu,fri,sat }a,b,c;11.10.2 枚举类型变量的赋值和使用枚举类型在使用中有以下规定：1. 枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值：sun=5;mon=2;sun=mon;都是错误的。2. 枚举元素本身由系统定义了一个表示序号的数值，从0开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1，…,sat值为6。【例11.10】main(){enum weekday{ sun,mon,tue,wed,thu,fri,sat } a,b,c;a=sun;b=mon;c=tue;printf("%d,%d,%d",a,b,c);}说明：只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如：a=sum;b=mon;是正确的。而：a=0;b=1;是错误的。如一定要把数值赋予枚举变量，则必须用强制类型转换。如：a=(enum weekday)2;其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于：a=tue;还应该说明的是枚举元素不是字符常量也不是字符串常量，使用时不要加单、双引号。【例11.11】main(){enum body{ a,b,c,d } month[31],j;int i;j=a;for(i=1;i<=30;i++){month[i]=j;j++;if (j>d) j=a;}for(i=1;i<=30;i++){switch(month[i]){case a:printf(" %2d %c ",i,"a"); break;case b:printf(" %2d %c ",i,"b"); break;case c:printf(" %2d %c ",i,"c"); break;case d:printf(" %2d %c ",i,"d"); break;default:break;}}printf(" ");}

在实际问题中， 有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月， 一个班每周有六门课程等等。如果把这些量说明为整型， 字符型或其它类型显然是不妥当的。 为此，C语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值， 被说明为该“枚举”类型的变量取值不能超过定义的范围。应该说明的是， 枚举类型是一种基本数据类型，而不是一种构造类型， 因为它不能再分解为任何基本类型。枚举类型的定义和枚举变量的说明一、枚举的定义枚举类型定义的一般形式为：enum 枚举名{ 枚举值表 };在枚举值表中应罗列出所有可用值。这些值也称为枚举元素。例如： enum weekday{ sun,mou,tue,wed,thu,fri,sat };该枚举名为weekday，枚举值共有7个，即一周中的七天。 凡被说明为weekday类型变量的取值只能是七天中的某一天。二、枚举变量的说明 如同结构和联合一样，枚举变量也可用不同的方式说明， 即先定义后说明，同时定义说明或直接说明。设有变量a,b,c被说明为上述的weekday，可采用下述任一种方式：enum weekday{......};enum weekday a,b,c;或者为： enum weekday{......}a,b,c;或者为： enum{......}a,b,c;枚举类型变量的赋值和使用枚举类型在使用中有以下规定：1. 枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值： sun=5;mon=2;sun=mon; 都是错误的。2. 枚举元素本身由系统定义了一个表示序号的数值，从0 开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1， …,sat值为6。main(){enum weekday{ sun,mon,tue,wed,thu,fri,sat } a,b,c;a=sun;b=mon;c=tue;printf("%d,%d,%d",a,b,c);}3. 只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如： a=sum;b=mon; 是正确的。而： a=0;b=1; 是错误的。如一定要把数值赋予枚举变量，则必须用强制类型转换，如： a=(enum weekday)2;其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于： a=tue; 还应该说明的是枚举元素不是字符常量也不是字符串常量， 使用时不要加单、双引号。main(){enum body{ a,b,c,d } month[31],j;int i;j=a;for(i=1;i<=30;i++){month[i]=j;j++;if (j>d) j=a;}for(i=1;i<=30;i++){switch(month[i]){case a:printf(" %2d %c ",i,"a"); break;case b:printf(" %2d %c ",i,"b"); break;case c:printf(" %2d %c ",i,"c"); break;case d:printf(" %2d %c ",i,"d"); break;default:break;}}printf(" ");}

enum是枚举型你可以看成是数字树组union是联合体，成员共用一个变量缓冲区现在基本已经不用了。。。直接用CLASS代替掉了。。。。不在乎那点空间

枚举类型其实是整型,它的作用一是让数值看起来更直观二是圈定一个范围,是数值被限定在这个范围中.语句如下:enum color{red,orange,yello} a;a = red;if(a==0) printf("a=0");

在C语言中，枚举变量，即以enum关键字定义的变量，是按照整型或者无符号整型来处理的。1 如果在枚举变量中，不存在负值，如enum test{A,B,};这样的定义，系统会将该枚举变量按照无符号整型处理，即unsigned int 型。输出的时候使用%u格式即可。enum test t = A;printf("%u", t);2 如果在枚举变量中存在负值，那么系统按整型处理，即int型。如定义enum test{A=-199,B,};输出时，需要用%d格式：enum test t = A;printf("%d", t);3 由于枚举变量在书写时，一般不会太大，很少有在没有负数的时候，即按照无符号数处理的时候超出有符号数所能表示的正数范围，即一般不会把最高位置一，所以大多数情况下，用%d输出都是没问题的。

1.枚举 (enumeration) 值类型的一种特殊形式，它从 System.Enum 继承，并为基础基元类型的值提供备用名称。枚举类型有名称、基础类型和一组字段。基础类型必须是一个内置的有符号（或无符号）整数类型（如 Byte、Int32 或 UInt64）。字段是静态文本字段，其中的每一个字段都表示常数。所使用的语言给每个字段都分配一个基础类型的特定值。2.枚举(enum) 枚举是一个被命名的整型常数的集合, 枚举在日常生活中很常见。 例如表示星期的SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, 就是一个枚举。 枚举的说明与结构和联合相似, 其形式为: enum 枚举名{ 标识符[=整型常数], 标识符[=整型常数], ... 标识符[=整型常数], } 枚举变量; 如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始, 顺 次赋给标识符0, 1, 2, ...。但当枚举中的某个成员赋值后, 其后的成员按依次 加1的规则确定其值。 例如下列枚举说明后, x1, x2, x3, x4的值分别为0, 1, 2, 3。 enum string{x1, x2, x3, x4}x; 当定义改变成: enum string { x1, x2=0, x3=50, x4, }x; 则x1=0, x2=0, x3=50, x4=51 注意: 1. 枚举中每个成员(标识符)结束符是",", 不是";", 最后一个成员可省略 ","。 2. 初始化时可以赋负数, 以后的标识符仍依次加1。 3. 枚举变量只能取枚举说明结构中的某个标识符常量。 例如: enum string { x1=5, x2, x3, x4, }; enum strig x=x3; 此时, 枚举变量x实际上是7。 3.枚举（pascal) 随着计算机的不断普及，程序不仅只用于数值计算，还更广泛地用于处理非数值的数据。例如：性别、月份、星期几、颜色、单位名、学历、职业等，都不是数值数据。 在其它程序设计语言中，一般用一个数值来代表某一状态，这种处理方法不直观，易读性差。如果能在程序中用自然语言中有相应含义的单词来代表某一状态，则程序就很容易阅读和理解。也就是说，事先考虑到某一变量可能取的值，尽量用自然语言中含义清楚的单词来表示它的每一个值，这种方法称为枚举方法，用这种方法定义的类型称枚举类型。

那用GCC 试试， 应该可以的

enum grade set_grade(enum grade x){}

是的，变量的值可以不连续，但必须不一样，C语言是这么规定的

枚举，是一系列值，每个都相当于一个整型常量。枚举类型的变量其实就是整型变量结构体，是一组数据的集合，可以是不同类型所以二者没有什么相同的唯一相同的就是都属于自定义类型。

可以，举例：#include <QtCore/QMetaEnum>int main() {QMetaEnum metaEnum = QMetaEnum::fromType<Qt::Alignment>();//字符串转枚举值Qt::Alignment alignment = (Qt::Alignment)metaEnum.keyToValue("Qt::AlignLeft");alignment = (Qt::Alignment)metaEnum.keysToValue("Qt::AlignLeft | Qt::AlignVCenter");//枚举值转字符串const char* s = metaEnum.valueToKey(Qt::AlignCenter);return 0;}

枚举 1.枚举 (enumeration) 值类型的一种特殊形式，它从 System.Enum 继承，并为基础基元类型的值提供备用名称。枚举类型有名称、基础类型和一组字段。基础类型必须是一个内置的有符号（或无符号）整数类型（如 Byte、Int32 或 UInt64）。字段是静态文本字段，其中的每一个字段都表示常数。所使用的语言给每个字段都分配一个基础类型的特定值。 2.枚举(enum) 枚举是一个被命名的整型常数的集合, 枚举在日常生活中很常见。 例如表示星期的SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, 就是一个枚举。 枚举的说明与结构和联合相似, 其形式为: enum 枚举名{ 标识符[=整型常数], 标识符[=整型常数], ... 标识符[=整型常数], } 枚举变量; 如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始, 顺 次赋给标识符0, 1, 2, ...。但当枚举中的某个成员赋值后, 其后的成员按依次 加1的规则确定其值。 例如下列枚举说明后, x1, x2, x3, x4的值分别为0, 1, 2, 3。 enum string{x1, x2, x3, x4}x; 当定义改变成: enum string { x1, x2=0, x3=50, x4, }x; 则x1=0, x2=0, x3=50, x4=51 注意: 1. 枚举中每个成员(标识符)结束符是",", 不是";", 最后一个成员可省略 ","。 2. 初始化时可以赋负数, 以后的标识符仍依次加1。 3. 枚举变量只能取枚举说明结构中的某个标识符常量。 例如: enum string { x1=5, x2, x3, x4, }; enum strig x=x3; 此时, 枚举变量x实际上是7。 3.枚举（pascal) 随着计算机的不断普及，程序不仅只用于数值计算，还更广泛地用于处理非数值的数据。例如：性别、月份、星期几、颜色、单位名、学历、职业等，都不是数值数据。 在其它程序设计语言中，一般用一个数值来代表某一状态，这种处理方法不直观，易读性差。如果能在程序中用自然语言中有相应含义的单词来代表某一状态，则程序就很容易阅读和理解。也就是说，事先考虑到某一变量可能取的值，尽量用自然语言中含义清楚的单词来表示它的每一个值，这种方法称为枚举方法，用这种方法定义的类型称枚举类型。

枚举(enum)枚举在C/C++/c#中，是一个被命名的整型常数的集合, 枚举在日常生活中很常见。例如表示星期的SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,SATURDAY, 就是一个枚举。枚举的说明与结构和联合相似, 其形式为:enum 枚举名{标识符[=整型常数],标识符[=整型常数],...标识符[=整型常数]} 枚举变量;如果枚举没有初始化, 即省掉=整型常数时, 则从第一个标识符开始, 顺次赋给标识符0, 1, 2, ...。但当枚举中的某个成员赋值后, 其后的成员按依次加1的规则确定其值。例如下列枚举说明后, x1, x2, x3, x4的值分别为0, 1, 2, 3。enum Num{x1, x2, x3, x4}x;当定义改变成:enum Num{x1,x2=0,x3=50,x4}x;则x1=0, x2=0, x3=50, x4=51注意:1. 枚举中每个成员(标识符)结束符是,, 不是;, 最后一个成员可省略,。2. 初始化时可以赋负数, 以后的标识符仍依次加1。3. 枚举变量只能取枚举说明结构中的某个标识符常量。例如:enum Num{x1=5,x2,x3,x4};enum Num x=x3;此时, 枚举变量x实际上是7。枚举类型变量的赋值和使用枚举类型在使用中有以下规定：1.枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值： sun=5;mon=2;sun=mon; 都是错误的。2. 枚举元素本身由系统定义了一个表示序号的数值，从0 开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1， …,sat值为6。main(){enum weekday{ sun,mon,tue,wed,thu,fri,sat } a,b,c;a=sun;b=mon;c=tue;printf(%d,%d,%d,a,b,c);}3. 只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如： a=sun;b=mon; 是正确的。而： a=0;b=1; 是错误的。如一定要把数值赋予枚举变量，则必须用强制类型转换，如： a=(enum weekday)2;其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于： a=tue; 还应该说明的是枚举元素不是字符常量也不是字符串常量， 使用时不要加单、双引号。main(){enum body{ a,b,c,d };int month[31];int j=a;int i;for(i=1;i<=30;i++){month[i]=j;j++;if (j>d) j=a;}for(i=1;i<=30;i++){switch(month[i]){case a:printf( %2d %c ,i,"a"); break;case b:printf( %2d %c ,i,"b"); break;case c:printf( %2d %c ,i,"c"); break;case d:printf( %2d %c ,i,"d"); break;default:break;}}printf( );}10个数字,任意取出不相等的5个数字,谁还记得这个算法的公式????????用javascript有什么好的计算方法??m　n*(n-1)*(n-2)*...*(n-m+1)　n!C　= ---------------------------------------------　=　--------------------------n　m*(m-1)*(m-2)*...*3*2*1　m!*(n-m)!这个是公式,但是对枚举作用不大,还是要遍历循环才行.这就需要一个好的算法