C-uppräkningsdeklarationer

En uppräkning består av en uppsättning namngivna heltalskonstanter. En uppräkningstypdeklaration ger namnet på (valfri) uppräkningstagg. Och den definierar uppsättningen med namngivna heltalsidentifierare (kallas uppräkningsuppsättningen, uppräkningskonstanter, uppräknare eller medlemmar). En variabel av uppräkningstypen lagrar ett av värdena i uppräkningsuppsättningen som definierats av den typen.

Variabler av enum typen kan användas i indexeringsuttryck och som operander för alla aritmetiska operatorer och relationsoperatorer. Uppräkningar är ett alternativ till #define förprocessordirektivet med fördelarna med att värdena kan genereras åt dig och följa normala omfångsregler.

I ANSI C har int de uttryck som definierar värdet för en uppräkningskonstant alltid typ. Det innebär att lagringen som är associerad med en uppräkningsvariabel är den lagring som krävs för ett enda int värde. En uppräkningskonstant eller ett värde av uppräkningstyp kan användas var som helst där C-språket tillåter ett heltalsuttryck.

Syntax

enum-specifier:
  enum identifier _välja{enumerator-list}
  enum identifier

enumerator-list:
 enumerator
  enumerator-list , enumerator

enumerator:
 enumeration-constant
  enumeration-constant = constant-expression

enumeration-constant:
 identifier

De valfria identifier namnen på uppräkningstypen som definieras av enumerator-list. Den här identifieraren kallas ofta "taggen" för den uppräkning som anges i listan. En typspecificerare deklarerar identifier som taggen för den uppräkning som anges av den enumerator-list icke-terminala, enligt följande:

enum identifier
{
    // enumerator-list
}

enumerator-list Definierar medlemmarna i uppräkningsuppsättningen.

Om deklarationen av en tagg visas anger senare deklarationer som använder taggen men utelämnar enumerator-list den tidigare deklarerade uppräkningstypen. Taggen måste referera till en definierad uppräkningstyp och den uppräkningstypen måste finnas i det aktuella omfånget. Eftersom uppräkningstypen definieras någon annanstans enumerator-list visas inte den i den här deklarationen. Deklarationer av typer som härleds från uppräkningar och typedef deklarationer för uppräkningstyper kan använda uppräkningstaggen innan uppräkningstypen definieras.

Var enumeration-constant och en i en enumerator-list namnger ett värde för uppräkningsuppsättningen. Som standard associeras den första enumeration-constant med värdet 0. Nästa enumeration-constant i listan är associerad med värdet ( constant-expression + 1 ), såvida du inte uttryckligen associerar den med ett annat värde. Namnet på en enumeration-constant motsvarar dess värde.

Du kan använda enumeration-constant = constant-expression för att åsidosätta standardsekvensen med värden. Om det visas i enumeration-constantenumerator-listär det associerat med värdet som anges av constant-expression.enumeration-constant = constant-expression Måste constant-expression ha int typen och kan vara negativ.

Följande regler gäller för medlemmarna i en uppräkningsuppsättning:

• En uppräkningsuppsättning kan innehålla dubbletter av konstanta värden. Du kan till exempel associera värdet 0 med två olika identifierare, till exempel medlemmar med namnet null och zero, i samma uppsättning.

• Identifierarna i uppräkningslistan måste skilja sig från andra identifierare i samma omfång med samma synlighet. Det inkluderar vanliga variabelnamn och identifierare i andra uppräkningslistor.

• Uppräkningstaggar följer de normala omfångsreglerna. De måste skilja sig från andra uppräknings-, struktur- och unionstaggar med samma synlighet.

Exempel

De här exemplen illustrerar uppräkningsdeklarationer:

enum DAY            /* Defines an enumeration type    */
{
    saturday,       /* Names day and declares a       */
    sunday = 0,     /* variable named workday with    */
    monday,         /* that type                      */
    tuesday,
    wednesday,      /* wednesday is associated with 3 */
    thursday,
    friday
} workday;

Värdet 0 är associerat med saturday som standard. Identifieraren sunday är uttryckligen inställd på 0. De återstående identifierarna anges som standard värdena 1 till 5.

I det här exemplet tilldelas ett värde från uppsättningen DAY till variabeln today.

enum DAY today = wednesday;

Namnet på uppräkningskonstanten används för att tilldela värdet. DAY Eftersom uppräkningstypen tidigare har deklarerats är det bara uppräkningstaggen DAY som krävs.

Om du uttryckligen vill tilldela ett heltalsvärde till en variabel av en uppräknad datatyp använder du en typkonvertering:

workday = ( enum DAY ) ( day_value - 1 );

Den här casten rekommenderas i C men krävs inte.

enum BOOLEAN  /* Declares an enumeration data type called BOOLEAN */
{
    false,     /* false = 0, true = 1 */
    true
};

enum BOOLEAN end_flag, match_flag; /* Two variables of type BOOLEAN */

Den här deklarationen kan också anges som

enum BOOLEAN { false, true } end_flag, match_flag;

eller som

enum BOOLEAN { false, true } end_flag;
enum BOOLEAN match_flag;

Ett exempel som använder dessa variabler kan se ut så här:

if ( match_flag == false )
    {
     .
     .   /* statement */
     .
    }
    end_flag = true;

Namnlösa uppräkningsdatatyper kan också deklareras. Namnet på datatypen utelämnas, men variabler kan deklareras. Variabeln response är en variabel av den typ som definierats:

enum { yes, no } response;

Se även

Uppräkningar(C++)