Sterk getypte opsommingen in C ++ - dummies

Programmeren heeft alles te maken met de leesbaarheid. Het is moeilijk (eigenlijk is het onmogelijk) om een ​​programma te schrijven en te onderhouden dat je niet kunt lezen. Een deel van het lezen van een broncode-lijst is een goed begrip van wat de getallen in het programma voorstellen. Het meest basale hulpmiddel dat C ++ biedt, is de alomtegenwoordige #define, zoals in het volgende oft-aangehaalde voorbeeld:

#define PI 3. 141592653589793

Deze oplossing is geschikt voor individuele waarden, hoewel het lijdt onder het feit dat de #define-mechanisme is (strikt genomen) geen onderdeel van C / C ++ omdat de preprocessor vóór de compiler wordt uitgevoerd. Als reactie hierop heeft C ++ 2011 een constante expressie -construct toegevoegd:

constexpr lang dubbel PI = 3. 141592653589793;

Het constexpr-trefwoord brengt constanten in de C ++ -tent. Deze PI heeft een echt type, net als andere C ++ -variabelen. C ++ kan foutberichten genereren met PI die veel logischer zijn dan die met 3. 14159.

Constante uitdrukkingen zijn prima voor individuele constante waarden, maar vaak vertegenwoordigen constanten sets van dingen in plaats van natuurlijke constanten, zoals in het volgende voorbeeld:

#define DC_OR_TERRITORY 0 #define ALABAMA 1 #define ALASKA 2 #define ARKANSAS 3 // … enzovoort …

Vermoedelijk worden deze constanten gebruikt om de toestanden te identificeren, misschien gebruikt als een index in een array van state-objecten of als een waarde in een database ergens.

C ++ heeft al lang een verbeterd mechanisme voor het definiëren van dit soort constanten - de opsomming:

enum STATE {DC_OR_TERRITORY, // krijgt 0 ALABAMA, // krijgt 1 ALASKA, // krijgt 2 ARKANSAS, // … en spoedig…};

Het trefwoord enum introduceert een reeks constanten die een "opsomming" wordt genoemd. In dit geval heeft de opsomming de naam STATE. Elk element van deze opsomming krijgt een waarde die begint bij 0 en achter elkaar wordt verhoogd met 1, dus DC_OR_TERRITORY is gedefinieerd als 0, ALABAMA is gedefinieerd als 1, enzovoort. U kunt deze incrementele volgorde wijzigen door een toewijzingsinstructie als volgt te gebruiken:

enum STATE {DC, TERRITORY = 0, ALABAMA, ALASKA, // … enzovoort …};

Deze versie van STATE definieert een element DC, dat de waarde 0 krijgt. Het definieert dan een nieuw element TERRITORY, waaraan ook de waarde 0 is toegewezen. ALABAMA pakt met 1, net als voorheen.

In de praktijk kan de programmeur opsommingen gebruiken om behoorlijk leesbare code te schrijven, zoals de volgende:

dubbele taxrate (STATE s) {return taxRatesByState [s];}

Het enige probleem met deze aanpak is dat deze opsomming maakt geen nieuw type aan (zoals je misschien denkt).In feite is STATE, volgens de standaard, gewoon een andere naam voor int - en de constanten ALABAMA, ALASKA, enzovoort, zijn allemaal van type const int.

De gcc-compiler geeft inderdaad een enum dat op deze manier een beetje meer autoriteit wordt verklaard dan gewoon een andere vorm van int. U kunt functies overbelasten op basis van een enum-type:

void fn (STATE s); void fn (int n); fn (Alaska); // verwijst naar fn (STATE)

Met de 2011-standaard kan de programmeur een volledig nieuw type maken met behulp van het trefwoord Enum. Omdat de makers van de nieuwe standaard bestaande code niet wilden verbreken, vereist de standaard de toevoeging van een extra sleutelwoord om een ​​opsommingstype te definiëren, zoals in het volgende voorbeeld:

enum klasse STATE {DC, TERRITORY = 0, ALABAMA, ALASKA, // … enzovoort …};

Een opsommingsklasse is nu een volledig schaaltype zoals elke andere door de gebruiker gedefinieerde klasse. Het volgende is om twee redenen niet eens meer legaal:

int s = ALASKA;

Ten eerste wordt de constante ALASKA alleen gedefinieerd binnen de STATE-naamruimte. Dus de naam van de constante is STATE:: ALASKA. Ten tweede is het type niet int maar STATE. U kunt een waarde van het type STATE niet toewijzen aan een int.

STATE s = STATE:: ALASKA;

De programmeur kan een STATE omzetten in een int, maar ze moet dit expliciet doen - impliciete conversies knippen het niet met opsommingsklassen:

int n = (int) STATE:: ALASKA;

Dit nieuwe type type kan ook worden gebaseerd op een van de andere typen getallen naast alleen int:

enumklasse STATE: char {DC, // … de rest van de verklaring is hetzelfde