精华内容
下载资源
问答
  • c的printf怎么输出枚举类型变量

    万次阅读 2016-11-08 14:18:17
    enum设计出来是为了编写代码方便而使用的,底层并不保存枚举量名称,如果你真需要打印出enum的变量名称出来,可以使用下面的方式: typedef enum { A, B, C }ENUM_SAM_T; 如果直接打印的话,ABC只能打印为%d,0,1,2。...

    C语言枚举类型打印出来好像只能打印为%d格式,而且打印的结果是当前这个元素在枚举类型的位置。

    enum enumtest{test1, test2};

    printf("%d",test1);

    此时打印结果是0,表示test1在他的枚举类型定义为第0个元素。

    如果要打印出来test1的话,可以增加一个字符串数组,通过位置索引来打印test1.


    int main(){
            enum enumtest{test1,test2};
            char *s[]={"test1","test2"};
            printf("%d\n",test2);
            printf("%s\n",s[test2]);
            return 0;
    }
    

    打印结果为 :

    1

    test2

    展开全文
  • 枚举

    2021-02-17 17:09:33
    1.如果自己不去给枚举值赋初值,就自动从0开始定义 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h> //枚举 enum WEEKDAY { ri, yi,er,sa,si,wu,li...

    在这里插入图片描述
    1.如果自己不去给枚举值赋初值,就自动从0开始定义

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    //枚举
    enum WEEKDAY 
    {
    	ri,
    	yi,er,sa,si,wu,li
    };
    void test()
    {
    	printf("%d ",ri);
    	printf("%d ", yi);
    	printf("%d ", er);
    	printf("%d ", sa);
    	printf("%d ", si);
    	printf("%d ", wu);
    	printf("%d ", li);
    }
    int main()
    {
    	test();
    	return 0;
    }
    
    

    在这里插入图片描述
    2.匿名枚举类型

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    //枚举
    //匿名枚举
    enum 
    {
    	a,b
    };
    void test()
    {
    	printf("%d ",a);
    	printf("%d ", b);
    
    }
    int main()
    {
    	test();
    	return 0;
    }
    
    

    3.可以自定义枚举类型变量

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    //枚举
    enum  aa
    {
    	a=2,b
    };
    void test()
    {
    	enum aa a1 = a;
    	printf("%d ",a1);
    	printf("%d ", b);
    
    }
    int main()
    {
    	test();
    	return 0;
    }
    

    在这里插入图片描述
    4.枚举值是常量,不能在程序中赋值
    5.取别名:

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    //枚举
    typedef enum  aaa
    {
    	a=2,b
    }aa;
    void test()
    {
    	 aa a1 = a;
    	printf("%d ",a1);
    	printf("%d ", b);
    
    }
    int main()
    {
    	test();
    	return 0;
    }
    
    
    展开全文
  • JAVA 枚举详解 ​ java 枚举类型的基本想法非常简单:这些类通过共有的静态final域为每个枚举常量导出一个实例。枚举类型没有可以访问的构造器,所以它是真的final类。客户端不能创建枚举类型的实例,也不能对它进行...

    JAVA 枚举详解

    ​ java 枚举类型的基本想法非常简单:这些类通过共有的静态final域为每个枚举常量导出一个实例。枚举类型没有可以访问的构造器,所以它是真的final类。客户端不能创建枚举类型的实例,也不能对它进行扩展,因此不存实例,而只存在声明过程的枚举常量。也就是枚举类型是实例受控的。它们是单例(Singleton)的范型化,本质上是单元素的枚举。

    ​ 枚举类型保证了编译时的类型安全。包含同名常量的多个枚举类型可以在一个系统中和平共处。因为每个类型都有自己的命名空间。可以新增或者重新排列枚举类型中的常量,而无需重新编译它的客户端代码。

    ​ 枚举类型可以添加任意的方法和域,并实现任意的接口。它们提供了所有的Object方法的高级实现,实现了Comparable和Serializable接口,并针对枚举类型的可任意改变性提供了序列化方法。

    ​ 举个例子,如定义一个状态类型枚举类,代码如下:

    public enum StatusPublicEnum {
        FAIL("失败", "300", "认证系统"),
        OK("成功", "200", "认证系统");
    
        private final String msg;
        private final String status;
        private final String code;
    
        StatusPublicEnum(String msg, String status, String code) {
            this.msg = msg;
            this.status = status;
            this.code = code;
        }
    
        public String toJson() throws Exception {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("msg",this.msg);
            jsonObject.put("status",this.status);
            jsonObject.put("code",this.code);
            return jsonObject.toCompactString();
        }
    
        public static void main(String[] args) throws Exception {
            System.out.println(StatusPublicEnum.FAIL.toJson());
            System.out.println(StatusPublicEnum.OK.toJson());
        }
    
    }
    

    说明:在枚举类型StatusPublicEnum中添加了toJson 方法,该方法返回了枚举类中定义三个属性的JSON串。我们使用时可以直接调用StatusPublicEnum.OK.toJson()方法,返回OK枚举对象的JSON串。返回结果如下

    {"msg":"失败","status":"300","code":"认证系统"}
    {"msg":"成功","status":"200","code":"认证系统"}
    

    ​ StatusPublicEnum实例对于大多数枚举类型来说足够了,但是我们有时候会需要更多的方法。每个常量关联了不同的数据类型,但有时需要将不同的行为与每个常量关联起来。例如我们编写一个枚举类型,来表示计算器的四大基本操作,你想要提供一个方法来执行每个常量所表示的算术运算。有一种方式是通过启用枚举的值来实现。

    /**
     * 枚举计算类
     */
    public enum Operation {
        PLUS, MINUS, TIMES, DIVIDE;
        public double apply(double x, double y) {
            switch (this) {
                case PLUS:
                    return x + y;
                case MINUS:
                    return x - y;
                case TIMES:
                    return x * y;
                case DIVIDE:
                    return x / y;
            }
            throw new AssertionError("Unknown op:" + this);
        }
        public static void main(String[] args) {
            System.out.println(Operation.PLUS.apply(2, 3));
        }
    }
    

    ​ 这段代码能用,但是不太好看。如果没有 throw 语句,它就不能进行编译,虽然从技术角度来看代码的结束部分是可以执行的,但是实际上是不可能执行到这行代码的。更糟糕的是,这段代码很脆弱。如果新增一个枚举常量,却忘记给switch添加相应的条件,枚举类型可以编译,但是运行新的枚举常量时,运行就会失败。

    ​ 让我们改进这个方法,在枚举类型中声明一个抽象的apply方法,并在特定于常量的类主体中,用具体的方法覆盖每个常量的抽象apply方法。这种方法被称为特定于常量的方法实现。

    /**
     * 枚举计算类
     */
    public enum Operation {
        PLUS("+") {
            @Override
            public double apply(double x, double y) {
                return x + y;
            }
        }, MINUS("-") {
            @Override
            public double apply(double x, double y) {
                return x - y;
            }
        }, TIMES("*") {
            @Override
            public double apply(double x, double y) {
                return x * y;
            }
        }, DIVIDE("/") {
            @Override
            public double apply(double x, double y) {
                return x / y;
            }
        };
    
        private final String symbol;
    
        Operation(String symbol) {
            this.symbol = symbol;
        }
    
        public abstract double apply(double x, double y);
    
        @Override
        public String toString() {
            return symbol;
        }
    
        public static void main(String[] args) {
            double x = 4;
            double y = 2;
            for (Operation operation : Operation.values()) {
                System.out.printf("%f %s %f = %f%n",
                        x, operation, y, operation.apply(x, y));
            }
        }
    }
    

    通过接口扩展枚举

    ​ 虽然枚举类型是不可扩展的,但是接口类型确实可扩展的,它是用来表示API中的操作的接口类型。你可以定义另一个枚举类型,它实现这个接口,并用这个新类型的实例代替基本类型。

    定义接口:

    public interface IOperation {
        double apply(double x, double y);
    }
    

    枚举实现:

    /**
     * 枚举计算类
     */
    public enum Operation implements IOperation{
        PLUS("+") {
            @Override
            public double apply(double x, double y) {
                return x + y;
            }
        }, MINUS("-") {
            @Override
            public double apply(double x, double y) {
                return x - y;
            }
        }, TIMES("*") {
            @Override
            public double apply(double x, double y) {
                return x * y;
            }
        }, DIVIDE("/") {
            @Override
            public double apply(double x, double y) {
                return x / y;
            }
        };
    
        private final String symbol;
    
        Operation(String symbol) {
            this.symbol = symbol;
        }
        @Override
        public String toString() {
            return symbol;
        }
        public static void main(String[] args) {
            double x = 4;
            double y = 2;
            for (Operation operation : Operation.values()) {
                System.out.printf("%f %s %f = %f%n",
                        x, operation, y, operation.apply(x, y));
            }
    
        }
    }
    

    扩展实现乘积运算:

    public enum ExtOperation implements IOperation {
    
        EXP("^") {
            @Override
            public double apply(double x, double y) {
                return Math.pow(x, y);
            }
        };
        private final String symbol;
    
        ExtOperation(String symbol) {
            this.symbol = symbol;
        }
    
        @Override
        public String toString() {
            return this.symbol;
        }
        
    	//入参实现IOperation接口并且是枚举类型。这个可以将该限定去掉,只要实现IOperation接口即可。
        private static <T extends Enum<T> & IOperation> void test(Class<T> tClass, double x,
                                                                  double y) {
            for (IOperation operation : tClass.getEnumConstants()) {
                System.out.printf("%f %s %f = %f%n",
                        x, operation, y, operation.apply(x, y));
            }
        }
    
        public static void main(String[] args) {
            test(ExtOperation.class,2,3);//使用扩展实现枚举对象
            test(Operation.class,2,3);//使用默认的实现
        }
    
    }
    

    更多内容请查看 Julywhj的博客期待您的光顾。

    展开全文
  • 1. printf 枚举可显示枚举的序号: #include <stdio.h> int main(void) { enum ABC{AAA,BBB,CCC}; enum ABC e1,e2,e3; e1 = AAA; e2 = BBB; e3 = CCC; printf("%d, %d, %...

    1. printf 枚举可显示枚举的序号:
    
    #include <stdio.h>
    
    int main(void)
    {
        enum ABC{AAA,BBB,CCC};
    
        enum ABC e1,e2,e3;
    
        e1 = AAA;
        e2 = BBB;
        e3 = CCC;
        
        printf("%d, %d, %d\n", e1, e2, e3);
        getchar();
        return 0;
    }
    

    2. 定义枚举时可同时定义变量:
    
    #include <stdio.h>
    
    int main(void)
    {
        enum ABC{AAA,BBB,CCC} e1=BBB, e2=BBB+1, e3=e2-2;
        
        printf("%d, %d, %d\n", e1, e2, e3);
        getchar();
        return 0;
    }
    

    3. 同时定义变量时, 你甚至可以不要枚举名:
    
    #include <stdio.h>
    
    int main(void)
    {
        enum {AAA,BBB,CCC} e=BBB;
        
        printf("%d\n", e);
    
        e++;
        printf("%d\n", e);
        
        getchar();
        return 0;
    }
    

    4. 可随意指定序号:
    
    #include <stdio.h>
    
    int main(void)
    {
        enum ABC{AAA=2,BBB,CCC=9} e1, e2, e3;
    
        e1 = AAA;
        e2 = BBB;
        e3 = CCC;
        
        printf("%d, %d, %d\n", e1, e2, e3);
        getchar();
        return 0;
    }
    

    5. 序号重了都不要紧:
    
    #include <stdio.h>
    
    int main(void)
    {
        enum ABC{AAA=2,BBB=2,CCC} e1, e2, e3;
    
        e1 = AAA;
        e2 = BBB;
        e3 = CCC;
        
        printf("%d, %d, %d\n", e1, e2, e3);
        getchar();
        return 0;
    }
    

    转载于:https://www.cnblogs.com/del/archive/2008/11/27/1342235.html

    展开全文
  • 枚举——简单枚举

    千次阅读 2018-03-08 23:04:30
    第一次写博客,写得不好请见谅,我想把acm之路的过程记录下来思想:1、枚举也称暴力法,很多问题都可以通过枚举来完成,虽然大多数题目都有可能超时,但是枚举法都是分析清楚题目的初始解法,本人中招过某些题目就是...
  • c++枚举

    2021-07-27 21:02:44
    一、枚举类型的定义 枚举类型的定义:枚举类型(enumeration)是 C++ 中的一种派生数据类型,它是由用户定义的若干枚举常量的集合。 定义格式:枚举类型的定义格式为:enum <类型名> {<枚举常量表>}; 例如...
  • 重构printf

    2021-04-23 14:15:53
    定义枚举类型打印等级 typedef enum { Log_Off = 0, Log_Error = 1, Log_Warn = 2, Log_Info = 3, Log_Debug = 4, Log_Trace = 5, }Log_Level; 定义当前打印等级 uint8_t Current_Log_Level = Log_Debug; 调用printf...
  • C语言 枚举 enum

    千次阅读 2016-01-11 13:28:53
    一、枚举的概念 枚举是C语言中的一种基本数据类型,并不是构造类型,它可以用于声明一组常数。当一个变量有几个固定的可能取值时,可以将这个变量定义为枚举类型。比如,你可以用一个枚举类型的变量来表示季节,...
  • 枚举enum

    2020-10-17 15:15:49
    C enum(枚举) 枚举是 C 语言中的一种基本数据类型,它可以让数据更简洁,更易读。 枚举语法定义格式为: enum 枚举名 {枚举元素1,枚举元素2,……}; instance analysis: #include <... printf("%d",day);
  • 枚举.3.枚举

    2020-02-23 12:26:34
    枚举量 -声明枚举量时可以指定值 enum color{red=1, yellow... printf("code for blue is %d\n",blue); return 0; } 枚举只是int -即使给枚举类型的变量赋不存在的整数值也没有任何的Warning或error #include <...
  • 枚举常量

    2017-10-19 19:48:01
    枚举常量 enum 枚举常量是需要占用内存的,需要在内存中开辟一个空间进行存储。 #include enum Sex { MALE, FEMALE, SECRET }; int main()  { printf("%d\n", MALE);  printf("%d\n", FEMALE); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,462
精华内容 75,384
关键字:

printf枚举