Sterkt Typed Enumerations i C ++ - dummies

Programmering handler om lesbarhet. Det er vanskelig (faktisk det er umulig) å skrive og vedlikeholde et program som du ikke kan lese. En del av å lese en kildekodeoppføring er å forstå hva tallene som brukes i programmet representerer. Den mest grunnleggende hjelpen som C ++ gir, er den allestedsnærværende #definen, som i følgende ofte omtalte eksempel:

#define PI 3. 141592653589793

Denne løsningen er greit for individuelle verdier, selv om det lider av at #define mekanismen er ikke (strengt tatt) en del av C / C ++ siden preprosessoren kjører før kompilatoren. Som svar på dette introduserte C ++ 2011 et konstant uttrykk konstruksjon:

constexpr lang dobbel PI = 3. 141592653589793;

Constexpr-nøkkelordet bringer konstanter inn i C ++-teltet. Denne PI har en ekte type, som andre C ++-variabler. C ++ kan generere feilmeldinger med PI som gir mye mer mening enn de som involverer 3. 14159.

Konstantuttrykk er bra for individuelle konstante verdier, men ofte representerer konstanter sett av ting i stedet for naturlige konstanter, som i følgende eksempel:

#define DC_OR_TERRITORY 0 #define ALABAMA 1 #define ALASKA 2 #define ARKANSAS 3 // … og så videre …

Formentlig blir disse konstantene brukt til å identifisere statene som kanskje brukes som en indeks i en rekke statobjekter eller som en verdi i en database et sted.

C ++ har lenge hatt en forbedret mekanisme for å definere disse typer konstanter - oppregningen:

enum STATE {DC_OR_TERRITORY, // blir 0 ALABAMA, // får 1 ALASKA, // får 2 ARKANSAS, // … og så videre …};

Enum-nøkkelordet introduserer en sekvens av konstanter kalt en "oppsummering". I dette tilfellet bærer tallet navnet STATE. Hvert element i denne oppstillingen er tilordnet en verdi som starter ved 0 og øker sekvensielt med 1, slik at DC_OR_TERRITORY er definert som 0, ALABAMA er definert som 1, og så videre. Du kan overstyre denne inkrementelle sekvenseringen ved å bruke en tilordnet setning som følger:

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

Denne versjonen av STATE definerer et element DC, som er gitt verdien 0. Den definerer deretter et nytt element TERRITORY, som også tildeles verdien 0. ALABAMA plukker opp med 1, som før.

I praksis kan programmereren bruke tall for å skrive ganske lesbar kode som følgende:

double taxRate (STATS s) {return tax RatesByState [s];}

Det eneste problemet med denne tilnærmingen er at denne oppsummeringen Oppretter ikke en ny type (som du kanskje tror).Faktisk, ifølge standarden er STATE bare et annet navn for int - og konstantene ALABAMA, ALASKA, og så videre, er alle type const int.

Gcc-kompilatoren gir faktisk en enum deklarert på denne måten litt mer autoritet enn bare å kalle det en annen form for int. Du kan faktisk overbelaste funksjoner basert på en enum type:

void fn (STATE s); void fn (int n); fn (Alaska); // påberoper fn (STATE)

2011-standarden lar programmereren lage en helt ny type ved hjelp av enum-søkeordet. Siden skaperne av den nye standarden ikke ville bryte eksisterende kode, krever standarden tillegg av et ekstra søkeord for å definere en opptellingstype, som i følgende eksempel:

enum klasse STATE {DC, TERRITORY = 0, ALABAMA, ALASKA, // … og så videre …};

En opptellingsklasse er nå en fullskala type som enhver annen brukerdefinert klasse. Følgende er ikke engang lovlig lenger av to grunner:

int s = ALASKA;

Først er den konstante ALASKA bare definert innenfor STATE namespace. Dermed er konstantens navn STATE:: ALASKA. For det andre er typen ikke int men STATE. Du kan ikke tildele en verdi av typen STATE til en int.

STATE s = STATE:: ALASKA;

Programmøren kan omstille en STAT til en int, men hun må gjøre det eksplisitt. Forenkler konverteringer ikke kuttet med opptellingsklasser:

int n = (int) STAT:: ALASKA;

Denne nye enumtypen kan også baseres på en av de andre talltypene i tillegg til bare int:

enum klasse STATE: char {DC, // … resten av erklæringen er den samme