Usando enums com escopo definido para sinalizadores de bit em C ++

Um enum X : int(C #) ou enum class X : int(C ++ 11) é um tipo que possui um campo interno oculto intque pode conter qualquer valor. Além disso, várias constantes predefinidas de Xsão definidas na enumeração. É possível converter a enumeração em seu valor inteiro e vice-versa. Isso tudo é verdade em C # e C ++ 11.

Em C #, as enums não são usadas apenas para armazenar valores individuais, mas também para combinar combinações de bit a bit de sinalizadores, conforme recomendação da Microsoft . Tais enumerações são (geralmente, mas não necessariamente) decoradas com o [Flags]atributo Para facilitar a vida dos desenvolvedores, os operadores bit a bit (OR, AND, etc ...) estão sobrecarregados para que você possa fazer algo assim (C #):

void M(NumericType flags);

M(NumericType.Sign | NumericType.ZeroPadding);

Eu sou um desenvolvedor experiente de C #, mas tenho programado C ++ apenas há alguns dias e não sou conhecido pelas convenções de C ++. Pretendo usar uma enumeração C ++ 11 da mesma maneira que costumava fazer em C #. No C ++ 11, os operadores bit a bit em enumerações com escopo não são sobrecarregados, então eu queria sobrecarregá-los .

Isso solicitou um debate, e as opiniões parecem variar entre três opções:

1. Uma variável do tipo enum é usada para conter o campo de bits, semelhante ao C #:

   void M(NumericType flags);
   
   // With operator overloading:
   M(NumericType::Sign | NumericType::ZeroPadding);
   
   // Without operator overloading:
   M(static_cast<NumericType>(static_cast<int>(NumericType::Sign) | static_cast<int>(NumericType::ZeroPadding)));
   

   Mas isso contraria a filosofia de enumeração fortemente tipada das enumerações com escopo definido em C ++ 11.

2. Use um número inteiro simples se desejar armazenar uma combinação de enumerações bit a bit:

   void M(int flags);
   
   M(static_cast<int>(NumericType::Sign) | static_cast<int>(NumericType::ZeroPadding));
   

   Mas isso reduziria tudo a um int, deixando você sem idéia de qual tipo você deveria colocar no método.

3. Escreva uma classe separada que sobrecarregará os operadores e mantenha os sinalizadores bit a bit em um campo inteiro oculto:

   class NumericTypeFlags {
       unsigned flags_;
   public:
       NumericTypeFlags () : flags_(0) {}
       NumericTypeFlags (NumericType t) : flags_(static_cast<unsigned>(t)) {}
       //...define BITWISE test/set operations
   };
   
   void M(NumericTypeFlags flags);
   
   M(NumericType::Sign | NumericType::ZeroPadding);
   

   ^{( código completo do usuário315052 )}

   Mas você não possui o IntelliSense ou qualquer outro suporte para sugerir os valores possíveis.

Sei que essa é uma pergunta subjetiva , mas: que abordagem devo usar? Qual abordagem, se houver, é a mais amplamente reconhecida em C ++? Qual abordagem você usa ao lidar com campos de bits e por quê ?

É claro que, como todas as três abordagens funcionam, estou procurando razões factuais e técnicas, convenções geralmente aceitas e não apenas preferências pessoais.

Por exemplo, devido ao meu background em C #, eu costumo seguir a abordagem 1 em C ++. Isso tem o benefício adicional de que meu ambiente de desenvolvimento pode me sugerir os valores possíveis e, com operadores sobrecarregados de enum, isso é fácil de escrever e entender, e bastante limpo. E a assinatura do método mostra claramente que tipo de valor espera. Mas a maioria das pessoas aqui discorda de mim, provavelmente por um bom motivo.

A maneira mais simples é fornecer que o operador se sobrecarregue. Estou pensando em criar uma macro para expandir as sobrecargas básicas por tipo.

#include <type_traits>

enum class SBJFrameDrag
{
    None = 0x00,
    Top = 0x01,
    Left = 0x02,
    Bottom = 0x04,
    Right = 0x08,
};

inline SBJFrameDrag operator | (SBJFrameDrag lhs, SBJFrameDrag rhs)
{
    using T = std::underlying_type_t <SBJFrameDrag>;
    return static_cast<SBJFrameDrag>(static_cast<T>(lhs) | static_cast<T>(rhs));
}

inline SBJFrameDrag& operator |= (SBJFrameDrag& lhs, SBJFrameDrag rhs)
{
    lhs = lhs | rhs;
    return lhs;
}

(Observe que type_traitsé um cabeçalho C ++ 11 e std::underlying_type_té um recurso C ++ 14.)

Historicamente, eu sempre teria usado a enumeração antiga (de tipo fraco) para nomear as constantes de bits e apenas usado a classe de armazenamento explicitamente para armazenar o sinalizador resultante. Aqui, o ônus dependeria de mim para garantir que minhas enumerações se encaixassem no tipo de armazenamento e para acompanhar a associação entre o campo e as constantes relacionadas.

Gosto da ideia de enumerações fortemente tipadas, mas não me sinto muito à vontade com a ideia de que variáveis ​​do tipo enumerado podem conter valores que não estão entre as constantes dessa enumeração.

Por exemplo, assumindo o bit a bit ou foi sobrecarregado:

enum class E1 { A=1, B=2, C=4 };
void test(E1 e) {
    switch(e) {
    case E1::A: do_a(); break;
    case E1::B: do_b(); break;
    case E1::C: do_c(); break;
    default:
        illegal_value();
    }
}
// ...
test(E1::A); // ok
test(E1::A | E1::B); // nope

Para sua terceira opção, você precisa de um padrão para extrair o tipo de armazenamento da enumeração. Supondo que queremos forçar um tipo subjacente não assinado (também podemos manipular assinados, com um pouco mais de código):

template <size_t Size> struct IntegralTypeLookup;
template <> struct IntegralTypeLookup<sizeof(int64_t)> { typedef uint64_t Type; };
template <> struct IntegralTypeLookup<sizeof(int32_t)> { typedef uint32_t Type; };
template <> struct IntegralTypeLookup<sizeof(int16_t)> { typedef uint16_t Type; };
template <> struct IntegralTypeLookup<sizeof(int8_t)>  { typedef uint8_t Type; };

template <typename IntegralType> struct Integral {
    typedef typename IntegralTypeLookup<sizeof(IntegralType)>::Type Type;
};

template <typename ENUM> class EnumeratedFlags {
    typedef typename Integral<ENUM>::Type RawType;
    RawType raw;
public:
    EnumeratedFlags() : raw() {}
    EnumeratedFlags(EnumeratedFlags const&) = default;

    void set(ENUM e)   { raw |=  static_cast<RawType>(e); }
    void reset(ENUM e) { raw &= ~static_cast<RawType>(e); };
    bool test(ENUM e) const { return raw & static_cast<RawType>(e); }

    RawType raw_value() const { return raw; }
};
enum class E2: uint8_t { A=1, B=2, C=4 };
typedef EnumeratedFlags<E2> E2Flag;

Isso ainda não oferece o IntelliSense ou o preenchimento automático, mas a detecção do tipo de armazenamento é menos feia do que eu esperava inicialmente.

Agora, encontrei uma alternativa: você pode especificar o tipo de armazenamento para uma enumeração de tipo fraco. Ele ainda tem a mesma sintaxe que em C #

enum E4 : int { ... };

Como é de tipo fraco e converte implicitamente para / de int (ou qualquer outro tipo de armazenamento que você escolher), é menos estranho ter valores que não correspondem às constantes enumeradas.

A desvantagem é que isso é descrito como "transitório" ...

NB essa variante adiciona suas constantes enumeradas ao escopo aninhado e ao anexo, mas você pode contornar isso com um espaço para nome:

namespace E5 {
    enum Enum : int { A, B, C };
}
E5::Enum x = E5::A; // or E5::Enum::A

Você pode definir sinalizadores de enumeração com segurança de tipo no C ++ 11 usando std::enable_if. Esta é uma implementação rudimentar que pode estar faltando algumas coisas:

template<typename Enum, bool IsEnum = std::is_enum<Enum>::value>
class bitflag;

template<typename Enum>
class bitflag<Enum, true>
{
public:
  constexpr const static int number_of_bits = std::numeric_limits<typename std::underlying_type<Enum>::type>::digits;

  constexpr bitflag() = default;
  constexpr bitflag(Enum value) : bits(1 << static_cast<std::size_t>(value)) {}
  constexpr bitflag(const bitflag& other) : bits(other.bits) {}

  constexpr bitflag operator|(Enum value) const { bitflag result = *this; result.bits |= 1 << static_cast<std::size_t>(value); return result; }
  constexpr bitflag operator&(Enum value) const { bitflag result = *this; result.bits &= 1 << static_cast<std::size_t>(value); return result; }
  constexpr bitflag operator^(Enum value) const { bitflag result = *this; result.bits ^= 1 << static_cast<std::size_t>(value); return result; }
  constexpr bitflag operator~() const { bitflag result = *this; result.bits.flip(); return result; }

  constexpr bitflag& operator|=(Enum value) { bits |= 1 << static_cast<std::size_t>(value); return *this; }
  constexpr bitflag& operator&=(Enum value) { bits &= 1 << static_cast<std::size_t>(value); return *this; }
  constexpr bitflag& operator^=(Enum value) { bits ^= 1 << static_cast<std::size_t>(value); return *this; }

  constexpr bool any() const { return bits.any(); }
  constexpr bool all() const { return bits.all(); }
  constexpr bool none() const { return bits.none(); }
  constexpr operator bool() { return any(); }

  constexpr bool test(Enum value) const { return bits.test(1 << static_cast<std::size_t>(value)); }
  constexpr void set(Enum value) { bits.set(1 << static_cast<std::size_t>(value)); }
  constexpr void unset(Enum value) { bits.reset(1 << static_cast<std::size_t>(value)); }

private:
  std::bitset<number_of_bits> bits;
};

template<typename Enum>
constexpr typename std::enable_if<std::is_enum<Enum>::value, bitflag<Enum>>::type operator|(Enum left, Enum right)
{
  return bitflag<Enum>(left) | right;
}
template<typename Enum>
constexpr typename std::enable_if<std::is_enum<Enum>::value, bitflag<Enum>>::type operator&(Enum left, Enum right)
{
  return bitflag<Enum>(left) & right;
}
template<typename Enum>
constexpr typename std::enable_if_t<std::is_enum<Enum>::value, bitflag<Enum>>::type operator^(Enum left, Enum right)
{
  return bitflag<Enum>(left) ^ right;
}

Observe que, number_of_bitsinfelizmente, não pode ser preenchido pelo compilador, pois o C ++ não tem como fazer uma introspecção dos possíveis valores de uma enumeração.

Edit: Na verdade, eu estou corrigido, é possível obter o preenchimento do compilador number_of_bitspara você.

Observe que isso pode manipular (de maneira ineficiente) um intervalo de valores de enum não contínuo. Digamos apenas que não é uma boa ideia usar o item acima com uma enumeração como esta ou com a loucura:

enum class wild_range { start = 0, end = 999999999 };

Mas todas as coisas consideradas são uma solução bastante útil no final. Não precisa de nenhuma manipulação de bits do lado do usuário, é seguro para o tipo e dentro de seus limites, o mais eficiente possível (estou me baseando fortemente na std::bitsetqualidade da implementação aqui ;)).

Eu ódio detesto macros no meu C ++ 14 tanto quanto o próximo, mas passei a usá-lo em todo o lugar, e de maneira bastante liberal também:

#define ENUM_FLAG_OPERATOR(T,X) inline T operator X (T lhs, T rhs) { return (T) (static_cast<std::underlying_type_t <T>>(lhs) X static_cast<std::underlying_type_t <T>>(rhs)); } 
#define ENUM_FLAGS(T) \
enum class T; \
inline T operator ~ (T t) { return (T) (~static_cast<std::underlying_type_t <T>>(t)); } \
ENUM_FLAG_OPERATOR(T,|) \
ENUM_FLAG_OPERATOR(T,^) \
ENUM_FLAG_OPERATOR(T,&) \
enum class T

Fazendo uso tão simples quanto

ENUM_FLAGS(Fish)
{
    OneFish,
    TwoFish,
    RedFish,
    BlueFish
};

E, como se costuma dizer, a prova está no pudim:

ENUM_FLAGS(Hands)
{
    NoHands = 0,
    OneHand = 1 << 0,
    TwoHands = 1 << 1,
    LeftHand = 1 << 2,
    RightHand = 1 << 3
};

Hands hands = Hands::OneHand | Hands::TwoHands;
if ( ( (hands & ~Hands::OneHand) ^ (Hands::TwoHands) ) == Hands::NoHands)
{
    std::cout << "Look ma, no hands!" << std::endl;
}

Sinta-se livre para definir qualquer um dos operadores individuais como achar melhor, mas, na minha opinião altamente tendenciosa, o C / C ++ é para interface com conceitos e fluxos de baixo nível, e você pode retirar esses operadores bit a bit das minhas mãos frias e mortas e lutarei com você com todas as macros profanas e feitiços que eu posso invocar para mantê-las.

Normalmente, você define um conjunto de valores inteiros que correspondem aos números binários de um bit e os adiciona. É assim que os programadores C geralmente fazem isso.

Então você teria (usando o operador bitshift para definir os valores, por exemplo, 1 << 2 é o mesmo que 100 binário)

#define ENUM_1 1
#define ENUM_2 1 << 1
#define ENUM_3 1 << 2

etc

No C ++, você tem mais opções, defina um novo tipo em vez de int (use typedef ) e defina valores semelhantes, como acima; ou defina um campo de bits ou um vetor de bools . Os dois últimos são muito eficientes em termos de espaço e fazem muito mais sentido para lidar com sinalizadores. Um campo de bits tem a vantagem de fornecer verificação de tipo (e, portanto, intellisense).

Eu diria (obviamente subjetivo) que um programador C ++ deve usar um campo de bits para o seu problema, mas eu costumo ver a abordagem #define usada pelos programas C muito nos programas C ++.

Suponho que o campo de bits seja o mais próximo do enum do C #, por que o C # tentou sobrecarregar um enum para ser do tipo de campo de bits é estranho - um enum deve realmente ser do tipo "seleção única".

Um pequeno exemplo de enum-flags abaixo, se parece muito com o C #.

Sobre a abordagem, na minha opinião: menos código, menos bugs, melhor código.

#indlude "enum_flags.h"

ENUM_FLAGS(foo_t)
enum class foo_t
    {
     none           = 0x00
    ,a              = 0x01
    ,b              = 0x02
    };

ENUM_FLAGS(foo2_t)
enum class foo2_t
    {
     none           = 0x00
    ,d              = 0x01
    ,e              = 0x02
    };  

int _tmain(int argc, _TCHAR* argv[])
    {
    if(flags(foo_t::a & foo_t::b)) {};
    // if(flags(foo2_t::d & foo_t::b)) {};  // Type safety test - won't compile if uncomment
    };

ENUM_FLAGS (T) é uma macro, definida em enum_flags.h (menos de 100 linhas, livre para usar sem restrições).

Existe ainda outra maneira de esfolar o gato:

Em vez de sobrecarregar os operadores de bit, pelo menos alguns podem preferir adicionar um liner 4 para ajudá-lo a contornar essa restrição desagradável de enumerações com escopo definido:

#include <cstdio>
#include <cstdint>
#include <type_traits>

enum class Foo : uint16_t { A = 0, B = 1, C = 2 };

// ut_cast() casts the enum to its underlying type.
template <typename T>
inline auto ut_cast(T x) -> std::enable_if_t<std::is_enum_v<T>,std::underlying_type_t<T>>
{
    return static_cast<std::underlying_type_t<T> >(x);
}

int main(int argc, const char*argv[])
{
   Foo foo{static_cast<Foo>(ut_cast(Foo::B) | ut_cast(Foo::C))};
   Foo x{ Foo::C };
   if(0 != (ut_cast(x) & ut_cast(foo)) )
       puts("works!");
    else 
        puts("DID NOT WORK - ARGHH");
   return 0;
}

É verdade que você precisa digitar a ut_cast()coisa toda vez, mas, no lado superior, isso gera um código mais legível, no mesmo sentido que o uso static_cast<>(), comparado à conversão implícita de tipos ou operator uint16_t()coisas do tipo.

E vamos ser honestos aqui, usar type Foocomo no código acima tem seus perigos:

Em outro lugar, alguém pode alternar entre variáveis fooe não esperar que ele tenha mais de um valor ...

Assim, colocar o código de lado ut_cast()ajuda a alertar os leitores de que algo suspeito está acontecendo.