Met behulp van opgesomde typen als Bitflags (1 / 3 stap)

Stap 1: achtergrond

Het gebruik van bits vlaggen manier ver teruggaat tot de vroege dagen van de C programmeertaal. Het idee is eigenlijk heel simpel. In plaats van met behulp van een uniek geheel getal als een Booleaanse waarde (waar of onwaar of één of nul), kunt u elk van de bits binnen het gehele getal als een vlag zelf. Dit werkt alleen als uw vlaggen natuurlijk Boole-waarden zijn, maar gelukkig, in de programmering vele malen ze zijn.

Bijvoorbeeld, kon een 8-bits geheel getal als een vlag voor al dan niet weergeven van sommige instructies of niet verklaart:

unsigned char DISPLAY_INSTRUCTIONS = 1;

Met behulp van een 8-bit waarde zou ons in staat om 2⁸ mogelijke waarden, of 256 unieke vlaggen. Elke vlag zou voeren opwaarts een byte van bronnen, hetzij op schijf of in kern RAM. We kunnen ook andere standaard waarden gebruiken voor de vlag zoals uint16_t, een 16-bits waarde opslaan van maximaal 65.535 unieke vlaggen, waarschijnlijk veel meer dan we konden nodig hebt of ooit gebruikt. Maar wat als we alleen, zeggen hadden, 6 vlaggen we nodig om bij te houden? In de bovenstaande regeling zou het vereisen zes bytes, één byte voor elk vlag, maar met behulp van bits vlaggen we kon slaan alle zes vlaggen (en dan sommige) binnen één byte.

Als u niet vertrouwd met binaire getallen bent, misschien u neem een moment en lees mijn instructable op nummer bases, waaronder binaire of een aantal tutorials online vinden. Ik neem aan dat je al een voorbijgaande begrip van hoe binaire getallen worden samengesteld. Dus, kan u worden gevraagd hoe gebruikt men de individuele bits binnen een geheel getal als een vlag voor gebruik in code/software? Typisch, dit wordt gedaan door een beetje toe te wijzen op "1" of "0" en op basis van de positie binnen het gehele getal, kan worden gebruikt voor een bevestiging of ontkenning van de opgegeven waarde. Bijvoorbeeld, neem een 8-bits getal, zeggen, nul en staar ernaar.

0000 0000

OK, niets spannend hier. In de 1's locatie, maken het nu 1:

0000 0000

Kunnen we hetzelfde voor de twee locatie:

0000 0010

of de vier locatie:

0000 0100

of misschien de 32 en 8e locatie:
0010 1000

Welke nummers maak deze bits flips? Wij schelen niet. Wij zijn alleen bezorgd over de individuele bits binnen het nummer in dit geval. Om gemakkelijk toewijzen vlagwaarden bits, is het gebruikelijk om het volgende idioom:

#define FLAG1 0x01 // 0000 0001
#define FLAG2 0x02 // #define FLAG1 0x01 // 0000 0001
 #define FLAG2 0x02 // 0000 0010
 #define FLAG3 0x04 // 0000 0100
 #define FLAG4 0x08 // 0000 1000
 #define FLAG5 0x10 // 0001 0000
 #define FLAG6 0x20 // 0010 0000
 #define FLAG7 0x40 // 0100 0000
 #define FLAG8 0x80 // 1000 0000
#define FLAG3 0x04 // unsigned char myFlags = 0x00; myFlags |= FLAG5;
#define FLAG4 0x08 // 0000 1000
#define FLAG5 0x10 // 0001 0000
#define FLAG6 0x20 // 0010 0000
#define FLAG7 0x40 // 0100 0000
#define FLAG8 0x80 // 1000 0000

We hebben er onze vlaggen gedefinieerd. Neem nota van het patroon in het hexadecimale nummer zowel de binaire representatie. Dus, als veld Markering5 is ingesteld, dan de integer-vlag zou zijn stukje 5 set (met behulp van een op 1 gebaseerde index, in tegenstelling tot het meer gemeenschappelijk 0 als basis, maar het is niet belangrijk voor ons nu). Maken van de variabele van de vlag en het instellen van veld Markering5 ziet er als volgt:

myFlags &= ~FLAG3;

Wij of de vlaggen zodat geen bestaande vlaggen blijft behouden. Als u en de vlaggen, schrijft u over bestaande vlaggen met het bitmasker op uw ANDing te. Dit is handig wanneer u wilt een markering wissen:

#define FLAG28 0x00400000

De bovenstaande sets Markering3 onderneming tot nul. Merk op dat je ANDing met de aanvulling van de vlag bent.
Maar wat gebeurt er als u hebt:

#define FLAG_1 0x01
 #define FLAG_2 0x02
 #define FLAG_3 0x04
 #define FLAG_4 0x08
 ...
 uint32_t _flags;
 // set a flag
 _flags |= FLAG_2;
 // clear a flag
 _flags &= ~FLAG_3;
 // test bit flag
 if (_flags & FLAG_4)
 do_something();

en u probeert om het te zetten met onze 8-bits integer opgehaald? Heb je een overloop met niet-overeenkomende integer maten en krijg de foutmelding, waarschijnlijk tijdens runtime en niet compilatietijd omdat de compiler zal meestal bevorderen of anders impliciet uw constante vlag te converteren naar het type dat wordt geopereerd. Dit is niet altijd het geval, maar wel vaak. Dit kan leiden tot moeilijk te vangen de bugs, en de ergste: runtime-fouten. Ze zijn slecht omdat ze kunnen moeilijker om op te sporen, moeilijker om te repliceren en geïntroduceerde aan uw gebruikers, die u nooit willen doen indien mogelijk.

Verder, wat als u een nieuwe vlag, bijvoorbeeld veld Markering9 nodig maar met de waarde 0x0080 om welke reden? U zou moeten 1) uitbreiden uw vlag is geschikt voor de grotere omvang en 2) de vlag in de verklaringen van uw vlag invoegen typt en alle vlaggen achter het hernummeren. Dat is gewoon niet uitvoerbaar en zeker niet beheersbaar.

Wat doe je over deze problemen? Hoe kunnen we garanderen typebeveiliging en uitbreidbaarheid om onze vlaggen? De bladzijde omslaan en kom erachter!