Is using enum for integer bit oriented operations in C++ realiable/safe?

Question

Consider the following (simplified) code:

enum eTestMode
{
    TM_BASIC        = 1,    // 1 << 0
    TM_ADV_1        = 1 << 1,
    TM_ADV_2        = 1 << 2
};

...

int m_iTestMode;    // a "bit field"

bool isSet( eTestMode tsm )
{ 
    return ( (m_iTestMode & tsm) == tsm );
}

void setTestMode( eTestMode tsm )
{
    m_iTestMode |= tsm;
}

Is this reliable, safe and/or good practice? Or is there a better way of achieving what i want to do apart from using const ints instead of enum? I would really prefer enums, but code realiability is more important than readability.

Answer 1

There is no problem. You can even use an variable of eTestMode (and defines bit manipulation for that type) as it is guaranteed to hold all possible values in that case.

Answer 2

I can't see anything bad in that design.

However, keep in mind that enum types can hold unspecified values. Depending on who uses your functions, you might want to check first that the value of tsm is a valid enumeration value.

Since enums are integer values, one could do something like:

eTestMode tsm = static_cast<eTestMode>(17); // We consider here that 17 is not a valid value for your enumeration.

However, doing this is ugly and you might just consider that doing so results in undefined behavior.

Answer 3

See also http://stackoverflow.com/questions/366017/what-is-the-size-of-an-enum-in-c

For some compilers (e.g. VC++) this non-standard width specifier can be used:

enum eTestMode : unsigned __int32
{ 
    TM_BASIC        = 1,    // 1 << 0 
    TM_ADV_1        = 1 << 1, 
    TM_ADV_2        = 1 << 2 
}; 

Answer 4

Using enums for representing bit patterns, masks and flags is not always a good idea because enums generally promote to signed integer type, while for bit-based operation unsigned types are almost always preferable.