Starkt typade uppräkningar i C ++ - dummies

Programmering handlar om läsbarhet. Det är svårt (faktiskt det är omöjligt) att skriva och underhålla ett program som du inte kan läsa. En del av att läsa en källkodslista är att förstå vad siffrorna som används i programmet representerar. Det mest grundläggande hjälp som C ++ ger är den allestädes närvarande #definen, som i följande ofta citerade exempel:

#define PI 3. 141592653589793

Den här lösningen är okej för individuella värden, även om det lider av det faktum att #define mekanism är inte (strängt) en del av C / C ++ eftersom preprocessorn körs före kompilatorn. Som svar på detta införde C ++ 2011 ett konstant uttryck konstruktion:

constexpr lång dubbel PI = 3. 141592653589793;

Constexpr-nyckelordet leder konstanter till C ++-tältet. Denna PI har en riktig typ, som andra C ++-variabler. C ++ kan generera felmeddelanden med PI som ger mycket mer mening än de som gäller 3. 14159.

Konstant uttryck är bra för individuella konstanta värden, men ofta utgör konstanter uppsättningar av saker snarare än naturliga konstanter, som i följande exempel:

#define DC_OR_TERRITORY 0 #define ALABAMA 1 #define ALASKA 2 #define ARKANSAS 3 // … och så vidare …

Förmodligen används dessa konstanter för att identifiera de stater som kanske används som ett index till en grupp statobjekt eller som ett värde i en databas någonstans.

C ++ har länge haft en förbättrad mekanism för att definiera dessa typer av konstanter - uppräkningen:

enum STATE {DC_OR_TERRITORY, // får 0 ALABAMA, // får 1 ALASKA, // får 2 ARKANSAS, // … och så vidare…};

Enum-sökordet introducerar en sekvens av konstanter som kallas en "uppräkning". I detta fall bär uppräkningen namnet STATE. Varje element i denna uppräkning har tilldelats ett värde som börjar vid 0 och ökar successivt med 1, så DC_OR_TERRITORY definieras som 0, ALABAMA definieras som 1, och så vidare. Du kan åsidosätta denna inkrementella sekvensering genom att använda en tilldelningsdeklaration enligt följande:

enum STATE {DC, TERRITORY = 0, ALABAMA, ALASKA, // … och så vidare …};

Den här versionen av STATE definierar ett element DC som får värdet 0. Det definierar sedan ett nytt element TERRITORY, vilket också tilldelas värdet 0. ALABAMA plockar upp med 1, precis som tidigare.

I praktiken kan programmeraren använda uppräkningar för att skriva ganska läsbar kod som följande:

double taxRate (STATE s) {return tax ratesByState [s];}

Det enda problemet med detta tillvägagångssätt är att denna uppräkning skapar inte en ny typ (som du kanske tror).Faktum är att enligt standarden är STATE bara ett annat namn för int - och konstanterna ALABAMA, ALASKA och så vidare är alla typ const int.

Gcc-kompilatorn ger faktiskt en enum deklarerad på detta sätt lite mer myndighet än att bara kalla det en annan form av int. Du kan faktiskt överbelasta funktioner baserat på en enumtyp:

void fn (STATE s); void fn (int n); fn (ALASKA); // påstår fn (STATE)

Med 2011-standarden kan programmeraren skapa en helt ny typ med enum-nyckelordet. Eftersom skaparna av den nya standarden inte vill bryta befintlig kod kräver standarden att ett extra nyckelord läggs till för att definiera en uppräkningstyp, som i följande exempel:

enum klass STATE {DC, TERRITORY = 0, ALABAMA, ALASKA, // … och så vidare …};

En uppräkningsklass är nu en fullskalig typ som någon annan användardefinierad klass. Följande är inte ens laglig av två skäl:

int s = ALASKA;

Först definieras den konstanta ALASKA endast inom STATE namespace. Således är konstantens namn STATE:: ALASKA. För det andra är typen inte int men STATE. Du kan inte tilldela ett värde av typ STATE till en int.

STATE s = STATE:: ALASKA;

Programmeraren kan omforma en STATE till en int men hon måste göra det explicit. -implikat omvandlingar klipp inte det med uppräkningsklasser:

int n = (int) STAT:: ALASKA;

Denna nya enumtyp kan också baseras på en av de andra räkningstypen förutom bara int:

enum klass STATE: char {DC, // … återstoden av deklarationen är densamma