C에서 열거 형 (enum)을 정의하는 방법은 무엇입니까?

C 열거 형을 사용하기위한 올바른 구문이 무엇인지 잘 모르겠습니다. 다음 코드가 있습니다.

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

그러나 이것은 다음 오류와 함께 컴파일되지 않습니다.

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

내가 뭘 잘못하고 있죠?

열거 형 변수 선언은 다음과 같이 수행됩니다.

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

그러나 a typedef를 사용하여 다음과 같이 변수 선언을 줄일 수 있습니다 .

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

유형과 변수를 구별하기위한 명명 규칙을 갖는 것이 좋습니다.

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

필요 하지 않음을 지적 할 가치 가 있습니다 typedef. 다음과 같이하면됩니다.

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

당신이 선호하는지 여부는 스타일 질문 typedef입니다. 이것이 없으면 열거 유형을 참조하려면을 사용해야 enum strategy합니다. 그것으로, 당신은 말할 수 있습니다strategy .

두 가지 방법 모두 장단점이 있습니다. 하나는 더 장황하지만 유형 식별자를 일반 식별자와 충돌하지 않는 태그 네임 스페이스에 유지합니다 (생각 struct stat및 stat기능 : 충돌하지 않음). 다른 하나는 짧지 만 형식 식별자를 일반 네임 스페이스로 가져옵니다.

strategy두 번 선언하려고 하면 위의 오류가 발생합니다. 다음은 불만없이 작동합니다 (로 컴파일 됨 gcc -ansi -pendantic -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불리는 변수의 선언을 취 했습니다.strategyint 했지만 이미이 이름을 가진 변수가 이미 선언되었습니다.

그러나 과제를 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;
}

당신이 말할 때

enum {RANDOM, IMMEDIATE, SEARCH} strategy;

이름없는 열거 형의 'strategy'라는 단일 인스턴스 변수를 만듭니다. 이것은 매우 유용한 일이 아닙니다. typedef가 필요합니다.

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

작성된 바와 같이 코드에는 아무런 문제가 없습니다. 다음과 같은 일을하지 않았습니까?

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

오류 메시지는 어떤 줄을 가리 킵니까? "이전의 '전략'선언이 여기에 있었다"고 할 때 "여기"란 무엇이며 무엇을 보여줍니까?

질문에 대한 그의 의견에 @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존재 int와 0값).

당신은 또한 이것을 할 수 있습니다 :

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

그리고 가치 aa가있을 것이다 .int7

enum앞에서 언급했듯이를 사용하여 기호 상수 정의를 반복 할 수 없기 때문에 다음을 사용 하여 intvars 를 선언하려면 태그를 사용해야합니다 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};

언급 할 그것의 가치가 C에서 + + 당신은 타입 정의 문을 필요없이 새로운 유형을 정의하는 "열거"를 사용할 수 있습니다.

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

이 접근법이 훨씬 더 친숙하다는 것을 알았습니다.

[편집-명확한 C ++ 상태-나는 이것을 원래 가지고 있었고 그것을 제거했다!]

선언에 혼란이있는 것 같습니다.

때 strategy앞에 오는 {RANDOM, IMMEDIATE, SEARCH}다음과 같이

enum strategy {RANDOM, IMMEDIATE, SEARCH};

이라는 이름의 새 유형을 작성 중 enum strategy입니다. 그러나 변수를 선언 할 때는 enum strategy자체 를 사용해야 합니다. 당신은 단지 사용할 수 없습니다 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변수 유형으로 자유롭게 사용할 수 있습니다 . enum strategy더 이상 입력 할 필요가 없습니다. 다음은 현재 유효합니다

strategy x = RANDOM;

Typedef와 enum 이름을 결합하여 얻을 수도 있습니다.

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

현재 사용 strategy하고 enum strategyName상호 교환 할 수 있다는 사실 외에는이 방법을 사용하면 큰 이점이 없습니다 .

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

enum strategyName a = RANDOM;
strategy b = SEARCH;

열거 이름을 선언하면 오류가 발생하지 않습니다.

선언되지 않은 경우 다음을 사용해야합니다 typedef.

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

오류가 표시되지 않습니다 ...

내가 가장 좋아하고 사용하는 구성은 항상 다음과 같습니다.

typedef enum MyBestEnum
{
    /* good enough */
    GOOD = 0,
    /* even better */
    BETTER,
    /* divine */
    BEST
};

나는 이것이 당신의 문제를 제거 할 것이라고 믿습니다. 새로운 유형을 사용하는 것은 내 관점에서 올바른 옵션입니다.

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 는 선언 또는 함수 내부에서 설정해야합니다. 전역 범위에서 임의의 소프트웨어 (특히 할당)를 작성할 수 없습니다.

그가 int 대신 enum {RANDOM, IMMEDIATE, SEARCH}을 사용했다는 사실은 그 이상으로 볼 수없는 사람들을 혼란스럽게 한 정도와 관련이 있습니다. 질문의 재정의 오류 메시지는 이것이 저자가 잘못한 것을 보여줍니다.

이제 아래 예제 중 첫 번째 예제가 잘못된 이유와 다른 세 가지 예제가 왜 올바른지 확인할 수 있습니다.

예 1. 잘못된!

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

예 2. RIGHT.

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

예 3. RIGHT.

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

예 4. RIGHT.

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

작업중인 프로그램이있는 경우이 스 니펫을 프로그램에 붙여넣고 일부는 컴파일하고 일부는 그렇지 않은 것을 볼 수 있습니다.

나는 gcc를 사용해 보았고 내 필요에 따라 오류없이 컴파일하기 위해 마지막 대안을 사용해야했습니다.

typedef 열거 형 상태 {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);

씨

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 및 단지 subscope 재정의 될 수 있고, 정의 후에 만 ​​사용 가능). 또한 enum stuff유형 정의 역할을하기 때문에 범위에서 한 번만 전체 유형을 사용할 수 있습니다 .

컴파일러 열거 형 정의 enum stuff는 파일 형식 (앞과 아래에서 사용 가능)과 순방향 형식 선언에도 존재합니다 (유형 enum stuff은 여러 선언을 가질 수 있지만 범위에서 하나의 정의 / 완료 만 가능하며 하위 범위에서 재정의 할 수 있음). . 또한 대체 할 수있는 컴파일러 지시자 역할 ar- 수치와 0, b와 -4, c와 5, d와 -2, e와 -3, f와 -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 

열거 형, 구조체 및 조합에 의해 공유 태그 네임 스페이스는 별도이며, 이후 C, 즉의 유형 키워드 (열거 형, 구조체 또는 조합) 접두어로 지정해야합니다 enum a {a} b, enum a c사용하지되어야합니다 a c. 태그 네임 스페이스는 식별자 네임 스페이스와 별개 enum a {a} b이므로 허용되지만 enum a {a, b} b상수가 변수 식별자 인 식별자 네임 스페이스와 동일한 네임 스페이스에 있기 때문이 아닙니다. typedef enum a {a,b} btypedef-names는 식별자 네임 스페이스의 일부이므로 허용되지 않습니다.

C의 유형 enum bool과 상수는 다음 패턴을 따릅니다.

+--------------+-----+-----+-----+
|   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 |
+-----------+-----+---------------+------+

이것은 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, forward declaration of enum type 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 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
}

열거 형 클래스

enum struct ~와 동일하다 enum class

#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