C'de numaralandırılmış tip (enum) nasıl tanımlanır?

C numaralarını kullanmak için uygun sözdiziminin ne olduğundan emin değilim. Takip koduna sahibim:

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

Ancak bu, aşağıdaki hata ile derlenmez:

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

Neyi yanlış yapıyorum?

Bir enum değişkeninin bildirilmesi şu şekilde yapılır:

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

Ancak, typedefdeğişken bildirimlerini kısaltmak için a'yı kullanabilirsiniz , şöyle:

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

Türleri ve değişkenleri ayırt etmek için bir adlandırma kuralına sahip olmak iyi bir fikirdir:

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

Eğer olmadığını işaret It değerinde ihtiyaç bir typedef. Sadece aşağıdaki gibi yapabilirsiniz

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

Tercih edip etmeyeceğiniz bir stil sorusu typedef. Onsuz, numaralandırma türüne başvurmak istiyorsanız, kullanmanız gerekir enum strategy. Bununla birlikte, sadece söyleyebilirsin strategy.

Her iki yolun da yanlısı ve eksileri vardır. İlki daha gariptir, ancak tür tanımlayıcılarını sıradan tanımlayıcılarla çakışmayacakları etiket ad alanında tutar (düşünün struct statve statişlev: bunlar da çakışmaz) ve bunun bir tür olduğunu hemen gördüğünüz yerde. Diğeri daha kısa, ancak sıradan ad alanına tür tanımlayıcıları getiriyor.

strategyİki kez beyan etmeye çalışıyorsunuz ve bu yüzden yukarıdaki hatayı alıyorsunuz. Aşağıdaki herhangi bir şikayet olmadan çalışır (derlenmiş 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;
}

Yukarıdakiler yerine, ikinci satır şu şekilde değiştirildi:

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

Uyarılardan, hatanızı kolayca görebilirsiniz:

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

Derleyici aldı strategy = IMMEDIATEstrategy varsayılan tip olarak adlandırılan bir değişkenin bildiriminiint , ancak zaten bu ada sahip bir değişkenin önceden bildirimi vardı.

Ancak, atamayı main()işleve yerleştirirseniz, geçerli bir kod olur:

#include <stdio.h>

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

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

    return 0;
}

Dediğinde

enum {RANDOM, IMMEDIATE, SEARCH} strategy;

adsız bir numaralandırmanın 'strateji' olarak adlandırılan tek bir örnek değişkeni oluşturursunuz. Bu çok yararlı bir şey değil - bir typedef'e ihtiyacınız var:

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

Yazıldığı gibi, kodunuzda yanlış bir şey yok. Böyle bir şey yapmadığınızdan emin misiniz?

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

Hata mesajları hangi satırlara işaret ediyor? "Strateji'nin" önceki beyanı buradaydı "derken," burada "nedir ve ne gösterir?

@ThoAppelsin yaptığı soruya yaptığı açıklamada doğru. Soruna gönderilen kod snippet'i geçerli ve hatasız. Sahip olduğunuz hata, c kaynak dosyanızın başka herhangi bir yerindeki diğer kötü sözdizimi nedeniyle olmalıdır. enum{a,b,c};Üç sembolik sabitleri (tanımlar a, bve cdeğerlerle tam sayılardır) 0, 1ve 2sırasıyla, ancak kullanırken enumbiz genellikle belirli tamsayı değeri umurumda değil, çünkü biz sembolik sabiti adının anlamı hakkında daha önem vardır. Bu, aşağıdakilere sahip olabileceğiniz anlamına gelir:

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

ve bu çıktı 1.

Bu da geçerli olacak:

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

ve önceki ile aynı çıktıyı alır.

Eğer bunu yaparsan:

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

bir hata alırsınız, ancak bunu yaparsanız:

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

herhangi bir hatanız olmayacak.

Bunu yapabilirsiniz:

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

ve aadeğeri olan bir tamsayı değişkeni olacaktır 0. ancak bunu da yapabilirsiniz:

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

ve (aynı etkiye sahip olacak aabir varlık intile 0değer).

ayrıca şunları da yapabilirsiniz:

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

ve değeri aaolacak .int7

Eğer kullanımı ile sembolik sabiti tanımını tekrar olamaz çünkü enumben daha önce söylediğimiz gibi, sen bir açıklamadan istiyorsanız, etiketleri kullanmalısınız intkullanımı ile vars enum:

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

bunun kullanımı, değişkeni tanımlamak için typedefher seferinde yazmanıza engel enum tag1olmaktır. İle typedefsadece yazabilirsiniz Tag1:

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

Ayrıca şunları da yapabilirsiniz:

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

Söylemek istediğimiz son şey, tanımlanmış sembolik sabitler hakkında konuştuğumuzdan, kullanırken büyük harf kullanmanın daha iyi enumolduğu, örneğin:

enum {A,B,C};

onun yerine

enum {a,b,c};

C ++ 'da bir typedef deyimine gerek kalmadan yeni bir tür tanımlamak için "enum" kullanabileceğinizi belirtmek gerekir .

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

Bu yaklaşımı çok daha dostane buluyorum.

[edit - netleştirilmiş C ++ durumu - Bunu başlangıçta aldım, sonra kaldırdım!]

Beyan hakkında bir karışıklık var gibi görünüyor.

Daha strategyönce {RANDOM, IMMEDIATE, SEARCH}aşağıdaki gibi geldiğinde ,

enum strategy {RANDOM, IMMEDIATE, SEARCH};

adlı yeni bir tür oluşturuyorsunuz enum strategy. Ancak, değişkeni bildirirken enum strategykendisini kullanmanız gerekir. Sadece kullanamazsın strategy. Bu yüzden aşağıdakiler geçersiz.

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

Ancak, aşağıdakiler geçerlidir

enum strategy {RANDOM, IMMEDIATE, SEARCH};

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

Sonra strategygeldiğinde {RANDOM, IMMEDIATE, SEARCH}, anonim bir numara oluşturuyor ve daha sonrastrategy bu tür bir değişken olduğunu bildiriyorsunuz.

Şimdi, böyle bir şey yapabilirsiniz

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

Ancak, enum {RANDOM, IMMEDIATE, SEARCH}daha önce adlandırmamış olduğunuz için başka bir tür değişkeni bildiremezsiniz . Yani aşağıdakiler geçersiz

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

Her iki tanımı da birleştirebilirsiniz

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

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

Typedef daha önce belirtildiği gibi daha kısa bir değişken bildirimi oluşturmak için kullanılır.

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy;

Şimdi derleyiciye enum {RANDOM, IMMEDIATE, SEARCH}sinonomik olduğunu söylediniz strategy. Artık strategydeğişken tip olarak özgürce kullanabilirsiniz . Artık yazmanıza gerek enum strategyyok. Aşağıdakiler şu anda geçerlidir

strategy x = RANDOM;

Ayrıca Typedef'i ve numaralandırma adıyla birleştirebilirsiniz.

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

Bu yöntemi şimdi strategyve enum strategyNamebirbirinin yerine kullanabilmeniz dışında kullanmanın pek bir avantajı yoktur .

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

enum strategyName a = RANDOM;
strategy b = SEARCH;

Numaralandırma adını bildirirseniz hata oluşmaz.

Bildirilmezse, aşağıdakileri kullanmanız gerekir typedef:

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

Bir hata göstermez ...

En sevdiğim ve sadece kullanılan inşaat her zaman:

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

Bunun sahip olduğunuz sorununuzu çözeceğine inanıyorum. Yeni tip kullanmak benim açımdan doğru seçeneğidir.

Tarc'ın cevabı en iyisidir.

Enum tartışmasının çoğu kırmızı bir ringa balığıdır.

Bu kod snippet'ini karşılaştırın: -

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

hangi verir

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

sorunsuz derleyen bu ile.

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

Değişken strategy bildirimde veya bir işlev vb. İçinde ayarlanması gerekir. Genel kapsamda rasgele yazılım - özellikle atamalar - yazamazsınız.

İnt yerine enum {RANDOM, IMMEDIATE, SEARCH} kullanması, yalnızca ötesini göremeyen insanları şaşırtmasıyla ilgilidir. Sorudaki yeniden tanımlama hata mesajları, yazarın yanlış yaptığı şeyin bu olduğunu gösterir.

Şimdi, aşağıdaki örnekten ilkinin neden yanlış, diğer üçünün de iyi olduğunu görebilmelisiniz.

Örnek 1. YANLIŞ!

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

Örnek 2. SAĞ.

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

Örnek 3. SAĞ.

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

Örnek 4. SAĞ.

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

Çalışan bir programınız varsa, bu parçacıkları programınıza yapıştırabilmeniz ve bazılarının derlediğini ve bazılarının yapmadığını görebilirsiniz.

Ben gcc ile denedim ve benim ihtiyaç için gelip ben hata ile derlemek için son alternatifi kullanmak zorunda kaldı.

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

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;

sTam tipte imzalı tamsayı için geçici bir tanım olarak hareket eden beyan qve kapsamda eksik tipte imzalı tamsayı için geçici bir tanım olarak hareket eden beyan (tip tanımı, kapsam) (herhangi bir belirsiz tanım gibi, tanımlayıcılar qve saynı türdeki eksik veya tam sürümle intveya enum stuffbirden çok kez yeniden tanımlanabilir, ancak kapsamda yalnızca bir kez tanımlanabilir yani int q = 3; ve yalnızca bir alt kapsamda yeniden tanımlanabilir ve yalnızca tanımdan sonra kullanılabilir). Ayrıca enum stuff, bir tür tanımı olarak hareket ettiğinden, kapsamda yalnızca bir kez tam türü kullanabilirsiniz .

Bir derleyici numaralandırma türü tanımı enum stuffda dosya kapsamında (öncesinde ve altında kullanılabilir) ve ileri tür bildiriminde (türün enum stuffbirden çok bildirimi olabilir, ancak kapsamda yalnızca bir tanım / tamamlanma olabilir ve bir alt kapsamda yeniden tanımlanabilir) . Ayrıca yerine bir derleyici yönergesi olarak hareket arvalue ile 0, bile -4, cile 5, dile -2, eile -3, file -1ve gile -2geçerli kapsam içinde. Numaralandırma sabitleri artık tanımdan sonra, aynı kapsam düzeyinde bulunamayan farklı bir numarada bir sonraki yeniden tanımlamaya kadar uygulanır.

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 ve birlik tarafından paylaşılan etiket ad ayrıdır ve sonra C yani yazın anahtar kelime (enum, struct ya birlik) eklenmeli enum a {a} b, enum a ckullanılan ve kullanılması gerektiğini a c. Etiket ad alanı, tanımlayıcı ad alanından ayrı olduğu için enum a {a} bizin verilir ancak enum a {a, b} bsabitler, değişken tanımlayıcıları, tanımlayıcı ad alanı ile aynı ad alanında olduğundan dolayı değildir.typedef enum a {a,b} btypedef-names, tanımlayıcı ad alanının bir parçası olduğu için de izin verilmez.

enum boolC tipi ve sabitleri C'de aşağıdaki paterni izler:

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

Bu C de iyi derler:

#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 ++ 'da numaralandırmaların bir türü olabilir

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

Bu durumda, sabitler ve tanımlayıcıların tümü aynı türe, boole sahiptir ve bir sayı bu türle temsil edilemezse bir hata oluşur. Belki = 2, bu bir bool değil. Ayrıca, True, False ve Bool küçük harf olamaz, aksi takdirde dil anahtar sözcükleriyle çakışırlar. Bir numaralandırma ayrıca bir işaretçi türüne sahip olamaz.

C ++ kurallarında numaralandırma kuralları farklıdır.

#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 ++ 'daki numaralandırma değişkenleri artık yalnızca işaretsiz tamsayılar vb. Değildir, ayrıca numaralandırma türündedir ve yalnızca numaralandırmada sabitler atanabilir. Ancak bu atılabilir.

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

Numaralandırma sınıfları

enum struct ile aynı 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
}

Kapsam çözümleme operatörü, kapsamı olmayan numaralandırmalar için hala kullanılabilir.

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

Ancak w, kapsamda başka bir şey olarak tanımlanamayacağı için, ::wve arasında bir fark yoktur.::a::w