Utilizzo di variabili firmate vs non firmate per flag in C++

Question

Esiste qualche "buona pratica" o l'abitudine di utilizzare le variabili firmate rispetto alle variabili non firmate per le bandiere? Personalmente userò la variabile unsigned, ma posso vedere anche la variabile firmata usata per i flag in qualche codice. Intendo soprattutto nell'interfaccia della biblioteca dove conta.

UDPATE Non riesco ad accettare la risposta "usa Enum", perché è implementation dependent e questo non può essere utilizzato nell'interfaccia della libreria.

Answer 1

E 'noto che le bandiere sono sempre interi non negativi, ma perché si userebbe int/unsigned int/short/unsigned short per una bandiera? Utilizzare #define o, ancora meglio, il tipo enum.

enum flags 
{ 
    FLAG0 = 0, 
    FLAG1 = 1, 
    FLAG2 = 2, 
    ... 
    FLAGN = n 
}; 

Answer 2

Penso che un tipo senza segno sia una rappresentazione migliore di un insieme di flag. Dato che hai bisogno di una quantità specifica di bit equivalenti per rappresentare le tue bandiere. In un tipo firmato il primo bit è un po 'speciale.

Probabilmente il std::bitset potrebbe anche soddisfare le vostre esigenze. E ti servirà con gli operatori logici di base e i metodi di conversione.

#include <iostream> 
#include <bitset> 
using namespace std; 

int main() { 
    std::bitset<4> flags; 
    flags.set(1); 
    flags.set(3); 
    std::cout << flags.to_string() << std::endl; 
    std::cout << flags.to_ulong() << std::endl; 
    return 0; 
} 

DEMO

Answer 3

Se si decide di utilizzare enum per le vostre bandiere, ecco un utile macro che crea il codice per gli operatori bit a bit per il tipo enum.

#define GENERATE_ENUM_FLAG_OPERATORS(enumType) \ 
    inline enumType operator| (enumType lhs, enumType rhs) \ 
    { \ 
     return static_cast<enumType>(static_cast<int>(lhs) | static_cast<int>(rhs)); \ 
    } \ 
    inline enumType& operator|= (enumType& lhs, const enumType& rhs) \ 
    { \ 
     lhs = static_cast<enumType>(static_cast<int>(lhs) | static_cast<int>(rhs)); \ 
     return lhs; \ 
    } \ 
    inline enumType operator& (enumType lhs, enumType rhs) \ 
    { \ 
     return static_cast<enumType>(static_cast<int>(lhs) & static_cast<int>(rhs)); \ 
    } \ 
    inline enumType& operator&= (enumType& lhs, const enumType& rhs) \ 
    { \ 
     lhs = static_cast<enumType>(static_cast<int>(lhs) & static_cast<int>(rhs)); \ 
     return lhs; \ 
    } \ 
    inline enumType operator~ (const enumType& rhs) \ 
    { \ 
     return static_cast<enumType>(~static_cast<int>(rhs)); \ 
    } 

Usage:

enum Test 
{ 
    TEST_1 = 0x1, 
    TEST_2 = 0x2, 
    TEST_3 = 0x4, 
}; 
GENERATE_ENUM_FLAG_OPERATORS(Test); 

Test one = TEST_1; 
Test two = TEST_2; 

Test three = one | two;