Re: "Reusable" operator overloading for enum?
Hi!
nick wrote:
Thanks, Balog. I did away with the ~ operator, but instead of
replacing it with a named function I figured I'd use the - and -=
operators for unsetting the flag. Here's what I ended up with, maybe
this will be useful for someone else.
inline static T operator-(T l, T r) \
{ return l&r?(T)((unsigned)l-(unsigned)r):l; } \
I cannot recommend this, since it produces undefined results in case you
try to remove more than one flag at once. Furthermore it creates a
reasonable runtime overhead because of the conditional expression.
I would prefer the use of l&~r, although ~r is not well defined by the
standard so far. In practice there is most likely not even one existing
implementation that breaks this code. And it is very unlikely that one
will ever exist, too, since in C++0x already has defined behavior
because you can specify the underlying type of the enum.
It is much more likely that future versions of the standard address this
kind of use case of enumeration types in some way. This will make the
above code superfluous.
By the way. There is another clean solution without using macros and
undefined behavior. Write your own enumeration class. You could use a
template base class to define the required operators.
template <typename I>
class EnumBase
{protected:
I Value;
EnumBase(I value) : Value(value) {}
};
template <typename I, typename T>
class EnumFlagsBase : EnumBase<I>
{protected:
EnumFlagsBase(I value) : EnumBase(value) {}
friend T operator|(T l, T r)
{ l.Value |= r.Value;
return l;
}
//...
};
class MyEnum : public EnumFlagsBase<unsigned, MyEnum>
{
MyEnum(unsigned value) : EnumFlagsBase(value) {}
public:
static const MyEnum Flag1;
static const MyEnum Flag2;
};
const MyEnum MyEnum::Flag1 = MyEnum(1);
const MyEnum MyEnum::Flag2 = MyEnum(2);
int main()
{ MyEnum val = MyEnum::Flag1|MyEnum::Flag2;
return 0;
}
The resulting object has the memory footprint of the underlying integral
type full type safety and no runtime overhead.
Strictly speaking the not fully specialized base class EnumBase could be
merged into EnumFlagsBase. But if you have some common base functions or
you need enumeration types that are no flags and you do not want the
implicit conversion to int, the additional type might be useful to avoid
unwanted code redundancies in the executable.
Marcel