在C ++中键入一个bitfield / mask

Question

I have this problem in C++: can I typedef a bitfield whose values come from an enum?

Code will be more explainatory:

typedef {
 AUDIO    = 0x01,
 VIDEO    = 0x02,
 SUBTITLE = 0x04,
 DATA     = 0x08,
 GUARD,
 ALL      = 0xFF
} my_enum_e;

// I'd like to replace 'unsigned int' by 'my_enum_e' or similar
int myFunction( unsigned int mask ) 
{
  // code
}

// called like this:
myFunction( AUDIO|VIDEO|DATA );

In the prototype of the function, I'd like to use my_enum_e as an input value type, so that when exploring the code, you can immediately know which values you're supposed to put in there.

Now, changing the prototype to

int myFunction( my_enum_e mask );

makes the compiler whine about a cast error. I cant fix it by casting the function calls like this:

int myFunction( my_enum_e mask )
{
    // code
}

myFunction( (my_enum_e)(VIDEO|AUDIO|DATA) );

But I find this quite horrible, and I'm not even sure it is legal (could it truncate the value??).
Do you have a solution?

Answer 1

Add an explicit overload for | and possibly other operators.

my_enum_e operator|(my_enum_e a, my_enum_e b) 
    { return my_enum_e(unsigned(a)|unsigned(b)); }

One can write a macro that defines all needed operators for a given bitmask type.

#define BITMASK_OPERATORS(T)   T operator|(T a, T b) { return T(unsigned(a)|unsigned(b)); } \
                                 T operator^(T a, T b) ...

Answer 2

How about implementing a special function to deal with this:

template <typename Enum>
Enum bitField(unsigned bits) {
  return static_cast<Enum>(bits);
}

It adds expressiveness to what you're doing:

myFunction(bitField<my_enum_e>(VIDEO|AUDIO|DATA));

If you want more sophistication, you can do this:

template <typename Enum>
struct BitField {
  Enum value;
  BitField(Enum value) : value(value) {}
  BitField operator|(Enum more) {
    return BitField(value | more);
  }
  BitField operator&(Enum more) {
    return BitField(value & more);
  }
  BitField operator~() {
    return BitField(~value);
  }
  operator Enum() {
    return value;
  }
}

Which will allow you to write

myFunction(BitField<my_enum_e>(VIDEO) | AUDIO | DATA);

Answer 3

当您执行按位运算时，编译器会将VIDEO | AUDIO | DATA视为整数值，因此您必须使用* my_enum_e *进行转换。

Answer 4

I recommend that you look at this thread: Which Typesafe Enum in C++ Are You Using? - The mentioned implemention in the [Boost Vault] (filename enum_rev4.6.zip ). 1 provides also the possibility to declare a BOOST_BITFIELD :

BOOST_BITFIELD(my_enum_e, 
  (AUDIO)    (0x01)
  (VIDEO)    (0x02)
  (SUBTITLE) (0x04)
  (DATA)     (0x08)
);

you can then declare your function:

int myFunction( const my_enum_e & in_enum ) 
{
  if ( in_enum[AUDIO] ) ...
}

The usage is then

void callerFunction()
{
  my_enum_e mask;
  mask.set(my_enum_e::AUDIO);
  mask.set(my_enum_e::VIDEO | my_enum_e::SUBTITLE );
  cout << mask << " = " << hex << mask.value() << endl; // will print: AUDIO|VIDEO|SUBTITLE = 0x7
  myFunction( mask );

}

The documentation of the api is not that good. But the packages comes with a test that shows several usages.

Answer 5

One way around it is to typedef int MY_FLAGS; and then #define all your values instead: #define AUDIO 0x01 etc. That way the compiler won't moan and you still get types in your function calls:

int myFunction( MY_FLAGS mask );

myFunction( VIDEO|AUDIO|DATA );