精华内容
下载资源
问答
  • C/C++enum枚举类型及赋值范围

    万次阅读 2018-05-10 15:05:19
    让weekday成为新类型的名称,2.让sun、mod、tue等作为符号常量,它们对应整数值0~6.这些常量叫做枚举量。 也可以自定义枚举量的值,指定的值为整数。没指定的自动根据前一个加1,第一个默认是0....

            C++的enum工具提供了一种创建符号常量的方式,这种方式可以代替const

            1.创建enum枚举

            

            这语句完成工作:1.让weekday成为新类型的名称,2.让sun、mod、tue等作为符号常量,它们对应整数值0~6.这些常量叫做枚举量。

            也可以自定义枚举量的值,指定的值为整数。没指定的自动根据前一个加1,第一个默认是0.可重复指定(比如两个1)。

            

            2.声明此类枚举类型变量

            

            也可在定义枚举量时同时定义枚举变量,如:

            这种类型的变量特性:不进行强制类型转换的情况下,只能将定义枚举时使用的枚举量赋给这种枚举的变量。

            如:today = sun;//正确

                   today = 0; //错误

                    VS里会自动报错:

                   而枚举量是整型,可以直接被提升为int型给其他值赋值。如:此时yesterday值为1。

            但可通过强制类型转换,将int值赋给枚举变量:此时today打印出来为4.但强制类型转换的数字要在枚举的取值范围内。

            总结:声明的枚举类型变量,可由枚举类型符号常量直接赋值,但不可以由int类型直接赋值,int类型要想赋值给枚举类型变量,满足两个条件:int数字要在枚举的取值范围内,要加上强制类型转换。  


    关于将int值赋值给枚举变量取值范围,从C++PrimerPlus截出:


            

    展开全文
  • 枚举类型

    2016-09-29 13:54:32
    枚举类型(也称为枚举)为定义一组可以赋给变量的命名整数常量提供了一种有效的方法。 例如,假设您必须定义一个变量,该变量的值表示一周中的一天。 该变量只能存储七个有意义的值。 若要定义这些值,可以使用...

    枚举类型(也称为枚举)为定义一组可以赋给变量的命名整数常量提供了一种有效的方法。 例如,假设您必须定义一个变量,该变量的值表示一周中的一天。 该变量只能存储七个有意义的值。 若要定义这些值,可以使用枚举类型。枚举类型是使用 enum关键字声明的。

    C#
    enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
    enum Months : byte { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec }; 
    

    默认情况下,枚举中每个元素的基础类型是 int 可以使用冒号指定另一种整数值类型,如前面的示例所示。 有关可能的类型的完整列表,请参见 enum(C# 参考)

    可以通过转换验证基础数值与基础类型,如下例所示。

    C#
    Days today = Days.Monday;
    int dayNumber =(int)today;
    Console.WriteLine("{0} is day number #{1}.", today, dayNumber);
    
    Months thisMonth = Months.Dec;
    byte monthNumber = (byte)thisMonth;
    Console.WriteLine("{0} is month number #{1}.", thisMonth, monthNumber);
    
    // Output:
    // Monday is day number #1.
    // Dec is month number #11.
    

    以下是使用枚举而不使用数值类型的好处:

    • 明确为客户端代码指定哪些值是变量的有效值。

    • 在 Visual Studio 中,IntelliSense 列出定义的值。

    如果未在枚举数列表中指定元素的值,则值将自动按 1 递增。 在前面的示例中,Days.Sunday 的值为 0,Days.Monday 的值为 1,依此类推。 创建新的 Days 对象时,如果不显式为其赋值,则它将具有默认值 Days.Sunday (0)。 创建枚举时,应选择最合理的默认值并赋给它一个零值。 这便使得只要在创建枚举时未为其显式赋值,则所创建的全部枚举都将具有该默认值。

    如果变量 meetingDay 的类型为 Days,则只能将 Days 定义的某个值赋给它(无需显式强制转换)。 如果会议日期更改,可以将Days 中的新值赋给 meetingDay

    C#
    Days meetingDay = Days.Monday;
    //...
    meetingDay = Days.Friday;
    
    System_CAPS_note注意

    可以将任意整数值赋给 meetingDay 例如,代码行 meetingDay = (Days) 42 不会产生错误。 但也不应该这样做,因为默认约定的是枚举变量只容纳枚举定义的值之一。 将任意值赋给枚举类型的变量很有可能会导致错误。

    可以将任意值赋给枚举类型的枚举数列表中的元素,也可以使用计算值:

    C#
    enum MachineState
    {
        PowerOff = 0,
        Running = 5,
        Sleeping = 10,
        Hibernating = Sleeping + 5
    }
    

    可以使用枚举类型定义位标志,从而使该枚举类型的实例可以存储枚举数列表中定义的值的任意组合。 (当然,某些组合在您的程序代码中可能没有意义或不允许使用。)

    创建位标志枚举的方法是应用 System.FlagsAttribute 特性并适当定义一些值,以便可以对这些值执行 ANDORNOT 和 XOR按位运算。 在位标志枚举中包含一个值为零(表示“未设置任何标志”)的命名常量。如果零值不表示“未设置任何标志”,则请不要为标志指定零值。

    在下面的示例中,定义了 Days 枚举的另一个版本,命名为 Days2 Days2 具有 Flags 特性,且它的每个值都是 2 的若干次幂,指数依次递增。 这样,您将能够创建值为 Days2.Tuesday 和 Days2.Thursday 的 Days2 变量。

    C#
    [Flags]
    enum Days2
    {
        None = 0x0,
        Sunday = 0x1,
        Monday = 0x2,
        Tuesday = 0x4,
        Wednesday = 0x8,
        Thursday = 0x10,
        Friday = 0x20,
        Saturday = 0x40
    }
    class MyClass
    {
        Days2 meetingDays = Days2.Tuesday | Days2.Thursday;
    }
    

    若要在某个枚举上设置标志,请使用按位 OR 运算符,如下面的示例所示:

    C#
    // Initialize with two flags using bitwise OR.
    meetingDays = Days2.Tuesday | Days2.Thursday;
    
    // Set an additional flag using bitwise OR.
    meetingDays = meetingDays | Days2.Friday;
    
    Console.WriteLine("Meeting days are {0}", meetingDays);
    // Output: Meeting days are Tuesday, Thursday, Friday
    
    // Remove a flag using bitwise XOR.
    meetingDays = meetingDays ^ Days2.Tuesday;
    Console.WriteLine("Meeting days are {0}", meetingDays);
    // Output: Meeting days are Thursday, Friday
    

    若要确定是否设置了特定标志,请使用按位 AND 运算,如下面的示例所示:

    C#
    // Test value of flags using bitwise AND.
    bool test = (meetingDays & Days2.Thursday) == Days2.Thursday;
    Console.WriteLine("Thursday {0} a meeting day.", test == true ? "is" : "is not");
    // Output: Thursday is a meeting day.
    

    有关使用 System.FlagsAttribute 特性定义枚举类型时需要考虑的事项的更多信息,请参见 System.Enum

    所有枚举都是 System.Enum 类型的实例。 不能从 System.Enum 派生新类,但可以使用它的方法发现有关枚举实例中的值的信息以及操作这些值。

    C#
    string s = Enum.GetName(typeof(Days), 4);
    Console.WriteLine(s);
    
    Console.WriteLine("The values of the Days Enum are:");
    foreach (int i in Enum.GetValues(typeof(Days)))
        Console.WriteLine(i);
    
    Console.WriteLine("The names of the Days Enum are:");
    foreach (string str in Enum.GetNames(typeof(Days)))
        Console.WriteLine(str);
    

    有关更多信息,请参见AllMembers.T:System.Enum

    此外,还可以使用扩展方法为枚举创建新方法。 有关更多信息,请参见如何:为枚举创建新方法(C# 编程指南)

    展开全文
  • C语言enum枚举类型解析

    万次阅读 2017-02-14 11:27:20
    在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,...定义一个变量是枚举类型,可以先定义一个枚举类型名,然后再说明这个变量是该枚举类型。 例如:  enum weekday{sun,mon,tue,wed,thu,fri,s
    在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,星期只有七种可能取值。在 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。 
    C 语言教程 ?216? 
    ④ 一个整数不能直接赋给一个枚举变量,必须强制进行类型转换才能赋值。例如: 
    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
    }
    展开全文
  • 枚举类型简单理解

    2019-07-23 16:08:16
     枚举类型声明为一组相关的符号常数定义了一个类型名称。枚举用于“多项选择”场合,就是程序运行时从编译时已经设定的固定数目的“选择”中做出决定。  枚举类型(也称为枚举)为定义一组可以赋给变量的命名整数...

    枚举

      枚举类型声明为一组相关的符号常数定义了一个类型名称。枚举用于“多项选择”场合,就是程序运行时从编译时已经设定的固定数目的“选择”中做出决定。

      枚举类型(也称为枚举)为定义一组可以赋给变量的命名整数常量提供了一种有效的方法。例如,假设您必须定义一个变量,该变量的值表示一周中的一天。该变量只能存储七个有意义的值。若要定义这些值,可以使用枚举类型。枚举类型是使用 enum 关键字声明的。 

     enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }; 

     默认情况下,枚举中每个元素的基础类型是 int。可以使用冒号指定另一种整数值类型。
      如果不为枚举数列表中的元素指定值,则它们的值将以 1 为增量自动递增。在前面的示例中,Days.Sunday 的值为 0,Days.Monday 的值为 1,依此类推。创建新的 Days 对象时,如果不显式为其赋值,则它将具有默认值 Days.Sunday (0)。创建枚举时,应选择最合理的默认值并赋给它一个零值。这便使得只要在创建枚举时未为其显式赋值,则所创建的全部枚举都将具有该默认值。枚举中大小写敏感,但是建议不要这样。

      注意:System.Enum 类型是所有枚举类型的抽象基类(它是一种与枚举类型的基础类型不同的独特类型),并且从 System.Enum 继承的成员在任何枚举类型中都可用。存在从任何枚举类型到System.Enum 的装箱转换,并且存在从 System.Enum 到任何枚举类型的取消装箱转换。System.Enum 本身不是枚举类型。相反,它是一个类类型,所有枚举类型都是从它派生的。类型 System.Enum 从类型 System.ValueType派生,而后者又从类型 object 派生。在运行时,类型 System.Enum 的值可以是 null 或是对任何枚举类型的装了箱的值的引用。

    枚举的优点:
    1、枚举可以使代码更易于维护,有助于确保给变量指定合法的、期望的值。
    2、枚举使代码更清晰,允许用描述性的名称表示整数值,而不是用含义模糊的数来表示。
    3、枚举使代码更易于键入。在给枚举类型的实例赋值时,VS.NET IDE会通过IntelliSense弹出一个包含可接受值的列表框,减少了按键次数,并能够让我们回忆起可能的值

    如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。

    例如,下面的代码定义了一个颜色枚举,变量 c 的类型为 color。最后,c 被赋值为 "blue"。

    enum color { red, green, blue } c;
    c = blue;

    默认情况下,第一个名称的值为 0,第二个名称的值为 1,第三个名称的值为 2,以此类推。但是,您也可以给名称赋予一个特殊的值,只需要添加一个初始值即可。例如,在下面的枚举中,green 的值为 5。

    enum color { red, green=5, blue };

    在这里,blue 的值为 6,因为默认情况下,每个名称都会比它前面一个名称大 1,但 red 的值依然为 0。

     

     

    enum weekday{mon=1,tue,wed,thu,fri,sat,sun};

    其实就是类似数组,但是比数组功能更全一些,一一对应。

    上面的代码就是定义了一个枚举类型的变量。enum 是枚举类型的关键字。枚举是一个很有意思的东西,weekday是一个变量,而且取值范围就是{}内的值,{}内的值是常量表示weekday的可能去到的值,称作枚举元素。枚举元素默认是从零开始,逐个递增的,上面代码中,我给初始设置了mon=1,这样就不是从零开始了,而是从1开始向后递增。
    枚举类型的使用意义是方便程序员记忆,也就是说在我们的开发过程中,我们定义了很多的常量,比如1、2、3、4、5、6、7分别代表一周的7天。这样看着很方便啊,很好。但是,开发没有一天两天就能完事的,比如一个项目开发周期是3个月,谁能保证不会忘记数字对应的天?当然有人会说不可能,1-7对应1-7,怎么会忘记。那么我们换一个例子,在开发中,我用1表示红色,2表示蓝色,3表示黄色,那么3个月后保证还能记得清楚?这个时候枚举的好处就出来了。我不用去记对应关系,只要提前写一个枚举类型的变量然后我们就可以在以后的开发中使用red,blue,yellow,这样的单词带取值,这样没几个人会忘记吧。那么我们就来写一个这样的枚举:

    enum color{red=1,blue,yellow};

    但是枚举类型也不要滥用,因为它是一个单独的数据类型,因此不能像数组那样操作,而且要经常用到数据转换,操作起来不方便。所以在实际开发中比较少用。

    虽然枚举有着这个缺点,但是它对于代码的记忆和可读性的帮助还是很大的。所以何时使用,怎么使用还需要程序员自己去理解。

    而对于枚举类型的使用也很简单:


    int main(int argc, const char * argv[]) {

        enum color{red=1,blue,yellow};

        int k;

        scanf("%d", &k);

        int col = (enum color)k;

        switch (col) {

            case red:

                printf("红色\n");

                break;

                

            case blue:

                printf("蓝色\n");

                break;

                

            case yellow:

                printf("黄色\n");

                break;

                

            default:

                break;

        }

        return 0;

    }

    展开全文
  • enum枚举类型用法浅析

    2021-03-27 11:24:40
    枚举类型定义用关键字enum标识,形式为: enum 标识符 { 枚举数据表 }; (1)、enum是关键字,标识枚举类型。定义枚举类型必须用enum开头。 (2)、枚举数据表中的名字是程序员自己设定,这些名字只是一个符号。但...
  • 枚举类型enum

    2013-08-14 19:37:45
    C语言的枚举类型实质就是整型变量,只不过通过枚举类型将一类有关联的标识组合起来,增加程序的可读性和可维护性 (1) 枚举型是一个集合,集合中的元素(枚举成员)是一些命名的整型常量,元素之间用逗号,隔开。 (2) ...
  • C语言枚举类型

    2017-09-18 20:21:47
    宏和枚举都可以将变量换一个别名对比: { 宏 枚举 差别 作用时期 存储形式 宏 预处理阶段 替换,程序运行 不存在 枚举 程序运行 后 起作用,枚举常量 存储 数据段 静态存储区里。 宏 占 代码段 空间,枚举 ...
  • 枚举类型与结构体的区别

    千次阅读 2019-08-05 21:47:43
    一、枚举类型: 1.1、定义: 是指将变量的值一 一列出来,变量的值只限于列举出来的值的范围内; 1.2、使用格式: 举例说明: enumDAY { MON=1, TUE, WED, THU, FRI,...
  • 结构体类型与枚举类型

    千次阅读 2013-08-08 10:01:58
    枚举类型 枚举类型(也称为枚举)为定义一组可以赋给变量的命名整数常量提供了一种有效的方法。 例如,假设您必须定义一个变量,该变量的值表示一周中的一天。 该变量只能存储七个有意义的值。  若要定义这些...
  • Java枚举类型的用法

    2014-10-30 10:18:14
    1. 在J2SE5.0中要定义枚举类型是使用enum关键词,枚举类型主要提供一些常数。如下列代码定义了Action枚举类型
  • C语言的枚举类型

    2015-10-22 14:50:28
    在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,...定义一个变量是枚举类型,可以先定义一个枚举类型名,然后再说明这个变量是该枚举类型。 例如:  enum weekday{sun,mon,tue,wed,thu,fri
  • 主要介绍了C++枚举类型enum与enum class的使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • C语言枚举类型enum-总结
  • C语言枚举类型enum

    2013-08-10 11:56:10
    在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,...定义一个变量是枚举类型,可以先定义一个枚举类型名,然后再说明这个变量是该枚举类型。 例如: enum weekday{sun,mon,tue,wed,thu,fri,s
  • C/C++ enum class枚举类型

    万次阅读 2017-11-10 15:40:33
    声明枚举类型的方式有2种: 1. 常见的enum方式 enum A { a0 = 0, a1 = 1 }; enum B { b0 = 0, b1 = 1 }; 2. enum class 方式 enum class CC { cc0 = 0, cc1 = 1 }; enum和enum class的区别如下: ...
  • 枚举类型是什么

    万次阅读 多人点赞 2018-06-13 21:41:38
    C语言详解 - 枚举类型注:以下全部代码的执行环境为VC++ 6.0在程序中,可能需要为某些整数定义一个别名,我们可以利用预处理指令#define来完成这项工作,您的代码可能是:#define MON 1#define TUE 2#define ...
  • c枚举类型

    千次阅读 2018-09-12 10:52:29
    (4) 可以人为设定枚举成员的值,从而自定义某个范围内的整数。 (5) 枚举型是预处理指令#define的替代。 (6) 类型定义以分号 ; 结束。   2. 使用枚举类型对变量进行声明 新的数据类型定义完成后,它...
  • C语言枚举类型举例

    千次阅读 2013-07-27 17:29:34
    C语言枚举类型举例 注:以下全部代码的执行环境为VC++ 6.0 宏和枚举的区别 宏和枚举之间的差别主要在作用的时期和存储的形式不同,宏是在预处理的阶段进行替换工作的,它替换代码段的文本,程序运行的过程...
  • c语言枚举类型

    2017-09-11 16:02:06
    定义一个变量是枚举类型,可以先定义一个枚举类型名,然后再说明这个变量是该枚举类型。 例如:  enum weekday{sun,mon,tue,wed,thu,fri,sat};  定义了一个枚举类型名 enum weekday,然后定义变量为该枚举...
  • 每个枚举成员的常数值必须在该枚举的基础类型范围之内。示例 enum Color: uint { Red = -1, Green = -2, Blue = -3 } 产生编译时错误,原因是常数值 -1、-2 和 –3 不在基础整型 uint 的范围内。 2、...
  • C语言详解 - 枚举类型

    千次阅读 2014-03-27 13:06:08
    C语言详解 - 枚举类型 原文链接:LINK 注:以下全部代码的执行环境为VC++ 6.0 在程序中,可能需要为某些整数定义一个别名,我们可以利用预处理指令#define来完成这项工作,您的代码可能是: #define ...
  • C语言之enum的用法和注意事项(枚举类型

    千次阅读 多人点赞 2020-06-14 23:22:13
    在C语言中有一个关键字是enum,枚举类型,不知道大家平时用吗,但是enum关键字在有些时候是非常方面的。下面说一下使用enum关键字的几种情况。 定义 枚举类型定义用关键字enum标识,形式为: enum 标识符 { 枚举...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,435
精华内容 10,974
关键字:

枚举类型未设定范围