精华内容
下载资源
问答
  • c++11新增了enum class,相比传统的enum好处多了很多,但也有些让人不太爽的地方,如:输出到std流时会报错,进行了强转则没有信息输出,那么,到底该如何将enum class的值出到std流呢? 提供这个enum class的原因是...
  • 在C++中,枚举类型分为不限定作用域(enum)和限定作用域(enum class)。 2. enumenum class的区别? (为什么需要限定作用域?) 答:枚举作用域是指枚举类型成员名字的作用域,起自其声明之处,终止枚举定义...
  • C++ 语言枚举类 (enum class) 1. enum class //============================================================================ // Name : Yongqiang Cheng // Author : Yongqiang Cheng // Version : Version ...

    C++ 语言枚举类 (enum class)

    1. enum class

    //============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    
    enum Season
    {
    	Summer,
    	Spring,
    	Winter,
    	Autumn
    };
    
    enum Color {
    	Blue,
    	Pink,
    	Green
    };
    
    int main()
    {
    	Season s = Summer;
    	Color c = Blue;
    
    	if (s == c) {
    		std::cout << "Equal" << std::endl;
    	}
    	else {
    		std::cout << "Not Equal" << std::endl;
    	}
    
    	return 0;
    }
    

    Here, we want to check whether Summer is equal to Blue which is obviously not true since one of these is Season and the other a Color. In the above example, we got the output true because Summer and Blue got converted into integers and then those integers got compared.
    在这里,我们要检查 Summer 是否等于 Blue,这显然不是 true,因为其中一个是 Season,另一个是 Color。 在上面的例子中,我们得到了输出 true,因为 SummerBlue 被转换成整数,然后这些整数被比较。

    Equal
    请按任意键继续. . .
    

    The values of both Summer and Blue is 0 and thus the values of s and c became 0. So, the condition (s == c) became true and Equal got printed on the screen. This is not the desired output because we cannot compare a Season and a Color. Since Season and Color belong to different enumerations, therefore these should not be compared.
    SummerBlue 的值为 0,因此 sc 的值变为 0。因此,条件 (s == c) 变为 true,并且打印了 Equal 屏幕上。这不是所需的输出,因为我们无法比较 Season and Color。由于 Season and Color 属于不同的枚举,因此不应将它们进行比较。

    Here comes in enum class which limits the scope of the enumerators within their enums. So, now any enumerator will be known by its enum thus limiting its scope within the enum to which it belongs. This is the reason enum class is also called scoped enumeration.
    这里有 enum class,它限制了枚举中枚举数据的范围。因此,现在任何枚举数据都将通过其枚举知道,从而将其范围限制在它所属的枚举内。这就是枚举类也称为作用域枚举的原因。

    To make an enum class, we simply have to add the keyword class after the keyword enum.
    要创建一个 enum class,我们只需在关键字 enum 之后添加关键字 class

    enum class Season
    {
    	Summer,
    	Spring,
    	Winter,
    	Autumn
    };
    
    

    We made our enum Season an enum class by adding the keyword class after the keyword enum. Now let’s see how to access any element (enumerator) of this enum class.
    通过在关键字 enum 之后添加关键字 class,我们使我们的 enum Season 成为 enum class。现在让我们看看如何访问这个 enum class 的任何元素。

    Season::Summer
    

    The :: symbol simply means belong to. Here, Summer belongs to the enum class Season and thus cannot be directly accessed anywhere.
    :: 符号仅表示属于。在这里,Summer 属于 enum class Season,因此不能在任何地方直接访问。

    //============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    
    enum class Season
    {
    	Summer,
    	Spring,
    	Winter,
    	Autumn
    };
    
    enum class Color {
    	Blue,
    	Pink,
    	Green
    };
    
    int main()
    {
    	Season s = Season::Summer;
    	Color c = Color::Blue;
    
    	if (s == c) {
    		std::cout << "Equal" << std::endl;
    	}
    	else {
    		std::cout << "Not Equal" << std::endl;
    	}
    	return 0;
    }
    
    
    1>------ Build started: Project: hash_table, Configuration: Debug Win32 ------
    1>  yongqiang.cpp
    1>d:\visual_studio_workspace\hash_table\hash_table\yongqiang.cpp(30): error C2676: binary '==': 'Season' does not define this operator or a conversion to a type acceptable to the predefined operator
    ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
    

    In this example, we cannot directly access the enumerators (i.e. we cannot directly access it by writing Summer or Blue as we did in the first example ). We have to write the enum class name followed by :: before the enumerator name while accessing it because now the enumerator will be known by its enum class.
    在这个例子中,我们不能直接访问枚举数据 (即我们不能像在第一个例子中那样通过写 SummerBlue 来直接访问它)。 我们必须在访问枚举器名称之前写入 enum class 名称,后跟 ::,因为现在枚举数据将通过它的 enum class 识别。

    As in the above example, we accessed the Summer enumerator as Season::Summer thus telling the compiler that we are accessing Summer which is a Season. Similarly, by writing Color::Blue, we are telling the compiler that we are accessing Blue which is a Color. When we wrote the condition (s == c), we are comparing a Season and a Color thus getting an error.
    在上面的例子中,我们对 Summer 枚举数据通过 Season::Summer 访问,从而告诉编译器我们正在访问 Summer,它是一个 Season。类似地,通过编写 Color::Blue,我们告诉编译器我们正在访问 Blue,它是一个Color。当我们编写条件 (s == c) 时,我们正在比较一个 Season 和一个 Color,从而得到一个错误。

    We can compare the enumerators which belong to the same enum class.
    我们可以比较属于同一个 enum class 的枚举数据。

    //============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    
    enum class Color {
    	Blue,
    	Pink,
    	Green
    };
    
    int main()
    {
    	Color c = Color::Blue;
    
    	if (c == Color::Blue) {
    		std::cout << "Your color is Blue" << std::endl;
    	}
    	else if (c == Color::Pink) {
    		std::cout << "Your color is Pink" << std::endl;
    	}
    	else {
    		std::cout << "Your color is Green" << std::endl;
    	}
    
    	return 0;
    }
    
    
    Your color is Blue
    请按任意键继续. . .
    

    Note that enumerators are not converted to integers in the case of enum class. By writing Color c = Color::Blue;, we are assigning the color Blue of enum class Color to the variable c. So the condition (c == Color::Blue) became true and "Your color is Blue" got printed. In this condition, we compared c and Color::Blue, both of which belong to the enum class Color.
    请注意,在 enum class 的情况下,枚举数据不会转换为整数。通过编写 Color c = Color::Blue;,我们将 enum class Colorcolor Blue 分配给变量 c。 所以条件 (c == Color::Blue) 变为真,并且打印出 "Your color is Blue"。在这种情况下,我们比较了 cColor::Blue,它们都属于 enum class Color

    2. Example

    //============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    
    enum class RetVal
    {
    	SUCCESS = 0,
    	FAILURE = 1
    };
    
    enum class DebugLevelType
    {
    	NONE = 0,
    	PARTIAL = 1,
    	FULL = 2
    };
    
    enum class CompilerType
    {
    	ONLINE = 0,
    	OFFLINE = 1
    };
    
    enum class Color {
    	Blue,
    	Pink,
    	Green
    };
    
    int main()
    {
    	Color c = Color::Blue;
    
    	if (c == Color::Blue) {
    		std::cout << "Your color is Blue" << std::endl;
    	}
    	else if (c == Color::Pink) {
    		std::cout << "Your color is Pink" << std::endl;
    	}
    	else {
    		std::cout << "Your color is Green" << std::endl;
    	}
    
    	return 0;
    }
    
    
    Your color is Blue
    请按任意键继续. . .
    

    References

    https://www.codesdope.com/cpp-enum-class/

    展开全文
  • C++11的enum classenum struct 和 enum

    万次阅读 多人点赞 2018-05-17 19:49:35
    原文地址:https://blog.csdn.net/sanoseiichirou/article/details/50180533侵删C++标准文档——n2347(学习笔记) 链接:http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf旧版enum存在的问题1 ...

    原文地址:https://blog.csdn.net/sanoseiichirou/article/details/50180533

    侵删

    C++标准文档——n2347(学习笔记) 

    链接: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf

    1. 旧版enum存在的问题

    问题描述
    1向整形的隐式转换(Implicit conversion to an integer)
    2无法指定底层所使用的数据类型(Inability to specify underlying type)
    3enum的作用域(Scope)
    4不同编译器解决该问题的方法不统一

    1.1 问题1:向整形的隐式转换

    在开始这个问题之前,我们需要知道什么是整形提升

    查看之前的博文:C\C++中的整形提升

    在看完什么是整形提升之后,我们开始这个问题:

    旧版enum其实并不具有非常完全的类型安全(当然它也体现了一定的类型安全:1.禁止不同枚举体之间的赋值 2.禁止整形向枚举体的隐式转换等),也就是面对整形提升,旧版enum是没有抗拒力的。

    例如:

    #include <iostream>
    
    enum colorA{redA,greenA,grayA};
    enum colorB {redB,greenB,yellowB};
    
    void test(int data) {
        std::cout << "test called" << std::endl;
    }
    
    int main() {
        colorA ca(redA);
        colorB cb(greenB);
    
        //ca = cb; ERROR , 无法从“colorB”转换为“colorA”
        //ca = 2;  ERROR , 无法从“int”转换为“colorA”
    
        bool res(ca < cb); //OK
        std::cout << std::boolalpha << res << std::endl;
    
        test(ca); //OK
    
        std::cin.get();
        return 0;
    }

    运行结果:

    true 
    test called

    就像上面的代码:我们仍然可以比较两个不同枚举体的大小,用枚举体调用参数为int的函数。显然此时的枚举体发生了 整形提升 。


    在无法使用C++11新版enum的情况下,机制的程序员想到了:将enum封装到类的内部的方法。

    #include <iostream>
    
    class Color {
    private:
        enum _color { _red, _blue, _yellow, _black };
    public:
        explicit Color(const _color & other) {
            value = value;
        }
        explicit Color(const Color & other) {
            value = other.value;
        }
        const Color& operator=(const Color& other) {
            value = other.value;
            return *this;
        }
        static const Color red, blue, yellow, black;
        _color value;
        //operators
        bool operator <(const Color & other) { return value < other.value; }
        bool operator >(const Color & other) { return value > other.value; }
        bool operator <=(const Color & other) { return value <= other.value; }
        bool operator >=(const Color & other) { return value >= other.value; }
        bool operator ==(const Color & other) { return value == other.value; }
        //...
    
        //conversion
        int toint() { return value; }
    };
    //init static const Color obj
    const Color Color::red(Color::_color::_red);
    const Color Color::blue(Color::_color::_blue);
    const Color Color::yellow(Color::_color::_yellow);
    const Color Color::black(Color::_color::_black);
    
    void test(int data) {
        std::cout << "called" << std::endl;
    }
    
    int main() {
        Color ca(Color::blue);
        std::cout << ca.toint() << std::endl;
    
        //ca = 2; ERROR, 没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)
        //test(ca); ERROR, 无法将参数 1 从“Color”转换为“int”
        //bool res(ca > 2); ERROR,没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)
    
        std::cin.get();
        return 0;
    }

    的确,封装在类中的enum能够抵抗整形提升。但是这种enum不同于POD(plain old data),无法放入寄存器当中,这会带来额外的开销。


    1.2 问题2:无法指定底层所使用的数据类型

    A. 首先,无法指定数据类型,导致我们无法明确枚举类型所占的内存大小。这种麻烦在结构体当中尤为突出,特别是当我们需要内存对齐和填充处理的时候。

    #include <iostream>
    
    enum Version { Ver1 = 1, Ver2, Ver3 };
    
    struct MyStruct {
        MyStruct(Version ver) { this->Ver = ver; }
        Version Ver;
        //Ohters...
    };
    
    int main() {
        MyStruct m(Version::Ver1);
        std::cin.get();
        return 0;
    }
    • 此时我们的解决办法还是:不使用enum
    #include <iostream>
    
    enum Version { Ver1 = 1, Ver2, Ver3 };
    
    struct MyStruct {
        MyStruct(Version ver) { this->Ver = ver; }
        unsigned char Ver;//将enum Version转为unsigned char类型
        //Ohters...
    };
    
    int main() {
        MyStruct m(Version::Ver1);
        std::cin.get();
        return 0;
    }
    • B. 其次,当我们使用enum时,我们无法决定编译器底层是如何对待enum的(比如:signed和unsigned)。
    #include <iostream>
    
    enum MyEnum { num1 = 1, num2 = 2, numn = 0xFFFFFF00U };
    
    int main() {
        std::cout << num1 << std::endl;
        std::cout << num2 << std::endl;
        std::cout << numn << std::endl;
        std::cin.get();
        return 0;
    }
    • VS2015运行结果:



    -256

    CodeBlocks运行结果:



    4294967040


    在 numn=0xFFFFFF00U;中,我们希望0xFFFFFF00表现为unsigned。但是不同的编译器其标准也不同。这就给我们的程序带来了许多的不确定性。


    在文档n2347中的例子:不同编译器对0xFFFFFFF0U的表现。

    #include <iostream>
    using namespace std;
    enum E { E1 = 1, E2 = 2, Ebig = 0xFFFFFFF0U };
    int main() {
        cout << sizeof(E) << endl;
        cout << "Ebig = " << Ebig << endl;
        cout << "E1 ? -1 =\t" << (E1 < -1 ? "less" : E1 > -1 ? "greater" : "equal") << endl;
        cout << "Ebig ? -1 =\t" << (Ebig < -1 ? "less" : Ebig > -1 ? "greater" : "equal") << endl;
    }

    这里写图片描述


    1.3 问题3:enum的作用域

    enum的中的 ” { } ” 大括号并没有将枚举成员的可见域限制在大括号内,导致enum成员曝露到了上一级作用域(块语句)中。

    例如:

    #include <iostream>
    enum color{red,blue};//定义拥有两个成员的enum,red和blue在enum的大括号外部可以直接访问,而不需要使用域运算符。
    int main() {
        std::cout << blue << std::endl;
        std::cin.get();
        return 0;
    }

    运行结果:

    1

    -

    就如上面的代码,我们可以在blue的大括号之外访问它,color的成员被泄露到了该文件的全局作用域中(虽然它尚不具备外部链接性)。可以直接访问,而不需要域运算符的帮助。


    但是这不是关键,有时我们反而觉得非常方便。下面才是问题所在:

    • 问题:无法定义同名的枚举成员
    enum color { red, blue };
    //enum MyEnum { red, yellow }; ERROR, 重定义;以前的定义是“枚举数”
    • 1
    • 2

    如上面的代码所示:我们无法重复使用red这个标识符。因为它在color中已经被用过了。但是,它们明明就是不同的枚举类型,如果可以使用相同的成员名称,然后通过域运算符来访问的话,该有多好!就像下面这样:

    color::red

    但是这是旧版的enum无法做到的。


    • 解决上述问题:利用命名空间
    #include <iostream>
    
    namespace spaceA {
        enum color { red, blue };
    }
    namespace spaceB {
        enum colorX { red, blue };
    }
    int main() {
        std::cout << spaceA::red << std::endl;
        std::cout << spaceB::blue << std::endl;
        std::cout << std::boolalpha << (spaceA::red > spaceB::blue) << std::endl;
        std::cin.get();
        return 0;
    }

    运行结果:



    false

    -

    是的,只要利用命名空间我们就能解决枚举体的成员重定义问题,但是添加了多余的一层命名空间,未免显得麻烦


    1.4 不同编译器解决该问题的方法不统一

    在1.2中展示的图片告诉我们:有些编译器可能提供了相应的扩展来解决这些问题,但是有的编译器却没有,这使得我们的编程非常的不统一,有时候因为enum而削弱了程序的可移植性。


    2. enum class 和 enum struct


    2.1 enum class 和 enum struct 是等价的


    2.2 声明

    如大标题,枚举体的声明和定义使用 enum class或是enum struct, 二者是等价的。使用enum class\enum struct不会与现存的enum关键词冲突。而且enum class\enum struct具有更好的类型安全和类似封装的特性(scoped nature)。

    enum class color{red,green,yellow}; 
    enum class colorx{red,green=100,yellow}; 
    //....


    2.3 类型转换

    与整形之间不会发生隐式类型转换,但是可以强转。

    #include <iostream>
    
    enum class color { red, green, yellow};
    
    int main() {
        //int res(color::red); //ERROR , “初始化”: 无法从“color”转换为“int”
        //color col(2);//ERROR , “初始化”: 无法从“int”转换为“color”
    
        //强转
        int res(static_cast<int>(color::red));//OK
        color col(static_cast<color>(1));//OK
    
        std::cin.get();
        return 0;
    }


    2.4 指定底层数据类型(underlying type)

    默认的底层数据类型是int,用户可以通过:type(冒号+类型)来指定任何整形(除了wchar_t)作为底层数据类型。

    enum class color:unsigned char{red,blue};
    enum calss colorb:long long{yellow,black};
    • 1
    • 2

    2.5 域

    引入了域,要通过域运算符访问,不可以直接通过枚举体成员名来访问(所以我们可以定义相同的枚举体成员而不会发生重定义的错误)

    #include <iostream>
    
    enum class color { red, green, yellow};
    enum class colorX { red, green, yellow };
    
    int main() {
        //使用域运算符访问枚举体成员,强转后打印
        std::cout << static_cast<int>(color::red) << std::endl;
        std::cout << static_cast<int>(colorX::red) << std::endl;
        std::cin.get();
        return 0;
    }

    运行结果:


    0


    3. C++11enum的一些新特点

    • 枚举体的定义和声明问题 
      这里写图片描述
    • 用enum定义的枚举体是一个不具有封装性(不知道如何翻译是好:unscoped enumeration)的枚举体,他的成员可以在enum的大括号外被直接访问。而用enum class或是enum struct(二者在语法上是等价的)定义的枚举体是具有封装性的(scoped enumeration),他的成员同过成员名直接访问,而应通过域运算符来访问。
    #include <iostream>
    
    enum class color{red,black};
    enum colorx{green,yellow};
    
    int main() {
        color::red;//用域运算符访问color的成员
        green;//直接访问colorx的成员
        colorx::green;//用域运算符访问colorx的成员
        std::cin.get();
        return 0;
    }

    • 图中的enum-base应该只能是整形的数据(不能是浮点类型或是其他类型),const或是volatile会被忽略。
    • enumerator-list中的成员被作为常量使用,与常量的功能等价。
    • 使用=给成员初始化的时候,=右边应该使用常量,这个常量应该为整形或是其他的枚举类型。如果第一个枚举成员没有初始化,那么他默认为0,其他没有初始化的成员是前面一个成员的值加1。
    enum color { red=3, black, gray };//成员的值分别为:3 4 5
    enum colorx { green, yellow };//成员的值分别为:0 1
    enum colorxx{xred,xyellow,xblack=12,xgray};//成员的值分别为:0 1 12 13
    • 每种枚举体的类型都不同于其他枚举体。
    enum colora{red};//colora的类型与colorb的类型不同
    enum colorb{yellow};
    • 每种枚举都具有底层数据类型,同过:type(冒号+类型)来指定。对于指定了数据类型的枚举体,他的数据类型为指定的数据类型。如果没有固定的底层数据类型:

      1. 对于enum class和enum struct来说,他的底层数据类型是int。
      2. 对于enum来说,他的底层数据类型根据编译器而不同。
      3. 如果有使用数据初始化,那么他的数据类型与用来初始化的数据的类型相同。
    • 如果该枚举体没有指定的底层数据类型,而且该枚举体的成员为空,那么这个枚举体相当于只有一个成员0

    • enum(非enum class\enum struct)会发生整形提升
    #include <iostream>
    
    enum color { red, green, yellow };
    
    int main() {
        std::cout << std::boolalpha << (red == green) << std::endl;//(red == green)发生了整形提升
        std::cin.get();
        return 0;
    }
    • enum(非enum class\enum struct)会发生自动数据类型转换。但是enum class\enum struct是不允许这么做的。
    #include <iostream>
    
    enum color { red, green, yellow };
    
    int main() {
        //color col = 2;//ERROR , “初始化”: 无法从“int”转换为“color”
        int i = green;//发生隐式转换
        std::cout << i << std::endl;
        std::cin.get();
        return 0;
    }

    运行结果:

    1

    • 可以对enum和enum class\enum struct进行强制转换。
    #include <iostream>
    
    enum class color { red, green, yellow,a,b,v };
    
    int main() {
        int res(0);
        //res = color::red + color::green;//ERROR , “color”不定义该运算符或到预定义运算符可接收的类型的转换
        res = static_cast<int>(color::red) + static_cast<int>(color::green);
        std::cout << res << std::endl;
        std::cin.get();
        return 0;
    }
    • 运行结果:

    1


    3. 转载请注明出处

    展开全文
  • enumenum class的区别

    2021-09-06 14:33:21
    enum使用时的问题:其成员的可见范围被提升至该枚举类型所在的命名空间内 这就表示在同一个命名空间中比如std,某个枚举...防止命名空间被污染的方法是使用enum class enum class Student { man, women }; enum cla

    enum使用时的问题:其成员的可见范围被提升至该枚举类型所在的命名空间内
    这就表示在同一个命名空间中比如std,某个枚举成员只可以定义一次,"污染"了命名空间
    如下的定义是错误的

    namespace huxiang {
    enum Student {
    	man,
    	women
    };
    enum Teacher { // error
    	man,
    	women
    };
    }
    
    

    防止命名空间被污染的方法是使用enum class

    enum class Student {
    	man,
    	women
    };
    enum class Teacher { // yes
    	man,
    	women
    };
    

    使用enum class对枚举类型的成员的作用域进行了限定,避免同一个命名空间下的重定义产生

    展开全文
  • c++11新增了enum class,相比传统的enum好处多了很多,但也有些让人不太爽的地方,如:输出到std流时会报错,进行了强转则没有信息输出,那么,到底该如何将enum class的值出到std流呢? 下面,介绍一种通过重载<...

    c++11新增了enum class,相比传统的enum好处多了很多,但也有些让人不太爽的地方,如:输出到std流时会报错,进行了强转则没有信息输出,那么,到底该如何将enum class的值出到std流呢?

    下面,介绍一种通过重载<<操作符的方法来实现,如下:

    #include <iostream>
    #include <sstream>
    
    enum class error_code
    {
       ok=0,
       invalid_args=1,
       runtime_error=2,
       //..
    }; 
    
    //重载operator<<的操作符,使error_code支持<<输出
    std::ostream & operator<<(std::ostream &os,const error_code &ec)
     {
          os<<static_cast<std::underlying_type<error_code>::type>(ec);
          return os;
     }
    
    
    using namespace std;
    
    int main(int argc,char *argv[])
    {
        cout<<error_code::ok<<endl;
        cout<<error_code::invalid_arg<<endl;
        cout<<error_code::runtime_error<<endl;
     
        stringstream ss;
        ss<<error_code::runtime_error;
    
        return 0;
    }
    

     

    展开全文
  • C++枚举类型enumenum class

    千次阅读 多人点赞 2020-08-18 22:31:23
    文章目录一.关于枚举类型二.枚举类型enum的使用三.枚举类型enum class的使用 ...在C++中,枚举类型分为不限定作用域(enum)和限定作用域(enum class)。 2. enumenum class的区别? (为什么需要
  • c++11 enum class用法

    2020-01-14 15:42:09
    // C++11之前的enum类型是继承C的,不温不火; // C++11对enum动刀了,加强了类型检查,推出强类型enum类型,眼前一亮 // 使用过QT 的都知道,早就应该这么做了,用的非常爽!! // 一、C中enum类型的局限 // 1...
  • C++11枚举类——enum class

    千次阅读 2020-10-12 17:41:09
    enum class是限定作用域枚举型别,他们仅在枚举型别内可见,且只能通过强制转换转换为其他型别。 两种枚举都支持底层型别指定,enum class默认是int,enum没有默认底层型别 enum可以前置声明,enum仅在指定默认...
  • C++11 enum class 语法解析

    千次阅读 2018-04-14 00:57:35
    C++11 enum class 语法解析 要了解enum class的出现,则需要首先了解enum,方才知道为何有这东西。那么Meyers首先举出一个 例子来阐述: enum Color {black, white, red}; auto white = false; // error 其缘由...
  • kotlin枚举类enum class

    2019-06-04 14:15:00
    ​ 与Java一样,枚举类是一种特殊的类,kotlin可以通过enum class关键字定义枚举类。 2.注意点 枚举类可以实现0~N个接口; 枚举类默认继承于kotlin.Enum类(其他类最终父类都是Any),因此kotlin枚举类不能继承类;...
  • C++11中enum class的使用

    万次阅读 2017-11-14 22:04:54
    C++11中enum class的使用
  • c++ enum class的基础类型

    千次阅读 2020-02-02 16:02:25
    枚举通常用某种整数类型表示,这个类型被...// by 鸟哥 qq1833183060 enum class的基础类型 #include <iostream> #include <string> enum class Color:int {red,green,blue}; enum class Font:char...
  • C++惯用法之enum class

    2019-12-11 14:28:51
    C++惯用法之enum class在Effective modern C++中Item 10: Prefer scoped enums to unscoped enum,调到要用有范围的...
  • enumenum class

    千次阅读 2017-07-20 17:54:27
    1) enum的功能需要一系列的#define来完成,enum 完成了一系列#define的打包收集,所以对于两个不一样的枚举体,即使枚举体的名字不同,里面的内容也不能重名。 enum Direction { TOP_LEFT, TOP_RIGHT }; enum ...
  • c++11 enum class

    2018-11-02 15:35:29
    非常好的解释了为什么要引入enum class这个强类型enum。 任何希望精通C++的人,其实都应该认真的阅读C++的标准文档,而不是只看别人写的书,第一手资料,特别是标准文档永远都是不可替代的。然后才是其他的书籍帮助...
  • enum class的输出重载

    2019-09-29 09:23:16
    之前纠结enum class,其中一个问题就是,要输出type的名字,方便调试。今天尝试了一下输出重载,没想到竟然可以。测试如下, #include <iostream> using namespace std; enum class Type { TEXT, ...
  • C++ 11起引入的 enum class相对于传统的enum有了很多变化,主要是针对传统 enum 在编程过程中出现的值类型名称作用域、enum类型安全问题进行了改良. 一、传统enum类型 先来看看传统enum在编程过程中可能遇到的...
  • C++11的enum class & enum struct和enum

    万次阅读 多人点赞 2015-12-04 22:26:04
    C++标准文档——n2347(学习笔记) 链接:http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf旧版enum存在的问题 1 问题1向整形的隐式转换 ...enum classenum struct 1 enum
  • C/C++ enum class枚举类型

    万次阅读 2017-11-10 15:40:33
    声明枚举类型的方式有2种: 1. 常见的enum方式 enum A { a0 = 0, a1 = 1 }; enum B { ...2. enum class 方式 ...enum class CC { ...enumenum class的区别如下: 1. 使用方式 enum声明的枚举可以直接使用枚举
  • enum Side{ Right, Left }; enum Thing{ Wrong, Right }; //Right枚举名冲突,不可以 枚举类型被视为整数,这使得两种不同的枚举类型之间可以进行比较 如上例中,slide的right可以和thing中wrong比较,但...
  • enumenum class的使用

    千次阅读 2017-09-06 09:36:00
    enum class既用在类外,又可以用在类内,用在类内作用域的范围为整个类,类外作用域全局。无论内外,只要用到里面的内容必须加上 枚举类::内容 c++11中引入了新的枚举类型---->强制枚举类型 enum [identifier] [: ...
  • (typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e) { 27 return stream << static_cast<typename std::underlying_type<T>::type> (e); 28 } 29 } main...
  • 然后我们知道C++11出来个enum class,改善了上述问题,并使枚举变成强数据类型。 在一般情况,这种做法都是很不错的。但有时候我们还是希望enum变量可以int类型互转。尤其是程序会反复调用时,我们不希望引入独立的...
  • c++11中输出enum class变量的数值

    千次阅读 2017-07-08 11:35:24
    enum class强枚举类c++11中定义了强枚举类,即enum class,与之前的enum类型相比,它解决了以下三个问题: 1. 枚举类型与整形之间的隐式转换: 2. 底层类型无法由程序员指定: 3. 弱作用域

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 292,311
精华内容 116,924
关键字:

enumclass