织梦可以做微网站吗国外flash网站

当前位置： 首页 > news >正文

织梦可以做微网站吗,国外flash网站,爱站查询工具,怎么做网站登陆战在 C 中#xff0c;枚举关键字用于定义枚举#xff0c;枚举是一种用户定义的数据类型#xff0c;由一组命名的积分常量组成。枚举可以用有意义的名称来表示相关常量的集合#xff0c;从而提高代码的可读性和可维护性。 In C, the enum keyword is used to define an enumer… 在 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) 在 C11 及更高版本中可以使用 enum class或 enum struct定义作用域枚举。作用域枚举提供了更好的类型安全性并防止了全局命名空间的污染。 In C11 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 C11) one of enum, enum class, or enum struct (since C11) enum-head-name: 要声明的枚举的名称可以省略。 The name of the enumeration thats being declared, it can be omitted. enum-base (自 C11 起冒号:后跟一个 type-specifier-seq命名一个整形类型作为该枚举类型的固定基础类型。 (since C11) 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 charstd::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 enumerations 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® { 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 C20) 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 }