C++ 模拟C#/Java中的检举（enum)类型

最新推荐文章于 2023-01-09 04:31:19 发布
最新推荐文章于 2023-01-09 04:31:19 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++ methods c class exception spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nocky/article/details/6315604
版权

    在C++中enum类型仅仅相当于一系列的整数常量，如果要在日志中显示或标准输出打印时需要把整数与一个字符串对应起来，从配置文件中读取时为了配置文件的可读性最好配置的是字符串名称而不是数字，使用enum类型很不方便，而在C#和Java中都可以方便地使用enum类型的toString方法转换成字符串，或使用parse方法来从字符串转换为对应的enum类型。但我们可以使用类来实现类似C#的enum类型，使用其静态成员变量来代替各enum的各值，再增加相应的方法即可，例如实现一个表示一周各天的类：

class Weekday{
private:
    typedef enum{ _Sunday, _Monday, _Tuesday, _Wednesday, _Thursday,_Friday, _Saturday , _END} WeekdayValue;
    static const char* _names[];

    const WeekdayValue _value;

    Weekday(const WeekdayValue value)
        :_value(value)
    {
    }
public:
    int Value( void ) const { return _value; }
    const char* Name( void ) const { return _names[_value]; }
    operator int( void ) const { return (int)_value; }
public:
    static Weekday Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday;

    static Weekday Parse(const char* str);
    static const char** GetNames( void ) { return _names; }
};
const char* Weekday::_names[]  = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday","Friday", "Saturday"  };

Weekday Weekday::Parse( const char* str )
{
    for(int i=0; i         if( stricmp(str, _names[i]) == 0){
            return Weekday((WeekdayValue)i);
        }
    }
    throw std::exception("Not a valid Weekday name");
}

使用示例：

int main( void )
{
    Weekday d0 = Weekday::FromValue(0);
    cout<<"d0 = "< <

    Weekday d6 = Weekday::FromValue(6);
    cout<<"d6 = "< <

    cout<<"Thursday = {"< <<":"< <<"}"<

    Weekday d5 = Weekday::Parse("FRIDAY");
    cout<<"d5 = "< <
    return 0;
}

但是如果每次我们定义一下这样的类都写这么多代码显然有点儿麻烦，而且很多东西是重复的，可以通过使用宏来简化编码，分别定义两个宏，DeclareEnumN和ImplementEnumN，前者用于生成声明，后者用于声明定义，其中的N表示包含的成员的个数，由于宏不支持宏名的重载，只能通过不同宏名称来区分。这样我们在定义枚举类时需要在.hpp的头文件中来使用DeclareEnumN进行声明，在.cpp的源程序文件中使用ImplementEnumN来定义。宏的实现代码如文件enum_class.hpp:

// enum_class.hpp

#ifndef ENUM_CLASS_HPP_H_
#define ENUM_CLASS_HPP_H_

#include

/** common */
#define DECLARE_ENUM_COMMON_METHODS( C) /
private: /
             static const char* _names[]; /
             const  EnumValue _value; /
             explicit C(const EnumValue value) /
             :_value(value)     /
            { /
                if(_value > _END) /
                    throw std::exception("Invalid value of "#C);    /
            } /
public: /
        int Value( void ) const { return _value; } /
        const char* Name( void ) const { return _names[_value]; } /
        operator int( void ) const { return (int)_value; } /
public: /
        inline static const char** GetNames( void ) { return _names; } /
        static C FromValue(const int value ); /
        static C Parse(const char* str)

#define IMPLEMENT_ENUM_COMMON_METHODS( C ) /
    C C::Parse( const char* str ) /
    { /
    for(int i=0; i
    if( stricmp(str, _names[i]) == 0){ /
    return C((EnumValue)i); /
    } /
    } /
    throw std::exception("Not a valid "#C " name"); /
}

/** 2 enum values */
#if 1
#define DeclareEnum2(C, E1, E2)    /
class C{ /
    private: typedef enum{ _##E1, _##E2, _END} EnumValue; /
    public: static C E1, E2; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
};

#define ImplementEnum2(C, E1, E2) /
    const char* C::_names[]  = {""#E1, ""#E2}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 3 enum values */
#if 1
#define DeclareEnum3(C, E1, E2, E3)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3; /
};

#define ImplementEnum3(C, E1, E2, E3) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 4 enum values */
#if 1
#define DeclareEnum4(C, E1, E2, E3, E4)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4; /
};

#define ImplementEnum4(C, E1, E2, E3, E4) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 5 enum values */
#if 1
#define DeclareEnum5(C, E1, E2, E3, E4, E5)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _##E5, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4, E5; /
};

#define ImplementEnum5(C, E1, E2, E3, E4, E5) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4, ""#E5}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    C C::E5(C::_##E5); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

//** 6 enum values */
#if 1
#define DeclareEnum6(C, E1, E2, E3, E4, E5, E6)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _##E5, _##E6, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4, E5, E6; /
};

#define ImplementEnum6(C, E1, E2, E3, E4, E5, E6) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4, ""#E5, ""#E6}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    C C::E5(C::_##E5); /
    C C::E6(C::_##E6); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 7 enum values */
#if 1
#define DeclareEnum7(C, E1, E2, E3, E4, E5, E6, E7)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _##E5, _##E6, _##E7, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4, E5, E6, E7; /
};

#define ImplementEnum7(C, E1, E2, E3, E4, E5, E6, E7) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4, ""#E5, ""#E6, ""#E7}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    C C::E5(C::_##E5); /
    C C::E6(C::_##E6); /
    C C::E7(C::_##E7); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 8 enum values */
#if 1
#define DeclareEnum8(C, E1, E2, E3, E4, E5, E6, E7, E8)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _##E5, _##E6, _##E7, _##E8, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4, E5, E6, E7, E8; /
};

#define ImplementEnum8(C, E1, E2, E3, E4, E5, E6, E7, E8) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4, ""#E5, ""#E6, ""#E7, ""#E8}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    C C::E5(C::_##E5); /
    C C::E6(C::_##E6); /
    C C::E8(C::_##E7); /
    C C::E7(C::_##E8); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 9 enum values */
#if 1
#define DeclareEnum9(C, E1, E2, E3, E4, E5, E6, E7, E8, E9)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _##E5, _##E6, _##E7, _##E8, _##E9, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4, E5, E6, E7, E8, E9; /
};

#define ImplementEnum9(C, E1, E2, E3, E4, E5, E6, E7, E8, E9) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4, ""#E5, ""#E6, ""#E7, ""#E8, ""#E9}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    C C::E5(C::_##E5); /
    C C::E6(C::_##E6); /
    C C::E7(C::_##E7); /
    C C::E8(C::_##E8); /
    C C::E9(C::_##E9); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

/** 10 enum values */
#if 1
#define DeclareEnum10(C, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10)    /
class C{ /
private: typedef enum{ _##E1, _##E2, _##E3, _##E4, _##E5, _##E6, _##E7, _##E8, _##E9, _##E10, _END} EnumValue; /
    DECLARE_ENUM_COMMON_METHODS( C ); /
public: static C E1, E2, E3, E4, E5, E6, E7, E8, E9, E10; /
};

#define ImplementEnum10(C, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10) /
    const char* C::_names[]  = {""#E1, ""#E2, ""#E3, ""#E4, ""#E5, ""#E6, ""#E7, ""#E8, ""#E9, ""#E10}; /
    C C::E1(C::_##E1); /
    C C::E2(C::_##E2); /
    C C::E3(C::_##E3); /
    C C::E4(C::_##E4); /
    C C::E5(C::_##E5); /
    C C::E6(C::_##E6); /
    C C::E7(C::_##E7); /
    C C::E8(C::_##E8); /
    C C::E9(C::_##E9); /
    C C::E10(C::_##E10); /
    IMPLEMENT_ENUM_COMMON_METHODS( C)
#endif

//------------------
#endif

该文件定义了2-10个参数的宏，如果需要更多的参数可以自行添加，或者不使用宏，而直接利用定义好的DECLARE_ENUM_COMMON_METHODS、IMPLEMENT_ENUM_COMMON_METHODS两个宏，来定义自己的类，也可以省去很多通用编码。使用时，例如在头文件中进行声明：
// enum_class_demo.hpp

#ifndef ENUM_CLASS_DEMO_HPP
#define ENUM_CLASS_DEMO_HPP

#include "enum_class.hpp"

DeclareEnum2(Result, OK, Error);

DeclareEnum3(E3, E3_1, E3_2, E3_3);
DeclareEnum4(E4, E4_1, E4_2, E4_3, E4_4);
DeclareEnum5(E5, E5_1, E5_2, E5_3, E5_4, E5_5);
DeclareEnum6(E6, E6_1, E6_2, E6_3, E6_4, E6_5, E6_6);
DeclareEnum7(E7, E7_1, E7_2, E7_3, E7_4, E7_5, E7_6, E7_7);
DeclareEnum8(E8, E8_1, E8_2, E8_3, E8_4, E8_5, E8_6, E8_7, E8_8);
DeclareEnum9(E9, E9_1, E9_2, E9_3, E9_4, E9_5, E9_6, E9_7, E9_8, E9_9);
DeclareEnum10(E10, E10_1, E10_2, E10_3, E10_4, E10_5, E10_6, E10_7, E10_8, E10_9,E10_10);

DeclareEnum4(Season, Spring, Summer, Autumn, Winter);

#endif

而在源程序enum_class_demo.cpp文件中进行定义，例如：

#include
#include
using namespace std;
#include "enum_class_demo.hpp"
ImplementEnum2(Result, OK, Error);

ImplementEnum3(E3, E3_1, E3_2, E3_3);
ImplementEnum4(E4, E4_1, E4_2, E4_3, E4_4);
ImplementEnum5(E5, E5_1, E5_2, E5_3, E5_4, E5_5);
ImplementEnum6(E6, E6_1, E6_2, E6_3, E6_4, E6_5, E6_6);
ImplementEnum7(E7, E7_1, E7_2, E7_3, E7_4, E7_5, E7_6, E7_7);
ImplementEnum8(E8, E8_1, E8_2, E8_3, E8_4, E8_5, E8_6, E8_7, E8_8);
ImplementEnum9(E9, E9_1, E9_2, E9_3, E9_4, E9_5, E9_6, E9_7, E9_8, E9_9);
ImplementEnum10(E10, E10_1, E10_2, E10_3, E10_4, E10_5, E10_6, E10_7, E10_8, E10_9,E10_10);

ImplementEnum4(Season, Spring, Summer, Autumn, Winter);

int main( void )
{
    cout<<"ok = {"< <<":"< <<"}"<
    cout<<"error = {"< <<":"< <<"}"<

    cout<<"E3_3 = "< <
    cout<<"E4_4 = "< <
    cout<<"E5_5 = "< <
    cout<<"E6_6 = "< <
    cout<<"E7_7 = "< <
    cout<<"E8_8 = "< <
    cout<<"E9_9 = "< <
    cout<<"E10_10 = "< <

    Season ssn = Season::Parse("winter");
    cout<<"ssn = "< <
    return 0;
}

这样以后再需要定义类似C#或Java中的enum类时只需要两行就可以了。

但是这各模拟方式还有一个缺点，那就是这里用的值都是连续的，如果要定义不连续的值则需要自行实现。使用连续值的一个最重要的原因就是性能，与符串的映射表很自然地实现为一个指针数组，性能非常高效，再加上inline，可以说从数值到字符串的转换几乎达到了性能的0消耗。

在实际使用中使用enum的绝大多数情况下使用连续值即可，枚举值作为mask使用的情况就更复杂，这样还需要重载实现位操作运算符，但技术上实现是没有问题的，而且性能并不会有太大的损耗，对于硬件比大白菜还便宜的时代，这点儿性能又算得了什么呢？所换来的可读性节约的维护成本是完全可以弥补这点儿损失。

noock
关注
专栏目录
一个Java Enum的C++实现
THINK . DESIGN . CODE
11-25 3131
Java 1.5提供了一个新的类型 - Enum，区别于传统C/C++的整型语义的枚举，Java的Enum为使用多态分支来取代 if/else 和 switch 这样的类型码相依逻辑的选择代码块提供了一个轻量级的实现，并同时具备传统的整型枚举语义与额外的便利的字符串语义 (可以获得枚举量对应的整型序号值与字符串值 oridinal toString，或通过字符串值获得对应的枚举量 valueOf)
c# 添加中文描述 给enum_C#中的枚举(Enum)你知道多少呢？
weixin_36329818的博客
01-14 1243
枚举(Enum)定义enum关键字用于声明枚举，即一种由一组称为枚举数列表的命名常量组成的独特类型。通常情况下，最好是在命名空间内直接定义枚举，以便该命名空间中的所有类都能够同样方便地访问它。但是，还可以将枚举嵌套在类或结构中。现在的有些电商网站根据购物的积分用到的，金牌会员，银牌会员，铜牌会员.enumMemberLevel{gold,silver,copper}枚举值获取一般获取的时候包括获取...
C# C++ enum 枚举 例子.rar
03-27
enum day {Sun,Mon,Tue,Wed,Thu,Fri,Sat}; 默认情况下，枚举符的值从0开始，其后值总是前面一个+1。 即Sun=0,Mon=1,Tue=2,Wed=3,Thu=4,Fri=5,Sat=6 也可以自己定义数值，其后值总是前面一个+1 例如： enum day {Sun=7,Mon=1,Tue,Wed,Thu,Fri,Sat}d1,d2,d3; 给枚举量赋值 d1=Sun; d2=Mon; d3=Sat; //不可以直接赋予数值量，如d3=6;错 即有结果 d1==7; d2==1; d3==6; 使用枚举好处： 提高安全性 增加可读性
C++ enum的使用
无敌秋
07-11 805
enum c++
c++与java的枚举
wenwenxiong的专栏
05-05 1469
Java枚举和C++枚举的主要区别为两点，一是C++中的枚举中只能定义常量，主要用于switch子句，二是C++中的枚举常量可以直接和数值型变量进行各种数学运算。 java的枚举 枚举的是在Java 1.5SE 中开始支持的，以下为Java枚举的基本概念和应用技巧： 1. 所有的enum对象均是由class对象作为底层支持的，该对象继承自JDK中的Enum，但是该底层类确实final类，
c++ enum 给定类型_C++枚举类型详解
weixin_28914101的博客
01-31 537
一、枚举类型的定义enum 类型名 {枚举值表}；类型名是变量名，指定枚举类型的名称。枚举值表也叫枚举元素列表，列出定义的枚举类型的所有可用值，各个值之间用“,”分开。例：enum Suit { Diamonds, Hearts, Clubs, Spades };二、枚举变量说明枚举变量有多种声明方式：1.枚举类型定义与变量声明分开如：enum Suit { Diamonds, Hearts, C...
C++枚举类型enum与enum class的使用
08-24
enum和enum class都是C++中枚举类型的实现方式，区别在于是否限定其作用域。enum的成员的可见范围被提升至该枚举类型所在的作用域内，而enum class能够限定其作用域，避免了枚举成员的重定义。 三、枚举类型enum的...
关于c#中枚举类型支持显示中文的扩展说明
12-31
public enum AuditEnum{　Holding=0,　Auditing=1, Pass=2,  Reject=3 } 以asp.net为例　，　程序中某个方法可能会这样使用枚举值　：public void HandleAudit(int userID, AuditEnum ae){　if (ae==AuditEnum....
C#中FlagsAttribute属性在enum中的应用详解
01-19
Net C#中枚举的声明格式如下所示： [attributes] [modifiers] enum identifier [:base-type] {enumerator-list} [;] FlagsAttribute属性就是枚举类型的一项可选属性。它的主要作用是可以将枚举作为位域处理(P.S. ...
enum 泛型_浅谈C++与C#泛型编程的区别与联系
weixin_39701735的博客
11-30 232
前言这阵子群友讨论了很多次C++模板元编程和C#泛型的区别，但是大家懂得，在QQ群讨论这种体量的论题，你一言我一语很难说清楚，尤其是大家对各种名词的理解和定义不一致的情况下，所以我决定今天整一篇文章，结合代码，浅谈一下C++和C#泛型编程的区别与联系。个人水平有限，欢迎大家指正，补充。名词定义正如上面所说，每个人对于各种名词的认识之间可能存在着差别，所以在这里统一用我的方式定义一下以下名词泛型：泛...
C#与C调用C++Dll，非托管，含struct调用及enum公用，完整项目，可直接编译或运行
03-12
C#与C调用C++，非托管，含struct调用及enum公用，完整项目，可直接编译或运行。 项目将所有工程的输出统一到Debug。 vs2015+Framework4.6,注意工程的配置。 所有东西自写，只是出于样例参考的作用，所以代码规范性见谅。
C++自定义的枚举类型（enum）和字符串相互转换
ST_stone的博客
01-09 9452
在使用上非常简洁的实现C++的enum（枚举类型）和string相互转换，定义和使用过程和enum几乎一样，但可以实现enum和string相互转换。
C#基础系列（4）-- 第一部分 基础数据类型与操作 -- 枚举类型与位标志（4）
amandag的专栏
12-07 2056
经常有人问下面的问题，就是在GridView的RowDataBound事件中，判断是否是EditItemTemplate里的控件为什么是if ((e.Row.RowState & DataControlRowState.Edit) != 0)而不是if (e.Row.RowState == DataControlRowState.Edit)具体代码如下：protected void Gri
C++实现反射机制
cxu123321的博客
04-01 693
C++实现反射机制 NET下的很多技术都是基于反射机制来实现的，反射让.NET平台下的语言变得得心应手。最简单的，比如枚举类型，我们我可以很容易的获得一个枚举变量的数值以及其名称字符串。 可是，在C++中，枚举变量本质上和一个整形变量没有区别，我们很难获取一个枚举变量的名称字符串。 其实在C++中，我们可以通过宏来实现类似反射的机制。 接下来，我想总结一下如何在C++中实现一个类似于C#枚...
enum 和 typedef 知识点总结
qq_38866454的博客
10-27 2118
文章目录前言一、enum（枚举）二、typedef1.引入库2.读入数据总结 前言 主要记录学习编程的经验和个人知识点总结，仅供学习用途。 提示：以下是本篇文章正文内容，主要讲 enum（枚举）和 typedef。 一、enum（枚举） 枚举是C语言中的一种基本数据类型，它可以让数据更简洁，更易读。 枚举语法定义格式为： enum 枚举名 { 枚举元素1， 枚举元素2， ... }枚举变量; 枚举名是自定义的一种数据数据类型名，而枚举变量为枚举名类型的一个变量，叫做枚举变量。 枚举变
C#枚举多选的原理与实现
漩子——二进制看世界
12-20 3247
利用枚举来传递多个参数实现多选。 原理其实是用2进制数的每一位来进行表示一个枚举值，比如A=00000001，B=00000010，C=00000100三个枚举值，其实就是2的N次方，如果将A和C进行相加或者是按位与及得到表示两个枚举值的00000101，这个代表多个值的枚举值，我们将其简称为多重枚举（此名字为杜撰）。原理很简单，我们来看应用。实现，用一个unity中的编辑器扩展的例子来说明u
Unity之EditorGUILayout-Enum、Popup、EnumMaskField
热门推荐
lq
11-29 1万+
Unity之EditorGUILayout-Enum、Popup、EnumMaskField一、在Inspector面板编辑显示 Enum 类型，如下图创建 脚本 MaskT.CSusing UnityEngine; using System.Collections;public enum EventType { OnClick = 0, Down, Enter, E
Unity C# 用枚举（enum）制作复选框
AdvancedPicachu的博客
10-25 1770
    最近在项目中做测试脚本用到一些布尔值做方法的开关，突然想到可以制作一个复选框控制开关。 首先搜集网上的资料，基本大同小异，这里就不多做解释了，代码附上： 1 public class EnumFlagsAttribute : PropertyAttribute{} 1 [CustomPropertyDrawer(typeof(EnumFlagsAttrib...
Enum.Parse 方法 (Type, String)
dwzsq的专栏
02-15 1万+
 将一个或多个枚举常数的名称或数字值的字符串表示转换成等效的枚举对象。    参数enumType枚举的 Type。 value包含要转换的值或名称的字符串。 返回值enumType类型的对象，其值由 value表示。public enum Weekday        {             Sun,Mon,Tue,Wen,Thu,Fr
C++和Java中枚举enum的用法
最新发布
05-28
在C++中，枚举类型是一种用户自定义类型，它定义了一组命名的整型常量。枚举类型使用关键字enum定义，如下所示： ``` enum Color { RED, GREEN, BLUE }; ``` 在上面的示例中，我们定义了一个名为Color的枚举类型，它包含三个常量：RED，GREEN和BLUE。默认情况下，这些常量被分配为0、1和2。 在Java中，枚举类型是一种数据类型，它定义了一组命名的值，这些值被称为枚举常量。枚举类型使用关键字enum定义，如下所示： ``` enum Color { RED, GREEN, BLUE } ``` 在上面的示例中，我们定义了一个名为Color的枚举类型，它包含三个常量：RED，GREEN和BLUE。这些常量被自动分配为0、1和2。 在C++和Java中，我们可以使用枚举类型来定义一组常量，这些常量具有相同的类型，并且可以在程序中使用它们作为常量值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值