如何在 C 中定义枚举类型（enum）？

Question

我不确定使用 C 枚举的正确语法是什么。 我有以下代码：

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = IMMEDIATE;

但这无法编译，并出现以下错误：

error: conflicting types for ‘strategy’
error: previous declaration of ‘strategy’ was here

我做错了什么？

Answer 1

值得一提的是，在 C++ 中，您可以使用“enum”来定义新类型，而无需 typedef 语句。

enum Strategy {RANDOM, IMMEDIATE, SEARCH};
...
Strategy myStrategy = IMMEDIATE;

我发现这种方法更加友好。

[编辑 - 澄清了 C++ 状态 - 我最初有这个，然后删除了它！]

Answer 2

@ThoAppelsin 对所发布问题的评论是正确的。 问题中发布的代码片段是有效的并且没有错误。 您遇到的错误一定是因为 c 源文件的任何其他位置存在其他错误语法。 enum{a,b,c}; 定义了三个符号常量（a、b 和 c），它们是分别具有值 0、1 和 2 的整数，但是当我们使用 enum 时，这是因为我们不通常我们关心具体的整数值，我们更关心符号常量名的含义。
这意味着您可以这样：

#include <stdio.h>
enum {a,b,c};
int main(){
  printf("%d\n",b);
  return 0;
}

并且这将输出 1。

这也将是有效的：

#include <stdio.h>
enum {a,b,c};
int bb=b;
int main(){
  printf("%d\n",bb);
  return 0;
}

并且输出与以前相同。

如果你这样做：

enum {a,b,c};
enum {a,b,c};

你将会有一个错误，但是如果你这样做：

enum alfa{a,b,c};
enum alfa;

你将不会有任何错误。

你可以这样做：

enum {a,b,c};
int aa=a;

aa 将是一个值为 0 的整数变量。 但你也可以这样做：

enum {a,b,c} aa= a;

并且 会产生相同的效果（即，aa 是一个具有 0 值的 int）。

您也可以这样做：

enum {a,b,c} aa= a;
aa= 7;

aa 将是 int，值为 7。

因为您不能使用 enum 重复符号常量定义，正如我之前所说，如果您想使用 int 声明变量，则必须使用标签>enum：

enum tag1 {a,b,c};
enum tag1 var1= a;
enum tag1 var2= b;

使用typedef是为了避免每次都写enum tag1来定义变量。 使用typedef，您只需键入Tag1：

typedef enum {a,b,c} Tag1;
Tag1 var1= a;
Tag1 var2= b;

您还可以：

typedef enum tag1{a,b,c}Tag1;
Tag1 var1= a;
enum tag1 var2= b;

最后要说的是，由于我们正在讨论定义的符号常量，因此最好在以下情况下使用大写字母：使用enum，例如：

enum {A,B,C};

而不是

enum {a,b,c};

Answer 3

该声明似乎存在混乱。

当 strategy 位于 {RANDOM, IMMEDIATE, SEARCH} 之前（如下所示）时，

enum strategy {RANDOM, IMMEDIATE, SEARCH};

您将创建一个名为 enum Strategy 的新类型。 但是，在声明变量时，您需要使用枚举策略本身。 您不能只使用策略。 所以下面的内容是无效的。

enum strategy {RANDOM, IMMEDIATE, SEARCH};
strategy a;

然而，以下内容是有效的

enum strategy {RANDOM, IMMEDIATE, SEARCH};

enum strategy queen = RANDOM;
enum strategy king = SEARCH;
enum strategy pawn[100];

---

当strategy出现在{RANDOM, IMMEDIATE, SEARCH}之后时，您正在创建一个匿名枚举，然后将strategy声明为是该类型的变量。

所以现在，您可以执行类似的操作

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = RANDOM;

，但是，您不能声明任何其他类型为 enum {RANDOM, IMMEDIATE, SEARCH} 的变量，因为您从未命名过它。 因此以下内容无效

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
enum strategy a = RANDOM;

---

您也可以将这两个定义组合起来

enum strategy {RANDOM, IMMEDIATE, SEARCH} a, b;

a = RANDOM;
b = SEARCH;
enum strategy c = IMMEDIATE;

---

Typedef 如前所述用于创建更短的变量声明。

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy;

现在您已经告诉编译器enum {RANDOM, IMMEDIATE, SEARCH} 与strategy 同义。 所以现在你可以自由地使用strategy作为变量类型。 您不再需要输入枚举策略。 以下内容现在有效

strategy x = RANDOM;

---

您还可以将 Typedef 与枚举名称结合起来获取

typedef enum strategyName {RANDOM, IMMEDIATE, SEARCH} strategy;

除了您现在可以使用 strategy 和 enumstrategyName 可以互换。

typedef enum strategyName {RANDOM, IMMEDIATE, SEARCH} strategy;

enum strategyName a = RANDOM;
strategy b = SEARCH;

Answer 4

如果您声明枚举的名称，则不会发生错误。

如果未声明，则必须使用 typedef：

enum enum_name {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = IMMEDIATE;

它不会显示错误...

Answer 5

我最喜欢且唯一使用的结构始终是：

typedef enum MyBestEnum
{
    /* Good enough */
    GOOD = 0,
    /* Even better */
    BETTER,
    /* Divine */
    BEST
};

我相信这会解决您遇到的问题。 从我的角度来看，使用新类型是正确的选择。

Answer 6

Tarc 的答案是最好的。

大部分关于枚举的讨论都是转移注意力的。

比较一下这个代码片段：

int strategy;
strategy = 1;   

void some_function(void) 
{
}

它

error C2501: 'strategy' : missing storage-class or type specifiers
error C2086: 'strategy' : redefinition

与编译没有问题的代码片段相同。

int strategy;

void some_function(void) 
{
    strategy = 1;   
}

变量strategy需要在声明时或函数内部等处设置。您不能在全局范围内编写任意软件（特别是赋值）。

他使用 enum {RANDOM, IMMEDIATE, SEARCH} 而不是 int 的事实仅与它让那些无法超越它的人感到困惑有关。
问题中的重新定义错误消息表明这是作者做错的事情。

现在您应该能够明白为什么下面的示例中的第一个是错误的，而其他三个则没有问题。

示例 1。错误！

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = IMMEDIATE;

void some_function(void) 
{
}

示例 2。正确。

enum {RANDOM, IMMEDIATE, SEARCH} strategy = IMMEDIATE;

void some_function(void) 
{
}

示例 3。正确。

enum {RANDOM, IMMEDIATE, SEARCH} strategy;

void some_function(void) 
{
    strategy = IMMEDIATE;
}

示例 4。正确。

void some_function(void) 
{
    enum {RANDOM, IMMEDIATE, SEARCH} strategy;
    strategy = IMMEDIATE;
}

如果您有一个可以运行的程序，您应该能够将这些片段粘贴到您的程序中，并看到有些可以编译，有些则不能。

Answer 7

我尝试使用 GCC 并根据我的需要提出，我被迫使用最后一个替代方案，编译无错误。

typedef enum 状态 {a = 0, b = 1, c = 2} 状态;

如：

typedef enum state {a = 0, b = 1, c = 2} state;

typedef enum state old; // New type, alias of the state type.
typedef enum state new; // New type, alias of the state type.

new now     = a;
old before  = b;

printf("State   now = %d \n", now);
printf("Sate before = %d \n\n", before);

Answer 8

C

enum stuff q;
enum stuff {a, b=-4, c, d=-2, e, f=-3, g} s;

声明充当具有完整类型的有符号整数 s 的暂定定义，以及充当范围内不完整类型的有符号整数 q 的暂定定义（其中解析为作用域中的完整类型，因为类型定义存在于作用域中的任何位置）（与任何暂定定义一样，标识符 q 和 s 可以使用以下命令重新声明多次使用相同类型 int 或 enum stuff 的不完整或完整版本，但仅在范围内定义一次，即 int q = 3；并且只能在子范围内重新定义，并且只能在定义之后使用）。 此外，您只能在作用域中使用完整类型的枚举内容一次，因为它充当类型定义。

enum stuff 的编译器枚举类型定义也出现在文件范围内（在之前和之后可用）以及前向类型声明（类型 enum stuff 可以有多个声明，但作用域中只有一个定义/完成，并且可以在子作用域中重新定义）。 它还充当编译器指令，用 r 替换 a -value 0，b 与 -4，c 与 5 >、d 与 -2、e 与 -3、f 与 < code>-1 和 g 以及 -2 在当前范围内。 现在，枚举常量在定义之后应用，直到在不同的枚举中进行下一次重新定义，而该枚举不能位于同一范围级别。

typedef enum bool {false, true} bool;

// This is the same as
enum bool {false, true};
typedef enum bool bool;

// Or
enum bool {false, true};
typedef unsigned int bool;

// Remember though, bool is an alias for _Bool if
// you include stdbool.h. And casting to a bool
// is the same as the "!!" operator

enum、struct和union共享的标签命名空间是独立的，必须以C语言中的type关键字（enum、struct或union）作为前缀，即在enum a {a} b之后，必须使用 enum a c 而不是 a c。 由于标记命名空间与标识符命名空间是分开的，因此允许使用 enum a {a} b，但不允许使用 enum a {a, b} b，因为常量位于与变量标识符相同的命名空间，标识符命名空间。 typedef enum a {a,b} b 也是不允许的，因为 typedef-names 是标识符命名空间的一部分。

enum bool 的类型和常量在 C 中遵循以下模式：

+--------------+-----+-----+-----+
|   enum bool  | a=1 |b='a'| c=3 |
+--------------+-----+-----+-----+
| unsigned int | int | int | int |
+--------------+-----+-----+-----+

+--------------+-----+-----+-----+
|   enum bool  | a=1 | b=-2| c=3 |
+--------------+-----+-----+-----+
|      int     | int | int | int |
+--------------+-----+-----+-----+

+--------------+-----+---------------+-----+
|   enum bool  | a=1 |b=(-)0x80000000| c=2 |
+--------------+-----+---------------+-----+
| unsigned int | int |  unsigned int | int |
+--------------+-----+---------------+-----+

+--------------+-----+---------------+-----+
|   enum bool  | a=1 |b=(-)2147483648| c=2 |
+--------------+-----+---------------+-----+
| unsigned int | int |  unsigned int | int |
+--------------+-----+---------------+-----+

+-----------+-----+---------------+------+
| enum bool | a=1 |b=(-)0x80000000| c=-2 |
+-----------+-----+---------------+------+
|    long   | int |      long     |  int |
+-----------+-----+---------------+------+

+-----------+-----+---------------+------+
| enum bool | a=1 | b=2147483648  | c=-2 |
+-----------+-----+---------------+------+
|    long   | int |      long     |  int |
+-----------+-----+---------------+------+

+-----------+-----+---------------+------+
| enum bool | a=1 | b=-2147483648 | c=-2 |
+-----------+-----+---------------+------+
|    int    | int |      int      |  int |
+-----------+-----+---------------+------+

+---------------+-----+---------------+-----+
|   enum bool   | a=1 | b=99999999999 | c=1 |
+---------------+-----+---------------+-----+
| unsigned long | int | unsigned long | int |
+---------------+-----+---------------+-----+

+-----------+-----+---------------+------+
| enum bool | a=1 | b=99999999999 | c=-1 |
+-----------+-----+---------------+------+
|    long   | int |      long     |  int |
+-----------+-----+---------------+------+

这表明常量类型基于分配给它的文字，并且没有后缀的整数文字通常总是遵循 int > > 长整数> long long int （字符文字也是 C 中的 int，但不是 C++）。 然而，枚举类型似乎是可以表示枚举中定义的所有常量的最小类型（并且当所有整数均为正数时，无论出于何种原因，更倾向于选择 unsigned int）。

这在 C 中编译得很好：

#include <stdio.h>
enum c j;
enum c{f, m} p;
typedef int d;
typedef int c;
enum c j;
enum m {n};

int main() {
  enum c j;
  enum d{l};
  enum d q;
  enum m y;
  printf("%llu", j);
}

C++

在 C++ 中，枚举可以有类型

enum Bool: bool {True, False} Bool;
enum Bool: bool {True, False, maybe} Bool; // Error

在这种情况下，常量和标识符都具有相同的类型 bool，如果数字不能用该类型表示，则会发生错误。 也许= 2，这不是一个布尔值。 另外，True、False 和 Bool 不能是小写，否则会与语言关键字冲突。 枚举也不能有指针类型。

C++ 中枚举的规则有所不同。

#include <iostream>

c j; // Not allowed, unknown type name c before
     //  enum c{f} p; line
enum c j; // Not allowed. A forward declaration of enum
          // type is not allowed and variable can have
          // an incomplete type, but not when it's still
          // a forward declaration in C++ unlike C
enum c{f, m} p;
typedef int d;
typedef int c; // Not allowed in C++ as it clashes with
               // enum c, but if just int c were used
               // then the below usages of c j; would
               // have to be enum c j;
[enum] c j;
enum m {n} ;
int main() {
  [enum] c j;
  enum d{l}; // Not allowed in same scope as typedef,
             // but it is allowed here
  d q;
  m y; // Simple type specifier not allowed, need
       // elaborated type specifier enum m to
       // refer to enum m here
  p v; // Not allowed, need enum p to refer to enum p
  std::cout << j;
}

C++ 中的枚举变量不再只是无符号整数等； 它们也是枚举类型，只能在枚举中分配常量。 然而，这可以被抛弃。

#include <stdio.h>

enum a {l} c;
enum d {f} ;
int main() {
  c=0; // Not allowed;
  c=l;
  c=(a)1;
  c=(enum a)4;
  printf("%llu", c); //4
}

枚举类

枚举结构与枚举类相同。

#include <stdio.h>
enum class a {b} c;
int main() {
  printf("%llu", a::b<1) ; // Not allowed
  printf("%llu", (int)a::b<1) ;
  printf("%llu", a::b<(a)1) ;
  printf("%llu", a::b<(enum a)1);
  printf("%llu", a::b<(enum class a)1) ; // Not allowed
  printf("%llu", b<(enum a)1); // Not allowed
}

作用域解析运算符仍然可用于非作用域枚举。

#include <stdio.h>

enum a: bool {l, w};

int main() {
  enum a: bool {w, l} f;
  printf("%llu", ::a::w);
}

但由于 w 不能在范围内定义为其他内容，因此 ::w 和 ::a::w 之间没有任何区别>。

Answer 9

值得指出的是，您不需要 typedef。 你可以像下面这样做，

enum strategy { RANDOM, IMMEDIATE, SEARCH };
enum strategy my_strategy = IMMEDIATE;

这是一个风格问题，你是否喜欢typedef。 如果没有它，如果要引用枚举类型，则需要使用枚举策略。 有了它，你就可以直接说策略。

两种方式都有其优点和缺点。 一个更冗长，但将类型标识符保留在标记命名空间中，这样它们就不会与普通标识符冲突（想想 struct stat 和 stat 函数：这些不也不冲突），并且您立即看到它是一种类型。 另一个更短，但将类型标识符带入普通命名空间。

Answer 10

声明枚举变量的方式如下：

enum strategy {RANDOM, IMMEDIATE, SEARCH};
enum strategy my_strategy = IMMEDIATE;

但是，您可以使用 typedef 来缩短变量声明，如下所示：

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy my_strategy = IMMEDIATE;

使用命名约定来区分类型和变量是一个好主意：

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy_type;
strategy_type my_strategy = IMMEDIATE;

Answer 11

您尝试声明strategy两次，这就是您收到上述错误的原因。 以下内容没有任何抱怨（使用 gcc 编译 -ansi -迂腐 -Wall):

#include <stdio.h>

enum { RANDOM, IMMEDIATE, SEARCH } strategy = IMMEDIATE;

int main(int argc, char** argv){
    printf("strategy: %d\n", strategy);

    return 0;
}

如果不是上面的，第二行改为：

...
enum { RANDOM, IMMEDIATE, SEARCH } strategy;
strategy = IMMEDIATE;
...

从警告中，你可以很容易地看到你的错误：

enums.c:5:1: warning: data definition has no type or storage class [enabled by default]
enums.c:5:1: warning: type defaults to ‘int’ in declaration of ‘strategy’ [-Wimplicit-int]
enums.c:5:1: error: conflicting types for ‘strategy’
enums.c:4:36: note: previous declaration of ‘strategy’ was here

所以编译器采取了 strategy = IMMEDIATE 声明一个名为 strategy 的变量，默认类型为 int，但之前已经有一个具有此名称的变量声明。

但是，如果您将赋值放在 main() 函数中，那么它将是有效的代码：

#include <stdio.h>

enum { RANDOM, IMMEDIATE, SEARCH } strategy = IMMEDIATE;

int main(int argc, char** argv){
    strategy=SEARCH;
    printf("strategy: %d\n", strategy);

    return 0;
}

Answer 12

当您说

enum {RANDOM, IMMEDIATE, SEARCH} strategy;

创建一个实例变量时，称为无名枚举的“策略”。 这不是一件非常有用的事情 - 你需要一个 typedef：

typedef enum {RANDOM, IMMEDIATE, SEARCH} StrategyType; 
StrategyType strategy = IMMEDIATE;

Answer 13

正如所写，您的代码没有任何问题。 您确定您没有做过类似

int strategy;
...
enum {RANDOM, IMMEDIATE, SEARCH} strategy;

错误消息指向哪些行？ 当它说“之前的‘战略’声明在这里”时，“这里”是什么，它显示了什么？