精华内容
下载资源
问答
  • 在实际编程中,有些数据的取值往往是有限的,只能是非常少量的整数,并且最好为每个值都取一个名字,以方便在后续代码中使用,比如一个星期只有七天,一年只有十二个月,一个班每周有六门课程等。以每周七天为例,...

    在实际编程中,有些数据的取值往往是有限的,只能是非常少量的整数,并且最好为每个值都取一个名字,以方便在后续代码中使用,比如一个星期只有七天,一年只有十二个月,一个班每周有六门课程等。

    以每周七天为例,我们可以使用#define命令来给每天指定一个名字:

    #include

    #define Mon 1

    #define Tues 2

    #define Wed 3

    #define Thurs 4

    #define Fri 5

    #define Sat 6

    #define Sun 7

    int main(){

    int day;

    scanf("%d", &day);

    switch(day){

    case Mon: puts("Monday"); break;

    case Tues: puts("Tuesday"); break;

    case Wed: puts("Wednesday"); break;

    case Thurs: puts("Thursday"); break;

    case Fri: puts("Friday"); break;

    case Sat: puts("Saturday"); break;

    case Sun: puts("Sunday"); break;

    default: puts("Error!");

    }

    return 0;

    }

    运行结果:

    5↙

    Friday

    #define命令虽然能解决问题,但也带来了不小的副作用,导致宏名过多,代码松散,看起来总有点不舒服。C语言提供了一种枚举(Enum)类型,能够列出所有可能的取值,并给它们取一个名字。

    枚举类型的定义形式为:

    enum typeName{ valueName1, valueName2, valueName3, ...... };

    enum是一个新的关键字,专门用来定义枚举类型,这也是它在C语言中的唯一用途;typeName是枚举类型的名字;valueName1, valueName2, valueName3, ......是每个值对应的名字的列表。注意最后的;不能少。

    例如,列出一个星期有几天:

    enum week{ Mon, Tues, Wed, Thurs, Fri, Sat, Sun };

    可以看到,我们仅仅给出了名字,却没有给出名字对应的值,这是因为枚举值默认从 0 开始,往后逐个加 1(递增);也就是说,week 中的 Mon、Tues ...... Sun 对应的值分别为 0、1 ...... 6。

    我们也可以给每个名字都指定一个值:

    enum week{ Mon = 1, Tues = 2, Wed = 3, Thurs = 4, Fri = 5, Sat = 6, Sun = 7 };

    更为简单的方法是只给第一个名字指定值:

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };

    这样枚举值就从 1 开始递增,跟上面的写法是等效的。

    枚举是一种类型,通过它可以定义枚举变量:

    enum week a, b, c;

    也可以在定义枚举类型的同时定义变量:

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } a, b, c;

    有了枚举变量,就可以把列表中的值赋给它:

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };

    enum week a = Mon, b = Wed, c = Sat;

    或者:

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } a = Mon, b = Wed, c = Sat;

    【示例】判断用户输入的是星期几。

    #include

    int main(){

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } day;

    scanf("%d", &day);

    switch(day){

    case Mon: puts("Monday"); break;

    case Tues: puts("Tuesday"); break;

    case Wed: puts("Wednesday"); break;

    case Thurs: puts("Thursday"); break;

    case Fri: puts("Friday"); break;

    case Sat: puts("Saturday"); break;

    case Sun: puts("Sunday"); break;

    default: puts("Error!");

    }

    return 0;

    }

    运行结果:

    4↙

    Thursday

    需要注意的两点是:

    1) 枚举列表中的 Mon、Tues、Wed 这些标识符的作用范围是全局的(严格来说是 main() 函数内部),不能再定义与它们名字相同的变量。

    2) Mon、Tues、Wed 等都是常量,不能对它们赋值,只能将它们的值赋给其他的变量。

    枚举和宏其实非常类似:宏在预处理阶段将名字替换成对应的值,枚举在编译阶段将名字替换成对应的值。我们可以将枚举理解为编译阶段的宏。

    对于上面的代码,在编译的某个时刻会变成类似下面的样子:

    #include

    int main(){

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } day;

    scanf("%d", &day);

    switch(day){

    case 1: puts("Monday"); break;

    case 2: puts("Tuesday"); break;

    case 3: puts("Wednesday"); break;

    case 4: puts("Thursday"); break;

    case 5: puts("Friday"); break;

    case 6: puts("Saturday"); break;

    case 7: puts("Sunday"); break;

    default: puts("Error!");

    }

    return 0;

    }

    Mon、Tues、Wed 这些名字都被替换成了对应的数字。这意味着,Mon、Tues、Wed 等都不是变量,它们不占用数据区(常量区、全局数据区、栈区和堆区)的内存,而是直接被编译到命令里面,放到代码区,所以不能用&取得它们的地址。这就是枚举的本质。

    关于程序在内存中的分区以及各个分区的作用,我们将在《C语言内存》专题中的《Linux下C语言程序的内存布局(内存模型)》一节中详细讲解。

    我们在《C语言switch语句》一节中讲过,case 关键字后面必须是一个整数,或者是结果为整数的表达式,但不能包含任何变量,正是由于 Mon、Tues、Wed 这些名字最终会被替换成一个整数,所以它们才能放在 case 后面。

    枚举类型变量需要存放的是一个整数,我猜测它的长度和 int 应该相同,下面来验证一下:

    #include

    int main(){

    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } day = Mon;

    printf("%d, %d, %d, %d, %d\n", sizeof(enum week), sizeof(day), sizeof(Mon), sizeof(Wed), sizeof(int) );

    return 0;

    }

    运行结果:

    4, 4, 4, 4, 4

    枚举类型enum详解——C语言

    enum enum是C语言中的一个关键字,enum叫枚举数据类型,枚举数据类型描述的是一组整型值的集合(这句话其实不太妥当),枚举型是预处理指令#define的替代,枚举和宏其实非常类似,宏在预处理阶 ...

    [编程] C语言枚举类型(Enum)

    C语言枚举类型(Enum):定义形式为:enum typeName{ valueName1, valueName2, valueName3, ...... };enum 类型名{名字1,名字2} 枚举 ...

    【转】java枚举类型enum的使用

    原文网址:http://blog.csdn.net/wgw335363240/article/details/6359614 java 枚举类型enum 的使用 最近跟同事讨论问题的时候,突然同事提到 ...

    C# 中的枚举类型 enum (属于值类型)

    原文 C# 中的枚举类型 enum (属于值类型) C# 支持两种特殊的值类型:枚举和结构. 声明枚举:声明时要声明所有可能的值. using System; using System.Collect ...

    深入理解Java枚举类型(enum)

    https://blog.csdn.net/javazejian/article/details/71333103 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(en ...

    人生苦短之Python枚举类型enum

    枚举类型enum是比较重要的一个数据类型,它是一种数据类型而不是数据结构,我们通常将一组常用的常数声明成枚举类型方便后续的使用.当一个变量有几种可能的取值的时候,我们将它定义为枚举类型.在Python ...

    全面解读Java中的枚举类型enum的使用

    这篇文章主要介绍了Java中的枚举类型enum的使用,开始之前先讲解了枚举的用处,然后还举了枚举在操作数据库时的实例,需要的朋友可以参考下 关于枚举 大多数地方写的枚举都是给一个枚举然后例子就开始sw ...

    Java基础之枚举类型Enum的使用

    Java基础之枚举类型Enum的使用 定义 public enum AccruedCleanEnum { SPREAD("1","发票"),OTHER(&quo ...

    《挑战30天C++入门极限》新手入门:C/C++中枚举类型(enum)

    新手入门:C/C++中枚举类型(enum) 如果一个变量你需要几种可能存在的值,那么就可以被定义成为枚举类型.之所以叫枚举就是说将变量或者叫对象可能存在的情况也可以说是可能的值一一例举出来. ...

    随机推荐

    Control Flow 如何处理 Error

    在Package的执行过程中,如果在Data Flow中出现Error,那么Data Flow component能够将错误行输出,只需要在组件的ErrorOutput中进行简单地配置,参考

    SpringMVC 配置log4j

    log4j.properties相关 http://www.cnblogs.com/ITEagle/archive/2010/04/23/1718365.html http://www.cnblogs ...

    html部分---表单、iframe、frameset及其他字符的用法(以及name、id、value的作用与区别);

    /action的作用是提交到..,methed是提交方法,用po ...

    Windows添加在此处打开命令CMD

    打开rededit在:HKEY_CLASS_ROOT > * > shell >下面新建一个项CMD 在CMD中新建两个字符串 一个是默认,值为 @shell32.dll,- 另外一 ...

    Android笔记——Bitmap自动取色(纯搬运)

    2015/6/12更新:发现一个更好的,带demo https://github.com/MichaelEvans/ColorArt 说明: 这个是一个老外写的自动自动从bitmap中取主色与第二主色 ...

    jQuery的extend详解

    JQuery的extend扩展方法:      Jquery的扩展方法extend是我们在写插件的过程中常用的方法,该方法有一些重载原型,在此,我们一起去了解了解.      一.Jquery的扩展方 ...

    jdk7u79linuxx64.tar.gz下载

    jdk1.7下载: 百度云盘链接:https://pan.baidu.com/s/1cQFLnS 密码:wdek

    [转]Cloudera Manager和CDH5.8离线安装

    https://blog.csdn.net/zzq900503/article/details/52982828 https://www.cnblogs.com/felixzh/p/9082344.h ...

    软件工程(FZU2015) 学生博客列表(最终版)

    FZU:福州大学软件工程 张老师的博客:http://www.cnblogs.com/easteast/ 经过前两周选课,最后正式选上课程的所有学生博客如下: 序号 学号后3位 博客 1 629 li ...

    IntelliJ Idea 使用笔记

    1. IntelliJ Idea解决Could not autowire. No beans of 'xxxx' type found的错误提示. 原因可能有两个,第一个是IntellijIDEA本身 ...

    展开全文
  • 让我惊奇的是市面上的一些C语言书籍以及视频课程并没有重视去讲enum。 今天我们还是从理论到实际产品应用,教大家真正掌握enum。 通过这篇内容你能掌握以下知识: 掌握枚举的相关概念 掌握枚举的几种用法 掌握...

    大家好,我是无际。

    今天跟大家讲一下我在产品开发时,用枚举(enum)的一些骚操作。

    我跟你保证,今天的内容绝对是你在书本和视频学不到的。

    为什么要讲枚举呢?

    因为我发现它是一个容易被遗忘,同时又非常重要的关键词,大家如果看那些大佬写的程序,真的会发现有非常非常多enum的应用。

    让我惊奇的是市面上的一些C语言书籍以及视频课程并没有重视去讲enum。

    今天我们还是从理论到实际产品应用,教大家真正掌握enum。

    通过这篇内容你能掌握以下知识:

    1. 掌握枚举的相关概念
    2. 掌握枚举的几种用法
    3. 掌握枚举在实际产品中的应用

    这篇内容是无际单片机编程那个程序架构视频教程的讲课稿,我稍微做了些调整,如果想看视频的也可以找我们拿。

    一、枚举的概念

    我对枚举的理解是把一些固定的值一一列举出来分别起个名字,比如说给1取个名字叫Ture, 0取个名字叫False。

    Ture和false都是一种表示同一个类型的数据,比如说都是代表逻辑的对错。

    我们模拟51单片机的IE中断使能寄存器每个位的值来举一个例子。

    我们可以对照单片机寄存器芯片资料一下,当我们设置IE寄存器的值等于0x01的时候,代表开启外部中断0,设置成0x80的时候允许全部中断。

    这些枚举值都是针对寄存器IE的固定值,所以我们可以称这些值是同一个类型的数据,我们把他们重新命名一下,便于阅读和记忆,这就是枚举的重要作用之一。

    二、枚举的几种用法

    1.直接定义枚举值,然后给普通变量赋值。

    上面这个代码呢,定义了一个枚举类型,但是没有给枚举类型命名。

    像这种枚举呢就是没办法定义枚举变量的,但是呢,这样其实也是可以用的。

    我们通过定义一个普通变量,然后把枚举的值赋给他,一样也能输出正确的值,这种方法我个人经常偷懒地用。

    2.定义带名称的枚举

    这里定义了一个名字为WeekDay的枚举,那么我们就可以通过这个枚举类型定义一个名为day的枚举变量。

    三、定义枚举别名

    这个代码中通过typedef来定义枚举的别名为WeekDay,然后我们直接使用WeekDay day来定义一个enum变量,这种方法用的是最多的

    四、枚举有什么用,用在哪里?

    上面我们已经学习了枚举的一些定义方法,那么枚举到底在产品当中有什么用呢?

    枚举的作用:

    1.为固定的值命名,当作数组访问的下标,当固定的数据很多时,比如有几十上百个,那么如果你应0-100去表示就很难记住每个值代表什么意思。

    比如说之前做过汽车故障诊断的产品,需要读取Pid数据存储到数组里,而PID有将近100个。

    如果让你去记这100个每个代表哪个PID参数,估计你会崩溃。

    而我把每个PID参数通过枚举另起一个一看就知道是什么参数的名字,是不是就方便很多?

    因为每个PID都单独存储在数组的一个元素里,那我用这个名字作为下标能很快速地把指定PID参数从数组取出来。

    看上图用枚举和不用枚举读取的区别相信你就能理解了。

    2.可以作为一个变量,灵活分配数组大小。

    我们在定义数组的时候,直接用该枚举类型的最后一个值作为数组大小。

    下次要增加或者减少PID参数的时候就不用去改数组大小了,非常方便。

    3.枚举作为设置值

    上图是STM32的固件库代码,配置GPIO模式的枚举定义。

    我们可以看到,每一个枚举值都代表着一个模式,最后通过把这些值写入相应寄存器,最终完成GPIO的模式配置。

    这里就先说这么多,更多实战应用可以跟随无际单片机编程做项目去学习和提高。

    最后总结:

    不知道大家有没有发现,其实枚举配合结构体,C语言照样也能做面向对象的编程。

    面向对象是什么意思?就是一切皆对象,单片机GPIO是一个对象,定时器是一个对象,串口又是一个对象等等。

    每个对象都有自己独有的属性,比如说GPIO有输入和输出的模式,有输出的频率,有输出的引脚号,这些都是属于GPIO的属性。

    那我们可以通过枚举和结构体把这些属性封装起来,当做一个对象来处理。

    如果大家理解比较困难也没关系,这都是正常的。

    当你代码写到一定量的时候,慢慢就理解了。

    展开全文
  • C语言枚举类型enum-总结

    注:以下全部代码的执行环境为VC++ 6.0或者Dev-C++ 5.10

    在程序中,可能需要为某些整数定义一个别名,我们可以利用预处理指令#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
    }
    



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

    2020-08-20 06:01:11
    枚举常量是枚举类型中的值,即枚举值。枚举类型是一种用户定义的类型,只有用户在程序中定义它后才能被使用
  • C语言枚举类型enum

    2013-08-10 11:56:10
    在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,...定义一个变量是枚举类型,可以先定义一个枚举类型名,然后再说明这个变量是该枚举类型。 例如: 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的值为 0mon 的值为 1…sat 的值为 6,如果有赋值语句
    day=mon

    day 变量的值为 1。当然,这个变量值是可以输出的。例如:
    printf ("%d",day)

    将输出整数 1
    如果在定义枚举类型时指定元素的值,也可以改变枚举元素的值。例如:
    enum weekday{sun=7,mon=1,tue,wed,thu,fri,sat}day

    这时,sun 7mon 1,以后元素顺次加 1,所以 sat 就是 6 了。
    枚举值可以用来作判断。例如:
    if (day==mon) {…}
    if (day>mon) {…}
    枚举值的比较规则是:按其在说明时的顺序号比较,如果说明时没有人为指定,则第一个枚举元素的值认作0。例如,mon>sunsat>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,yz的类型均为整型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_daybad_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; //
    变量todaytomorrow的类型为枚举型workday,也即enum workday

     

    enumworkday中的workday可以省略:


    typedef enum
    {
        saturday,
        sunday = 0,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday; //
    此处的workday为枚举型enum workday的别名
    workday today, tomorrow; //
    变量todaytomorrow的类型为枚举型workday,也即enum workday

     

    也可以用这种方式:


    typedef enum workday
    {
        saturday,
        sunday = 0,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    };
    workday today, tomorrow; //
    变量todaytomorrow的类型为枚举型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
    }

     

    展开全文
  • 使用枚举类型的变量,首先需要先定义一个枚举类型名,然后再声明该变量是枚举类型的例1:enum WEEKDAY{ \\该语句定义了一个枚举类型MONDAY = 1,TUSEDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,S...
  • 枚举类型enum用法 我是Java枚举的忠实拥护者。 似乎我们一直在等待获得它,但是当我们最终获得它( J2SE 5 )时,该枚举比CC ++提供的枚举要好得多,在我看来,“值得等待” 。 与Java enum一样好,它也不是没有问题...
  • C语言枚举类型enum

    2018-03-06 08:45:17
    2. 使用枚举类型对变量进行声明 方法一:枚举类型的定义和变量的声明分开 方法二:类型定义与变量声明同时进行 方法三:用typedef关键字将枚举类型定义成别名,并利用该别名进行变量声明 错误声明一:存在同名的枚举...
  • typedef enum week { Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } aaa; aaa bbb = Wed; aaa bbb2 = Wed; enum day { Mon2 = 1, Tues2, Wed2, Thurs2, Fri2, Sat2, Sun2 } ccc; ccc = Mon2; day ccc2 = S.
  • C语言枚举enum基本用法

    千次阅读 2019-07-04 16:34:28
    1.1枚举enum定义和调用 enum枚举最基本的用法是作为一个自定义的常量集合,比如enum ENUM{val1,val2...下面是一个枚举类型enum的定义和调用示例: enum EVal{val1,val2} Val; void Widget::on_pushButton_6_clic...
  • 在实际编程中,有些数据的取值往往是有限的,只能是非常少量的整数,并且最好为每个值都取一个名字,以方便在后续代码中使用,比如一个星期只有七天,一年只有十二个月,一个班每周有六门课程等。以每周七天为例,...
  • 枚举enum就是英文enumerate的缩写,也就是列举、排列说明的意思。枚举类型C语言中的一种特殊类型,枚举类型可以让我们的程序使用一些固定长度和固定数值的变量值范围。
  • C语言枚举类型Enum

    多人点赞 2018-10-18 19:59:32
    C语言枚举类型Enum) 在实际编程中,有些数据的取值往往是有限的,只能是非常少量的整数,并且最好为每个值都取一个名字,以方便在后续代码中使用,比如一个星期只有七天,一年只有十二个月,一个班每周有六门...
  • 在实际编程中,有些数据的取值往往是有限的,只能是非常少量的整数,并且最好为每个值都取一个名字,以方便在后续代码中使用,比如一个星期只有七天,一年只有十二个月,一个班每周有六门课程等。 以每周七天为例,...
  • java枚举类型 Enum

    2016-08-24 17:08:10
    java枚举类型 Enum
  • Java中枚举类型Enum用法介绍

    千次阅读 2016-08-21 21:26:38
    今天在学习的过程中遇到了枚举这个知识点。之前一直都知道这个“名字...定义:枚举类型enum type)是指由一组固定的常量组成合法的类型。Java中由关键字enum来定义一个枚举类型。例子如下: public enum Color{ RE
  • Java 枚举(enum) 详解7种常见的用法

    万次阅读 多人点赞 2016-08-11 11:14:45
    JDK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能,却给我的开发带来了“大”方便。...现在好了,有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。 Java代码 publ...
  • 在实际编程中,有些数据的取值往往是有限的,只能是非常少量的整数,并且最好为每个值都取一个名字,以方便在后续代码中使用,比如一个星期只有七天,一年只有十二个月,一个班每周有六门课程等。以每周七天为例,...
  • 枚举类型enum

    千次阅读 2014-04-10 19:12:31
    枚举类型使用方法 一般的定义方式如下: enum enum_type_name { ENUM_CONST_1, ENUM_CONST_2, ... ENUM_CONST_n } enum_variable_name; 注意:enum_type_name是自定义的一种数据数据类型名,而enum_...
  • 摘要 腾兴网为您分享:详解MySQL数据类型之枚举类型ENUM用法,中日翻译,先游,民宿客栈,蜜蜂查等软件知识,以及3dmax7,sql2005数据库,心田花开在线,联想服务,联想笔记本电池校正,可视化网页设计软件,w3...
  • C语言——enum枚举类型用法解析

    万次阅读 多人点赞 2018-05-25 17:13:19
    在实际的编程应用中,有的变量...要使用枚举类型的变量,首先需要先定义一个枚举类型名,然后再声明该变量是枚举类型的 例如: enum weekday{ \\该语句定义了一个`枚举类型` MONDAY, TUSEDAY, WEDNESDAY, ...
  • C语言枚举enum用法

    2020-10-09 14:38:25
    枚举enum)通过一种简单的途径,把一串名字与一串整形值联系在一起。可以代替#define声明 。但优点是#define定义的名字在编译时被丢弃,而枚举名字则通常在调试器中可见,可以在调试代码时使用它们。 使用举例 第...
  • 本文举例说明C语言enum枚举关键字的用法。用来同时定义多个常量利用enum定义月份的例子如下。#includeenumweek{Mon=1,Tue,Wed,Thu,Fri,Sat,Sun};int main(){ printf("%d",Tue); return 0;}这样定义Mon的值为1之后...
  • 本文举例说明C语言enum枚举关键字的用法。用来同时定义多个常量利用enum定义月份的例子如下。#include enumweek{Mon=1,Tue,Wed,Thu...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,966
精华内容 25,586
关键字:

c枚举类型enum用法