Come definire un tipo enumerato (enum) in C?

Non sono sicuro di quale sia la sintassi corretta per usare C enum. Ho il codice seguente:

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

Ma questo non viene compilato, con il seguente errore:

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

Che cosa sto facendo di sbagliato?

La dichiarazione di una variabile enum viene eseguita in questo modo:

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

Tuttavia, è possibile utilizzare a typedefper abbreviare le dichiarazioni delle variabili, in questo modo:

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

Avere una convenzione di denominazione per distinguere tra tipi e variabili è una buona idea:

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

Vale la pena sottolineare che non è necessario un typedef. Puoi semplicemente farlo come segue

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

È una domanda di stile se preferisci typedef. Senza di essa, se si desidera fare riferimento al tipo di enumerazione, è necessario utilizzare enum strategy. Con esso, puoi solo direstrategy .

Entrambi i modi hanno i loro pro e contro. L'uno è più prolisso, ma mantiene gli identificatori di tipo nello spazio dei nomi dei tag in cui non entreranno in conflitto con gli identificatori ordinari (pensate struct state la statfunzione: neanche questi sono in conflitto) e dove vedrete immediatamente che si tratta di un tipo. L'altro è più corto, ma porta gli identificatori di tipo nello spazio dei nomi ordinario.

Stai provando a dichiarare strategydue volte ed è per questo che stai ricevendo l'errore sopra. Di seguito funziona senza alcun reclamo (compilato con 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;
}

Se invece di quanto sopra, la seconda riga è stata cambiata in:

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

Dagli avvisi, potresti facilmente vedere il tuo errore:

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

Quindi il compilatore ha preso strategy = IMMEDIATEuna dichiarazione di una variabile chiamata strategycon il tipo predefinitoint , ma c'era già una precedente dichiarazione di una variabile con questo nome.

Tuttavia, se si inserisce l'assegnazione nella main()funzione, sarebbe un codice valido:

#include <stdio.h>

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

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

    return 0;
}

Quando dici

enum {RANDOM, IMMEDIATE, SEARCH} strategy;

crei una variabile di istanza singola, chiamata "strategia" di un enum senza nome. Questa non è una cosa molto utile da fare: hai bisogno di un typedef:

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

Come scritto, non c'è niente di sbagliato nel tuo codice. Sei sicuro di non aver fatto qualcosa del genere

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

A quali righe indicano i messaggi di errore? Quando dice che "la precedente dichiarazione di" strategia "era qui", cosa c'è "qui" e cosa mostra?

@ThoAppelsin nel suo commento alla domanda postata è giusto. Lo snippet di codice pubblicato nella domanda è valido e senza errori. L'errore che hai deve essere dovuto a un'altra sintassi errata in qualsiasi altra posizione del file sorgente c. enum{a,b,c};definisce tre costanti simboliche ( a, be c) che sono interi con valori 0, 1e 2rispettivamente, ma quando usiamo enumè perché di solito non cuore il valore intero specifico, ci interessa più circa il significato del nome costante simbolica. Questo significa che puoi avere questo:

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

e questo produrrà 1 .

Anche questo sarà valido:

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

e produrrà lo stesso di prima.

Se lo fai:

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

avrai un errore, ma se lo fai:

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

non avrai nessun errore.

Puoi farlo:

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

e aasarà una variabile intera con valore 0. ma puoi anche fare questo:

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

e avrà lo stesso effetto (cioè aaessere intcon0 valore).

puoi anche fare questo:

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

e aasarà intcon valore7 .

poiché non è possibile ripetere la definizione costante simbolica con l'uso di enum, come ho già detto in precedenza, è necessario utilizzare i tag se si desidera dichiarare intvars con l'uso di enum:

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

il suo uso typedefè per impedirti di scrivere ogni volta enum tag1per definire la variabile. Con typedefte puoi semplicemente digitare Tag1:

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

Puoi anche avere:

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

L'ultima cosa da dire è che, dal momento che stiamo parlando di costanti simboliche definite, è meglio usare lettere maiuscole durante l'uso enum, ad esempio:

enum {A,B,C};

invece di

enum {a,b,c};

Vale la pena ricordare che in C ++ è possibile utilizzare "enum" per definire un nuovo tipo senza bisogno di un'istruzione typedef.

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

Trovo questo approccio molto più amichevole.

[modifica - chiarito lo stato C ++ - L'ho avuto in origine, quindi rimosso!]

Sembra esserci una confusione sulla dichiarazione.

Quando strategyviene prima {RANDOM, IMMEDIATE, SEARCH}come nel seguito,

enum strategy {RANDOM, IMMEDIATE, SEARCH};

stai creando un nuovo tipo chiamato enum strategy. Tuttavia, quando si dichiara la variabile, è necessario utilizzare enum strategyse stesso. Non puoi semplicemente usare strategy. Quindi quanto segue non è valido.

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

Mentre, quanto segue è valido

enum strategy {RANDOM, IMMEDIATE, SEARCH};

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

Quando strategyviene dopo {RANDOM, IMMEDIATE, SEARCH}, stai creando un enum anonimo e poi dichiaristrategy di essere una variabile di quel tipo.

Quindi ora puoi fare qualcosa del genere

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

Tuttavia, non è possibile dichiarare qualsiasi altra variabile di tipo enum {RANDOM, IMMEDIATE, SEARCH}perché non l'hai mai nominata. Quindi quanto segue non è valido

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

Puoi anche combinare entrambe le definizioni

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

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

Typedef come notato prima, viene utilizzato per creare una dichiarazione variabile più breve.

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy;

Ora hai detto al compilatore che enum {RANDOM, IMMEDIATE, SEARCH}è sinonimo di strategy. Quindi ora puoi usare liberamente strategycome tipo variabile. Non è più necessario digitare enum strategy. Quanto segue è valido ora

strategy x = RANDOM;

Puoi anche combinare Typedef con il nome enum per ottenere

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

Non c'è molto vantaggio nell'utilizzare questo metodo a parte il fatto che ora puoi usare strategye in modo enum strategyNameintercambiabile.

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

enum strategyName a = RANDOM;
strategy b = SEARCH;

Se si dichiara il nome per l'enumerazione, non si verificherà alcun errore.

Se non dichiarato, è necessario utilizzare un typedef:

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

Non visualizzerà un errore ...

La mia costruzione preferita e solo usata è sempre stata:

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

Credo che questo eliminerà il tuo problema. L'uso del nuovo tipo è dal mio punto di vista l'opzione giusta.

La risposta di Tarc è la migliore.

Gran parte della discussione sull'enum è un'aringa rossa.

Confronta questo frammento di codice: -

int strategy;
strategy = 1;   
void some_function(void) 
{
}

che dà

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

con questo che si compila senza problemi.

int strategy;
void some_function(void) 
{
    strategy = 1;   
}

La variabile strategy deve essere impostata al momento della dichiarazione o all'interno di una funzione, ecc. Non è possibile scrivere software arbitrario - incarichi in particolare - nell'ambito globale.

Il fatto che abbia usato enum {RANDOM, IMMEDIATE, SEARCH} invece di int è rilevante solo nella misura in cui ha confuso persone che non possono vedere al di là di esso. I messaggi di errore di ridefinizione nella domanda mostrano che questo è ciò che l'autore ha fatto di sbagliato.

Quindi ora dovresti essere in grado di capire perché il primo esempio di seguito è sbagliato e gli altri tre sono a posto.

Esempio 1. SBAGLIATO!

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

Esempio 2. DESTRA.

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

Esempio 3. DESTRA.

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

Esempio 4. DESTRA.

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

Se hai un programma funzionante dovresti essere in grado di incollare questi snippet nel tuo programma e vedere che alcuni compilano e altri no.

Ho provato con gcc e ho pensato che per le mie necessità ero costretto a usare l'ultima alternativa, per compilare senza errori.

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

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);

C

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

Dichiarazione che funge da definizione provvisoria di un numero intero scon segno con tipo completo e dichiarazione che funge da definizione provvisoria di numero intero qcon segno con tipo incompleto nell'ambito (che si risolve al tipo completo nell'ambito poiché la definizione del tipo è presente ovunque nel ambito) (come qualsiasi definizione provvisoria, gli identificatori qe spossono essere ridecressi con la versione incompleta o completa dello stesso tipo into enum stuffpiù volte ma definiti una sola volta nell'ambito nell'ambito cioè int q = 3; e possono essere ridefiniti solo in un sottoscope e utilizzabile solo dopo la definizione). Inoltre è possibile utilizzare solo il tipo completo dienum stuff una sola volta nell'ambito poiché funge da definizione del tipo.

Una definizione del tipo di enumerazione del compilatore enum stuffè resa presente anche nell'ambito del file (utilizzabile prima e sotto) e una dichiarazione del tipo forward (il tipo enum stuffpuò avere più dichiarazioni ma solo una definizione / completamento nell'ambito e può essere ridefinito in un sottoscope) . Funge anche da direttiva del compilatore per sostituire acon rvalue 0, bcon -4, ccon 5, dcon -2, econ -3, fcon -1e gcon -2nell'ambito attuale. Le costanti di enumerazione ora si applicano dopo la definizione fino alla ridefinizione successiva in un enum diverso che non può essere sullo stesso livello di ambito.

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 

Lo spazio dei nomi dei tag condiviso da enum, struct e union è separato e deve essere preceduto dalla parola chiave type (enum, struct o union) in C, ovvero dopo enum a {a} b, enum a cdeve essere utilizzato e non a c. Poiché lo spazio dei nomi dei tag è separato dallo spazio dei nomi dell'identificatore, enum a {a} bè consentito ma enum a {a, b} bnon perché le costanti si trovano nello stesso spazio dei nomi degli identificatori delle variabili, lo spazio dei nomi dell'identificatore.typedef enum a {a,b} binoltre non è consentito perché i nomi typedef fanno parte dello spazio dei nomi identificativo.

Il tipo di enum boole le costanti seguono il seguente modello in 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 |
+-----------+-----+---------------+------+

Questo si compila bene in 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 ++

In C ++, gli enum possono avere un tipo

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

In questa situazione, le costanti e l'identificatore hanno tutti lo stesso tipo, valore booleano e si verificherà un errore se un numero non può essere rappresentato da quel tipo. Forse = 2, che non è un bool. Inoltre, True, False e Bool non possono essere minuscoli, altrimenti si scontreranno con le parole chiave del linguaggio. Un enum inoltre non può avere un tipo di puntatore.

Le regole per enum sono diverse in 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;
}

Le variabili Enum in C ++ non sono più solo numeri interi senza segno, ecc., Ma sono anche di tipo enum e possono essere assegnate solo costanti nell'enum. Questo può comunque essere gettato via.

#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
}

Classi Enum

enum struct è identico a 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
}

L'operatore di risoluzione dell'ambito può ancora essere utilizzato per enumerazioni senza ambito.

#include <stdio.h>
enum a: bool {l, w} ;
int main() {
  enum a: bool {w, l} f;
  printf("%llu", ::a::w);
}

Ma poiché w non può essere definito come qualcos'altro nell'ambito, non vi è alcuna differenza tra ::we::a::w