Använda uppräknade typer som bitflaggor (2 / 3 steg)

Steg 2: Använda uppräknade typer

template
class EnumFlag {
public:
void set(T f) {
_flags |= (1<<(uint64_t)f);
}
void unset(T f) {
_flags &= ~(1<<(uint64_t)f);
}
void toggle(T f) {
_flags ^= (1<<(uint64_t)f);
}
void zero() { _flags = (uint64_t)0; }
bool has(T f) { return (_flags & f); }

private:
uint64_t _flags;
};

Ibland kan det vara en stor smärta att hantera bitmasker, särskilt när du går över utrymmet som 32-bitars flagga. Något litet fel i din definiera kan helt kasta av din flagga kontroll. Det finns ett enklare sätt genom att dynamiskt skapa bitmasker med den bit placeringen, och jag har skrivit en klass som gör just detta.

enum class MyFlags : uint64_t {
FLAG1 = 1,
FLAG2,
FLAG3,
FLAG4
};

EnumFlag<MyFlags> myFlag;
// Initialize the flags
myFlag.zero();
// Set flag2
myFlag.set(MyFlags::FLAG2);
// Check for flag3
if (myFlag.has(MyFlags.FLAG3) do_something();

Du vill självklart ändra uint64_t till uint32_t om du är på en 32-bitars system. Du
använda en EnumFlag med 1-indexerade uppräknare, såhär:

Märka flaggorna är bara objekt i en uppräknad datatyp. Innebär detta ingen hård-kodning flagga masken till flaggan namn och ger dig ett enkelt sätt att infoga nya flaggor var som helst i enum flagga struktur och nästa gång du kompilerar det refactor allt.

Hur snyggt är det?!