C++ - 介绍enum的使用

在 C++ 中，枚举关键字用于定义枚举，枚举是一种用户定义的数据类型，由一组命名的积分常量组成。枚举可以用有意义的名称来表示相关常量的集合，从而提高代码的可读性和可维护性。

In C++, the enum keyword is used to define an enumeration, which is a user-defined data type consisting of a set of named integral constants. Enumerations are useful for representing a collection of related constants with meaningful names, improving code readability and maintainability.

Basic Enum Definition

Here’s how you can define and use a basic enumeration in C++:

#include <iostream>

// Define an enum outside of any class

enum Color {

    RED,

    GREEN,

    BLUE

};

int main() {

    // Declare a variable of type Color

    Color myColor = RED;

    // Use the enum variable in a switch statement

    switch (myColor) {

        case RED:

            std::cout << "The color is RED" << std::endl;

            break;

        case GREEN:

            std::cout << "The color is GREEN" << std::endl;

            break;

        case BLUE:

            std::cout << "The color is BLUE" << std::endl;

            break;

        default:

            std::cout << "Unknown color" << std::endl;

            break;

    }

    return 0;

}

Scoped Enumerations (enum class)

在 C++11 及更高版本中，可以使用 enum class（或 enum struct）定义作用域枚举。作用域枚举提供了更好的类型安全性，并防止了全局命名空间的污染。

In C++11 and later, you can define scoped enumerations using enum class (or enum struct). Scoped enumerations provide better type safety and prevent pollution of the global namespace.

#include <iostream>

// Define a scoped enum (enum class)

enum class Color {

    RED,

    GREEN,

    BLUE

};

int main() {

    // Declare a variable of type Color

    Color myColor = Color::RED;

    // Use the enum variable in a switch statement

    switch (myColor) {

        case Color::RED:

            std::cout << "The color is RED" << std::endl;

            break;

        case Color::GREEN:

            std::cout << "The color is GREEN" << std::endl;

            break;

        case Color::BLUE:

            std::cout << "The color is BLUE" << std::endl;

            break;

        default:

            std::cout << "Unknown color" << std::endl;

            break;

    }

    return 0;

}

Enum Inside a Class

你可以在类内定义一个枚举，以便在类范围内封装相关常量：

You can define an enum inside a class to encapsulate related constants within the class scope:

#include <iostream>

class MyClass {

public:

    // Define an enum inside the class

    enum Color {

        RED,

        GREEN,

        BLUE

    };

    // Method to demonstrate usage of the enum

    void printColor(Color color) {

        switch (color) {

            case RED:

                std::cout << "Color is RED" << std::endl;

                break;

            case GREEN:

                std::cout << "Color is GREEN" << std::endl;

                break;

            case BLUE:

                std::cout << "Color is BLUE" << std::endl;

                break;

            default:

                std::cout << "Unknown color" << std::endl;

                break;

        }

    }

};

int main() {

    MyClass myObject;

    // Use the enum defined in the class

    myObject.printColor(MyClass::RED);

    myObject.printColor(MyClass::GREEN);

    myObject.printColor(MyClass::BLUE);

    return 0;

}

Scoped Enum Inside a Class

还可以在类内定义一个作用域枚举（枚举类），以提高类型安全性：

You can also define a scoped enum (enum class) inside a class for better type safety:

#include <iostream>

class MyClass {

public:

    // Define a scoped enum inside the class

    enum class Color {

        RED,

        GREEN,

        BLUE

    };

    // Method to demonstrate usage of the enum

    void printColor(Color color) {

        switch (color) {

            case Color::RED:

                std::cout << "Color is RED" << std::endl;

                break;

            case Color::GREEN:

                std::cout << "Color is GREEN" << std::endl;

                break;

            case Color::BLUE:

                std::cout << "Color is BLUE" << std::endl;

                break;

            default:

                std::cout << "Unknown color" << std::endl;

                break;

        }

    }

};

int main() {

    MyClass myObject;

    // Use the scoped enum defined in the class

    myObject.printColor(MyClass::Color::RED);

    myObject.printColor(MyClass::Color::GREEN);

    myObject.printColor(MyClass::Color::BLUE);

    return 0;

}

Summary

* 基本枚举： 使用枚举定义一组简单的相关常量。

* 作用域枚举： 使用枚举类可以提高类型安全性，避免命名空间污染。

* 类中的枚举： 在类中定义枚举，将其封装在类范围内。

* 类中的作用域枚举： 在类中使用枚举类，以实现封装和类型安全。

* Basic Enum: Use enum to define a simple set of related constants.

* Scoped Enum: Use enum class for better type safety and to avoid namespace pollution.

* Enum in Class: Define enums inside a class to encapsulate them within the class scope.

* Scoped Enum in Class: Use enum class inside a class for encapsulation and type safety.

= = = = = = = = = = = = 分割线 = = = = = = = = = = = =

Enumeration declaration - cppreference.com

枚举是一种独特的类型，其值仅限于一个值范围（详见下文），其中可能包括几个明确命名的常量（"枚举器"）。

常量的值是被称为枚举底层类型的整形类型的值。枚举的大小、值表示和对齐要求与其基础类型相同。此外，枚举的每个值都与底层类型的相应值具有相同的表示形式。

An enumeration is a distinct type whose value is restricted to a range of values (see below for details), which may include several explicitly named constants ("enumerators").

The values of the constants are values of an integral type known as the underlying type of the enumeration. An enumeration has the same size, value representation, and alignment requirements as its underlying type. Furthermore, each value of an enumeration has the same representation as the corresponding value of the underlying type.

Declaration:

enum-key attr (optional) enum-head-name (optional) enum-base (optional) { enumerator-list , };

可以在枚举器列表后加上逗号。

A trailing comma can follow the enumerator-list.

声明之后，该类型就是一个完整的类型.

After this declaration, the type is a complete type.

enum-key:

enum (until C++11)

one of enum, enum class, or enum struct (since C++11)

enum-head-name:

要声明的枚举的名称，可以省略。

The name of the enumeration that's being declared, it can be omitted.

enum-base：

(自 C++11 起）冒号（:），后跟一个 type-specifier-seq，命名一个整形类型，作为该枚举类型的固定基础类型。

(since C++11) colon (:), followed by a type-specifier-seq that names an integral type that will serve as the fixed underlying type for this enumeration type

格式如下：

enum struct|class name : type { enumerator = constant-expression , enumerator = constant-expression , ... }

type可以是unsigned char，std::uint32_t等。

例如：

enum class Handle : std::uint32_t { Invalid = 0 };

enumerator-list:

用逗号分隔的枚举器定义列表，每个枚举器定义都是一个唯一标识符（成为枚举器的名称），或者是一个带有常量表达式的唯一标识符：identifier = constant-expression。

Comma-separated list of enumerator definitions, each of which is either simply a unique identifier, which becomes the name of the enumerator, or a unique identifier with a constant expression: identifier = constant-expression.

枚举有两种不同的类型：非作用域枚举（使用 enum-key enum 声明）和作用域枚举（使用 enum-key enum class 或 enum struct 声明）。

There are two distinct kinds of enumerations: unscoped enumeration (declared with the enum-key enum) and scoped enumeration (declared with the enum-key enum class or enum struct).

Unscoped enumerations

enum name (optional) { enumerator = constant-expression , enumerator = constant-expression , ... }

enum name (optional) : type { enumerator = constant-expression , enumerator = constant-expression , ... }

enum name : type ;

底层类型是实现定义的整数类型，可以表示所有枚举器的值。

The underlying type is an implementation-defined integral type that can represent all enumerator values.

如果枚举器列表为空，底层类型就如同枚举只有一个值为 0 的枚举器。

If the enumerator-list is empty, the underlying type is as if the enumeration had a single enumerator with value 0.

每个枚举器都会成为枚举类型（即名称）的命名常量，在外层作用域中可见，并可在需要常量时使用。

Each enumerator becomes a named constant of the enumeration's type (that is, name), visible in the enclosing scope, and can be used whenever constants are required.

enum Color { red, green, blue };

Color r = red;

switch(r)

{

    case red  : std::cout << "red\n";   break;

    case green: std::cout << "green\n"; break;

    case blue : std::cout << "blue\n";  break;

}

如果第一个枚举器没有 =，则相关值为零。对于定义中没有 = 的其他枚举器，相关值是前一个枚举器的值加一。

If the first enumerator does not have =, the associated value is zero. For any other enumerator whose definition does not have an =, the associated value is the value of the previous enumerator plus one.

enum Foo { a, b, c = 10, d, e = 1, f, g = f + c };

//a = 0, b = 1, c = 10, d = 11, e = 1, f = 2, g = 12

非作用域枚举的名称可以省略：这种声明只是将枚举引入外层作用域：

The name of an unscoped enumeration may be omitted: such declaration only introduces the enumerators into the enclosing scope:

enum { a, b, c = 0, d = a + 2 }; // defines a = 0, b = 1, c = 0, d = 2

Scoped enumerations

enum struct|class name { enumerator = constant-expression , enumerator = constant-expression , ... }

enum struct|class name : type { enumerator = constant-expression , enumerator = constant-expression , ... }

enum struct|class name ;

enum struct|class name : type ;

struct和class两个关键字等效。

第一行和第三行的基础类型（underlying type）都是int。

Using-enum-declaration

using enum nested-name-specifier (optional) name ;(since C++20)

enum class fruit { orange, apple };

struct S

{

    using enum fruit; // OK: introduces orange and apple into S

};

void f(){

    S s;

    s.orange;  // OK: names fruit::orange

    S::orange; // OK: names fruit::orange

}

引入两个同名枚举器的两个 using-enum-declarations 会发生冲突。

Two using-enum-declarations that introduce two enumerators of the same name conflict.

enum class fruit { orange, apple };

enum class color { red, orange };

void f(){

    using enum fruit;    // OK

    // using enum color; // error: color::orange and fruit::orange conflict

}