C ++에서 비트 플래그에 범위가 지정된 열거 형 사용

enum X : int(C 번호) 또는 enum class X : int(C ++ 11)의 숨겨진 내부 필드 갖는 타입 int의 값을 보유 할 수있다. 또한 많은 사전 정의 된 상수가 X열거 형에 정의되어 있습니다. 열거 형을 정수 값으로 캐스트 할 수 있으며 그 반대도 가능합니다. 이것은 C #과 C ++ 11 모두에 해당됩니다.

C # 열거 형은 Microsoft의 권장 사항에 따라 개별 값을 보유 할뿐만 아니라 플래그의 비트 조합을 보유하는 데 사용됩니다 . 이러한 열거 형은 (보통은 아니지만 반드시) [Flags]속성으로 장식됩니다 . 개발자의 삶을 쉽게하기 위해 비트 연산자 (OR, AND 등 ...)가 오버로드되어 다음과 같이 쉽게 수행 할 수 있습니다 (C #).

void M(NumericType flags);

M(NumericType.Sign | NumericType.ZeroPadding);

저는 숙련 된 C # 개발자이지만 지금은 며칠 동안 만 C ++을 프로그래밍하고 있으며 C ++ 규칙에 대해서는 알려져 있지 않습니다. C #에서와 똑같은 방식으로 C ++ 11 열거 형을 사용하려고합니다. C ++ 11에서는 범위가 지정된 열거 형의 비트 연산자가 오버로드되지 않으므로 오버 로드하고 싶었습니다 .

이것은 논쟁을 불러 일으켰으며, 의견은 세 가지 옵션 사이에서 다양하게 보인다.

1. 열거 형의 변수는 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)));
   

   그러나 이것은 C ++ 11의 범위가 지정된 열거 형의 강력한 형식의 열거 형 철학에 맞지 않습니다.

2. 열거 형의 비트 조합을 저장하려면 일반 정수를 사용하십시오.

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

   그러나 이것은 모든 것을로 줄여서 int메소드에 어떤 유형을 넣어야할지 전혀 알지 못합니다.

3. 연산자를 오버로드하고 숨겨진 정수 필드에 비트 단위 플래그를 보유하는 별도의 클래스를 작성하십시오.

   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);
   

   ^{( 전체 코드 에 의해 user315052 )}

   그러나 IntelliSense 또는 가능한 값을 알려주는 지원이 없습니다.

나는 이것이 주관적인 질문 이라는 것을 알고 있지만, 어떤 접근법을 사용해야합니까? C ++에서 가장 널리 인식되는 접근법은 무엇입니까? 비트 필드와 처리 할 때 당신은 어떤 방법을 사용합니까 왜 ?

물론 세 가지 접근 방식이 모두 효과가 있기 때문에 저는 개인적으로 선호되는 것이 아니라 사실적이고 기술적 인 이유, 일반적으로 받아 들여지는 규칙을 찾고 있습니다.

예를 들어, C # 배경으로 인해 C ++에서 접근법 1을 사용하는 경향이 있습니다. 이것은 내 개발 환경이 가능한 값을 암시 할 수 있다는 추가 이점을 가지고 있으며 과부하 된 열거 형 연산자를 사용하면 작성하고 이해하기 쉽고 깨끗합니다. 그리고 메소드 서명은 어떤 종류의 가치를 기대하는지 명확하게 보여줍니다. 그러나 여기에있는 대부분의 사람들 은 나에게 동의하지 않을 것입니다. 아마 그럴만한 이유가 있습니다.

가장 간단한 방법은 작업자에게 과부하를 제공하는 것입니다. 유형별로 기본 과부하를 확장하기 위해 매크로를 작성하려고합니다.

#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;
}

( type_traits이는 C ++ 11 헤더이며 std::underlying_type_tC ++ 14 기능입니다.)

역사적으로, 나는 항상 오래된 (약한 형식의) 열거 형을 사용하여 비트 상수의 이름을 지정하고 스토리지 클래스를 명시 적으로 사용하여 결과 플래그를 저장했습니다. 여기서 열거 형이 스토리지 유형에 적합하도록하고 필드와 관련 상수 사이의 연관성을 추적해야합니다.

나는 강력한 형식의 열거 형이라는 아이디어가 마음에 들지만 열거 형의 변수에 열거 형 상수에 속하지 않는 값이 포함될 수 있다는 생각에는 실제로 편안하지 않습니다.

예를 들어, 비트 단위 또는 과부하가 있다고 가정합니다.

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

세 번째 옵션의 경우 열거의 저장 유형을 추출하려면 상용구가 필요합니다. 서명되지 않은 기본 유형을 강제하고 싶다고 가정하면 (더 많은 코드로 부호를 처리 할 수 ​​있습니다) :

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;

그래도 IntelliSense 또는 자동 완성 기능을 제공하지는 않지만 스토리지 유형 감지가 원래 예상했던 것보다 덜 추합니다.

이제 대안을 찾았습니다. 약한 형식의 열거에 대한 저장소 유형을 지정할 수 있습니다. 심지어 C #에서와 동일한 구문을 가지고 있습니다.

enum E4 : int { ... };

약한 유형이며 int (또는 선택한 저장 유형)로 암시 적으로 변환하기 때문에 열거 된 상수와 일치하지 않는 값을 갖는 것이 이상하지 않습니다.

단점은 이것이 "과도기적"으로 묘사된다는 것입니다 ...

NB. 이 변형은 열거 된 상수를 중첩 범위와 둘러싸는 범위에 모두 추가하지만 네임 스페이스를 사용하여이 문제를 해결할 수 있습니다.

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

를 사용하여 C ++ 11에서 형식 안전 열거 형 플래그를 정의 할 수 있습니다 std::enable_if. 이것은 몇 가지 누락 된 기초 구현입니다.

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;
}

가 참고 number_of_bitsC ++이 열거의 가능한 값을 성찰 할 수있는 방법을 가지고 있지 않기 때문에 불행하게도, 컴파일러에 의해 작성 될 수 없습니다.

편집 : 실제로 나는 정정되었습니다 number_of_bits. 컴파일러를 채울 수 있습니다.

이것은 비 연속적인 열거 형 값 범위를 처리 할 수 ​​있다는 점에 유의하십시오. 위와 같은 열거 형과 함께 위의 내용을 사용하는 것이 좋지 않다고 가정 해 봅시다.

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

그러나이 모든 것이 결국에는 꽤 유용한 해결책이라고 생각합니다. 사용자 측 bitfiddling이 필요하지 않으며 유형 안전하고 범위 내에서 가능한 한 효율적입니다 ( std::bitset구현 품질에 크게 의존 하고 있습니다 ;)).

나는 미움 C ++ 14에서 매크로를 다음 사람만큼이나 비난했지만, 나는 이것을 온전히 사용하고 상당히 자유롭게 사용했습니다.

#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

간단하게 사용하기

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

그리고 그들이 말하는 것처럼 증거는 푸딩에 있습니다.

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;
}

적합하다고 생각되는대로 개별 연산자를 자유롭게 정의 할 수 있지만, C / C ++는 저수준의 개념 및 스트림과의 인터페이스를위한 것으로, 비트 단위 연산자를 차갑고 죽은 손에서 빼낼 수 있습니다. 그리고 나는 그것을 지키기 위해 쓸모없는 모든 거시적 매크로와 비트 튀기는 주문으로 당신과 싸울 것입니다.

일반적으로 단일 비트 집합 이진수에 해당하는 정수 값 집합을 정의한 다음 함께 더합니다. 이것이 C 프로그래머들이 일반적으로하는 방식입니다.

따라서 비트 시프트 연산자를 사용하여 값을 설정하십시오. 예를 들어 1 << 2는 이진 100과 동일합니다.

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

기타

C ++에는 더 많은 옵션이 있으며 int ( typedef 사용 ) 대신 새 유형을 정의하고 위와 같이 값을 설정하십시오. 또는 비트 필드 또는 bools 벡터를 정의하십시오 . 마지막 2 개는 공간 효율성이 뛰어나며 플래그 처리에 훨씬 적합합니다. 비트 필드는 유형 검사 (따라서 지능적)를 제공하는 이점이 있습니다.

C ++ 프로그래머가 문제에 비트 필드를 사용해야한다고 말하지만 분명히 C ++ 프로그램에서 C 프로그램이 많이 사용하는 #define 접근법을 보는 경향이 있습니다.

비트 필드가 C #의 열거 형에 가장 가까운 것으로 가정합니다. C #에서 열거 형을 비트 필드 형식으로 오버로드하려고 시도한 이유는 이상합니다. 열거 형은 실제로 "단일 선택"형식이어야합니다.

아래 열거 형 플래그의 간단한 예는 C #과 매우 비슷합니다.

접근 방식에 대해서는 제 생각에는 코드가 적고 버그가 적으며 코드가 좋습니다.

#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)는 enum_flags.h에 정의 된 매크로입니다 (100 줄 미만, 제한없이 사용 가능).

고양이를 피부에 바르는 또 다른 방법이 있습니다.

비트 연산자를 오버로드하는 대신 최소한 일부는 4 개의 라이너를 추가하여 범위가 지정된 열거 형의 엄격한 제한을 피할 수 있습니다.

#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;
}

물론 ut_cast()매번 물건 을 입력 해야하지만, 반대로, 이것은 static_cast<>()암시 적 유형 변환이나 operator uint16_t()종류의 물건에 비해 사용하는 것과 같은 방식으로 더 읽기 쉬운 코드를 생성 합니다.

Foo위 코드에서와 같이 type 을 사용 하면 위험이 있습니다.

다른 곳에서 누군가 변수를 바꾸는 경우가 foo있고 둘 이상의 값을 가질 것으로 기대하지 않을 수도 있습니다 ...

따라서 코드를 흩 뜨리면 ut_cast()독자에게 비린내가 일어나고 있음을 경고 하는 데 도움이됩니다.