C++11 standard conformant bitmasks using enum class

Question

Can you implement standard conformant (as described in 17.5.2.1.3 of the n3242 draft) type safe bitmasks using enum class? The way I read it, a type T is a bitmask if it supports the |,&,^,~,|=,&= and ^= operators and further you can do if(l&r) where l and r are of type T. Missing from the list are the operator != and == and to allow sorting one probably also wants to overload <.

Getting the operators to works is just annoying boilerplate code but I do not see how to do if(l&r). At least the following does not compile with GCC (besides being extremely dangerous as it allows an erroneous implicit conversion to int):

enum class Foo{
    operator bool(){
        return (unsigned)*this;
    }
};

EDIT: I now know for certain that enum classes can not have members. The actual question how to do if(l&r) remains though.

I do not see any requirement that a bitmask type be implicitly convertible to bool; why must if (l&r) be well-formed? — James McNellis
– James McNellis, Commented Aug 21, 2012 at 17:26
Have you considered... not bothering? Personally, I've always seen type-safe enums as a way of providing reasonable assurance that an enumeration value will always be one of its enumerator types. If you can do bitwise operations on them, then this assumption is wrong (proven by the amount of static_casts you'll need to make it compile). The way I see it, if you want a bitfield, you should use an enum, not an enum class. — Nicol Bolas
– Nicol Bolas, Commented Aug 21, 2012 at 17:38
I have written such operators as templates, and I use a has_flags function to test if a value has all of a certain set of flags set. I find it is a lot better than &, because it can check multiple flags without potential for mistakes (writing (l&r) instead of (l&r)==r); and it is a lot more readable. — R. Martinho Fernandes
– R. Martinho Fernandes, Commented Aug 21, 2012 at 18:30
@aschepler, who are you talking to? The question is about scoped enums, so that isn't true. — Jonathan Wakely
– Jonathan Wakely, Commented Aug 23, 2012 at 1:17

Pharap · Accepted Answer · 2017-08-02 20:14:58Z

44

I think you can... You'll have to add operators for bitmasky things. I didn't do it here but you could easily overload any relational operator.

  /**
   *
   */
  // NOTE: I changed to a more descriptive and consistent name
  //       This needs to be a real bitmask type.
  enum class file_permissions : int
  {
    no_perms        = 0,

    owner_read      =  0400,
    owner_write     =  0200,
    owner_exe       =  0100,
    owner_all       =  0700,

    group_read      =   040,
    group_write     =   020,
    group_exe       =   010,
    group_all       =   070,

    others_read     =    04,
    others_write    =    02,
    others_exe      =    01,
    others_all      =    07,

    all_all     = owner_all | group_all | others_all, // 0777

    set_uid_on_exe  = 04000,
    set_gid_on_exe  = 02000,
    sticky_bit      = 01000,

    perms_mask      = all_all | set_uid_on_exe | set_gid_on_exe | sticky_bit, // 07777

    perms_not_known = 0xffff,

    add_perms       = 0x1000,
    remove_perms    = 0x2000,
    symlink_perms   = 0x4000
  };

  inline constexpr file_permissions
  operator&(file_permissions x, file_permissions y)
  {
    return static_cast<file_permissions>
      (static_cast<int>(x) & static_cast<int>(y));
  }

  inline constexpr file_permissions
  operator|(file_permissions x, file_permissions y)
  {
    return static_cast<file_permissions>
      (static_cast<int>(x) | static_cast<int>(y));
  }

  inline constexpr file_permissions
  operator^(file_permissions x, file_permissions y)
  {
    return static_cast<file_permissions>
      (static_cast<int>(x) ^ static_cast<int>(y));
  }

  inline constexpr file_permissions
  operator~(file_permissions x)
  {
    return static_cast<file_permissions>(~static_cast<int>(x));
  }

  inline file_permissions &
  operator&=(file_permissions & x, file_permissions y)
  {
    x = x & y;
    return x;
  }

  inline file_permissions &
  operator|=(file_permissions & x, file_permissions y)
  {
    x = x | y;
    return x;
  }

  inline file_permissions &
  operator^=(file_permissions & x, file_permissions y)
  {
    x = x ^ y;
    return x;
  }

edited Aug 2, 2017 at 20:14

Pharap

4,1525 gold badges43 silver badges51 bronze badges

answered Aug 22, 2012 at 20:01

emsr

16.5k7 gold badges52 silver badges65 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Meister Schnitzel Over a year ago

I really like the simle an clear look of the code. Thanks for your answer.

anton_rh Over a year ago

This approach is used to implement std::launch enumeration in gcc implementation of standard library. std::launch is enum class but still supports bitwise logic operations on it.

Pavel Minaev Over a year ago

Never use __ in your identifiers - the Standard reserves them for implementations (for custom keywords, internal macros in standard library headers etc)

emsr Over a year ago

@PavelMinaev Yes, true. This cose actually came from an attempt to implement <filesystem> for libstdc++. I should have cleaned it.

Xeverous Over a year ago

Since C++14 you can add constexpr to all overloads.

ecatmur · Accepted Answer · 2012-08-21 21:42:18Z

I'm not entirely sure what your acceptance criteria are, but you can just make operator & return a wrapper class with appropriate conversions and an explicit operator bool:

#include <type_traits>

template<typename T> using Underlying = typename std::underlying_type<T>::type;
template<typename T> constexpr Underlying<T>
underlying(T t) { return Underlying<T>(t); }

template<typename T> struct TruthValue {
    T t;
    constexpr TruthValue(T t): t(t) { }
    constexpr operator T() const { return t; }
    constexpr explicit operator bool() const { return underlying(t); }
};

enum class Color { RED = 0xff0000, GREEN = 0x00ff00, BLUE = 0x0000ff };
constexpr TruthValue<Color>
operator&(Color l, Color r) { return Color(underlying(l) & underlying(r)); }

All your other operators can continue to return Color, of course:

constexpr Color
operator|(Color l, Color r) { return Color(underlying(l) | underlying(r)); }
constexpr Color operator~(Color c) { return Color(~underlying(c)); }

int main() {
    constexpr Color YELLOW = Color::RED | Color::GREEN;
    constexpr Color WHITE = Color::RED | Color::GREEN | Color::BLUE;
    static_assert(YELLOW == (WHITE & ~Color::BLUE), "color subtraction");
    return (YELLOW & Color::BLUE) ? 1 : 0;
}

Jonathan Wakely · Accepted Answer · 2012-08-23 01:14:08Z

Missing from the list are the operator != and ==

Those operators are already supported by enumeration types, integer types and std::bitset so there's no need to overload them.

and to allow sorting one probably also wants to overload <.

Why do you want to sort bitmasks? Is (a|b) greater than (a|c)? Is std::ios::in less than std::ios::app? Does it matter? The relational operators are always defined for enumeration types and integer types anyway.

To answer the main question, you would implement & as an overloaded non-member function:

Foo operator&(Foo l, Foo r)
{
    typedef std::underlying_type<Foo>::type ut;
    return static_cast<Foo>(static_cast<ut>(l) & static_cast<ut>(r));
}

I believe all the required operations for bitmask types could be defined for scoped enums, but not the requirements such as

Ci & Cj is nonzero and Ci & Cj iszero

and:

The value Y is set in the object X is the expression X & Y is nonzero.

Since scoped enums don't support impicit conversion to integer types, you cannot reliably test if it's nonzero or not. You would need to write if ((X&Y) != bitmask{}) and I don't think that's the intention of the committee.

(I initially thought they could be used to define bitmask types, then remembered I'd tried to implement one using scoped enums and encountered the problem with testing for zero/nonzero.)

Edit: I've just remembered that std::launch is a scoped enum type and a bitmask type ... so apparently scoped enums can be bitmask types!

David Rodríguez - dribeas · Accepted Answer · 2012-08-21 17:39:13Z

4

Scoped enumerations (those created with either enum class or enum struct) are not classes. They cannot have member functions, they just provide enclosed enumerators (not visible at namespace level).

answered Aug 21, 2012 at 17:39

David Rodríguez - dribeas

209k23 gold badges304 silver badges496 bronze badges

1 Comment

Jonathan Wakely Over a year ago

They also disallow implicit conversions that are allowed for unscoped enumerations.

Yuri Yaryshev · Accepted Answer · 2013-07-21 14:52:41Z

3

A short example of enum-flags below.

#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) is a macro, defined in enum_flags.h (less then 100 lines, free to use with no restrictions).

edited Jul 21, 2013 at 14:52

answered Jul 21, 2013 at 10:28

Yuri Yaryshev

1,0418 silver badges25 bronze badges

4 Comments

Warpspace Over a year ago

Life saver from re-cording boilerplate each time!

Soonts Over a year ago

Looks like you have a bug there. Line #68 should say enum class T: INT_T; instead of enum class T; Otherwise C3433: 'eee': all declarations of an enumeration must have the same underlying type

j b Over a year ago

This is super-useful. Question: why are you using intptr_t over e.g. uint32_t?

Yuri Yaryshev Over a year ago

@j intptr_t matches machine register size. It is 64 bit for modern machines and 32 for older ones and it can even be 16 bit if you're using it on some exotic platform, so intptr_t seems to be the best candidate for default type for enum. But you might have noticed that there's also a macro which gets type as argument

Collectives™ on Stack Overflow

C++11 standard conformant bitmasks using enum class

5 Answers 5

5 Comments

Comments

Comments

1 Comment

4 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

5 Comments

Comments

Comments

1 Comment

4 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related