C Language => uppräkningar

Anmärkningar

Uppräkningar består av nyckelordet enum och en valfri identifierare följt av en lista över listor som är bifogade av hängslen.

En identifierare är av typen int .

Uppräknarlistan har minst ett tellerelement .

En teller kan valfritt "tilldelas" ett konstant uttryck av typ int .

En teller är konstant och är kompatibel med antingen ett char , ett signerat heltal eller ett osignerat heltal. Som någonsin används är implementeringsdefinerat . I vilket fall som helst bör den använda typen kunna representera alla värden som definierats för beräkningen i fråga.

Om ingen konstant uttryck "tilldelas" en uppräknaren och det är ^{1: a} posten i en enumerator-lista tar det värde på 0 , annars får tar värdet av den tidigare post i uppräknaren listan plus ett.

Att använda flera "uppdrag" kan leda till att olika uppräknare av samma uppräkning har samma värden.

Enkel uppräkning

En uppräkning är en användardefinierad datatyp som består av integrerade konstanter och varje integralkonstant ges ett namn. Nyckelord enum används för att definiera uppräknade datatyp.

Om du använder enum istället för int eller string/ char* ökar du kompileringstidskontrollen och undviker att fel passerar i ogiltiga konstanter och du dokumenterar vilka värden som är lagliga att använda.

Exempel 1

enum color{ RED, GREEN, BLUE };

void printColor(enum color chosenColor)
{
    const char *color_name = "Invalid color";
    switch (chosenColor)
    {
       case RED:
         color_name = "RED";
         break;
       
       case GREEN:
        color_name = "GREEN";
        break;    

       case BLUE:
        color_name = "BLUE";
        break;
    }
    printf("%s\n", color_name);
}

Med en huvudfunktion definierad enligt följande (till exempel):

int main(){
    enum color chosenColor;
    printf("Enter a number between 0 and 2");
    scanf("%d", (int*)&chosenColor);
    printColor(chosenColor);
    return 0;
}

C99

Exempel 2

^{(Det här exemplet använder designerade initialisatorer som är standardiserade sedan C99.)}

enum week{ MON, TUE, WED, THU, FRI, SAT, SUN };
     
static const char* const dow[] = { 
  [MON] = "Mon", [TUE] = "Tue", [WED] = "Wed", 
  [THU] = "Thu", [FRI] = "Fri", [SAT] = "Sat", [SUN] = "Sun" };
    
void printDayOfWeek(enum week day) 
{ 
   printf("%s\n", dow[day]);
}

Samma exempel med intervallkontroll:

enum week{ DOW_INVALID = -1, 
  MON, TUE, WED, THU, FRI, SAT, SUN, 
  DOW_MAX };
     
static const char* const dow[] = { 
  [MON] = "Mon", [TUE] = "Tue", [WED] = "Wed", 
  [THU] = "Thu", [FRI] = "Fri", [SAT] = "Sat", [SUN] = "Sun" };
    
void printDayOfWeek(enum week day) 
{ 
   assert(day > DOW_INVALID && day < DOW_MAX);
   printf("%s\n", dow[day]);
}

Typedef enum

Det finns flera möjligheter och konventioner för att namnge en uppräkning. Den första är att använda ett taggnamn strax efter enum nyckelordet.

enum color
{ 
    RED, 
    GREEN, 
    BLUE 
};

Denna uppräkning måste då alltid användas med sökordet och taggen så här:

enum color chosenColor = RED;

Om vi använder typedef direkt när vi deklarerar enum , kan vi utelämna taggen och sedan använda typen utan enum nyckelordet:

typedef enum 
{ 
    RED, 
    GREEN, 
    BLUE 
} color;

color chosenColor = RED;

Men i det senare fallet kan vi inte använda det som enum color , eftersom vi inte använde taggnamnet i definitionen. En vanlig konvention är att använda båda, så att samma namn kan användas med eller utan enum nyckelord. Detta har den speciella fördelen att vara kompatibel med C ++

enum color                /* as in the first example */
{ 
    RED, 
    GREEN, 
    BLUE 
};
typedef enum color color; /* also a typedef of same identifier */

color chosenColor  = RED;
enum color defaultColor = BLUE;

Fungera:

void printColor()
{
    if (chosenColor == RED)
    {
        printf("RED\n");
    }
    else if (chosenColor == GREEN)
    {
        printf("GREEN\n");    
    }
    else if (chosenColor == BLUE)
    {
        printf("BLUE\n");
    }
}

typedef information om typedef finns i Typedef

Uppräkning med duplicerat värde

Ett uppräkningsvärde behöver inte vara unikt:

#include <stdlib.h> /* for EXIT_SUCCESS */
#include <stdio.h> /* for printf() */


enum Dupes
{
   Base, /* Takes 0 */
   One, /* Takes Base + 1 */
   Two, /* Takes One + 1 */
   Negative = -1,
   AnotherZero /* Takes Negative + 1 == 0, sigh */
};

int main(void)
{
  printf("Base = %d\n", Base);
  printf("One = %d\n", One);
  printf("Two = %d\n", Two);
  printf("Negative = %d\n", Negative);
  printf("AnotherZero = %d\n", AnotherZero);

  return EXIT_SUCCESS;
}

Exemplet skriver ut:

Base = 0
One = 1
Two = 2
Negative = -1
AnotherZero = 0

uppräkningskonstant utan typnamn

Uppräkningstyper kan också deklareras utan att ge dem ett namn:

  enum { buffersize = 256, };
  static unsigned char buffer [buffersize] = { 0 };

Detta gör det möjligt för oss att definiera kompileringstidskonstanter av typ int som kan som i detta exempel användas som array-längd.

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

C Language
uppräkningar

Sök…