Come sovraccaricare | = operatore su enumerato ambito?

Question

Come è possibile sovraccaricare l'operatore |= su un valore di tipo (in C++ 11, GCC) fortemente codificato?

Voglio testare, impostare e cancellare i bit su enum fortemente digitati. Perché fortemente digitato? Perché i miei libri dicono che è una buona pratica. Ma questo significa che devo static_cast<int> ovunque. Per evitare ciò, sovraccarico gli operatori | e &, ma non riesco a capire come sovraccaricare l'operatore |=su un enum. Per una lezione, devi semplicemente inserire the operator definition in the class, ma per le enumerazioni che non sembrano funzionare sintatticamente.

Questo è quello che ho finora:

enum class NumericType 
{ 
    None     = 0, 

    PadWithZero    = 0x01, 
    NegativeSign   = 0x02, 
    PositiveSign   = 0x04, 
    SpacePrefix    = 0x08 
}; 

inline NumericType operator |(NumericType a, NumericType b) 
{ 
    return static_cast<NumericType>(static_cast<int>(a) | static_cast<int>(b)); 
} 

inline NumericType operator &(NumericType a, NumericType b) 
{ 
    return static_cast<NumericType>(static_cast<int>(a) & static_cast<int>(b)); 
} 

La ragione per cui faccio questo: questo è il modo in cui funziona nel fortemente tipizzato C#: un enum c'è solo una struttura con un campo del suo sottostante tipo e un gruppo di costanti definito su di esso. Ma può avere qualsiasi valore intero che si adatti al campo nascosto dell'enumerazione.

E sembra che le enumerazioni C++ funzionino nello stesso modo. In entrambe le lingue, i cast devono passare da enum a int o viceversa. Tuttavia, in C# gli operatori bit a bit sono sovraccaricati per impostazione predefinita e in C++ non lo sono.

Answer 1

inline NumericType& operator |=(NumericType& a, NumericType b) 
{ 
    return a= a |b; 
} 

Questo funziona? Compile and run: (Ideone)

#include <iostream> 
using namespace std; 

enum class NumericType 
{ 
    None     = 0, 

    PadWithZero    = 0x01, 
    NegativeSign   = 0x02, 
    PositiveSign   = 0x04, 
    SpacePrefix    = 0x08 
}; 

inline NumericType operator |(NumericType a, NumericType b) 
{ 
    return static_cast<NumericType>(static_cast<int>(a) | static_cast<int>(b)); 
} 

inline NumericType operator &(NumericType a, NumericType b) 
{ 
    return static_cast<NumericType>(static_cast<int>(a) & static_cast<int>(b)); 
} 

inline NumericType& operator |=(NumericType& a, NumericType b) 
{ 
    return a= a |b; 
} 

int main() { 
    // your code goes here 
    NumericType a=NumericType::PadWithZero; 
    a|=NumericType::NegativeSign; 
    cout << static_cast<int>(a) ; 
    return 0; 
} 

stampa 3.

Answer 2

Combinando i valori distinti per fare nuove, valori non definiti, si sono totalmente in contraddizione con la paradigma forte tipizzazione.

Sembra che si stiano impostando singoli bit di bandiera completamente indipendenti. In questo caso, non ha senso combinare i bit in un tipo di dati in cui tale combinazione produce un valore non definito.

si dovrebbe decidere sulla dimensione dei dati di bandiera (char, short, long, long long) and roll con esso. È possibile, tuttavia, utilizzare tipi specifici per testare, flag impostati e chiari:

typedef enum 
{ 
    PadWithZero    = 0x01, 
    NegativeSign   = 0x02, 
    PositiveSign   = 0x04, 
    SpacePrefix    = 0x08 
} Flag; 

typedef short Flags; 

void SetFlag(Flags & flags, Flag f) 
{ 
    flags |= static_cast<Flags>(f); 
} 

void ClearFlag(Flags & flags, Flag f) 
{ 
    flags &= ~static_cast<Flags>(f); 
} 

bool TestFlag(const Flags flags, Flag f) 
{ 
    return (flags & static_cast<Flags>)(f)) == static_cast<Flags>(f); 
} 

Questo è molto semplice, e va bene quando ogni bandiera è solo un singolo bit. Per le bandiere mascherate, è un po 'più complesso. Ci sono modi per incapsulare i bit flag in una classe fortemente tipizzata, ma ne vale davvero la pena. Nel tuo caso, non sono convinto che lo sia.

Answer 3

This seems to work for me:

NumericType operator |= (NumericType &a, NumericType b) { 
    unsigned ai = static_cast<unsigned>(a); 
    unsigned bi = static_cast<unsigned>(b); 
    ai |= bi; 
    return a = static_cast<NumericType>(ai); 
} 

Tuttavia, si può ancora considerare la definizione di una classe per la vostra collezione di enum bit:

class NumericTypeFlags { 
    unsigned flags_; 
public: 
    NumericTypeFlags() : flags_(0) {} 
    NumericTypeFlags (NumericType t) : flags_(static_cast<unsigned>(t)) {} 
    //...define your "bitwise" test/set operations 
}; 

Quindi, modificare le | e & operatori a restituire NumericTypeFlags invece.