Question

let’s say I have this:

enum E{ 
a,
b,
c,
total
}

class A {
char mask; // supposed to contains combinations of values of the enum, like a or c, etc
}

Is there a decent solution to build the object A in a user-friendly way?
For instance I could do:

A(E e) {
mask = 1 << e;
}

but this will only work if you want the mask to be made from only 1 element of the enum
Ideally the user would be able to do something like :

A* a = new A(a | c)

and this would automatically create

mask = 1 << a | 1 << c;

Any idea on how to do this correctly?
thanks

edit

sadly I have no control over the initial enum and the values are increasing 1 by 1

Answer 1

Well, there’s the simple way and the ugly way.

The simple way is to define the bits as non-overlapping to being with, e.g.:

enum E
{ 
   a = 1 << 0,
   b = 1 << 1,
   c = 1 << 2,
   total = 1 << 3 // or a | b | c, not sure what the intent was
};

The ugly way:

#define MAKEA(x) (new A((E_helper() | x).get()))

where E_helper is a class that overrides operator|(enum E).

class E_helper
{
    unsigned accum;
public:
    explicit E_helper(unsigned initial = 0) : accum(initial) {}
    unsigned get() const { return accum; }
    E_helper operator|(enum E e) const { return E_helper(accum | (1 << (unsigned)e)); }
};

And then your user can say

A* p = MAKEA(a | c);

which expands to

A* p = (new A((A_helper() | a | c).get());

which causes this chain of events

A_helper.operator|(a).operator|(c).get()

Better yet, move the .get() call inside A’s constructor, which then takes an argument of type A_helper. This will let you catch the case where the user forgot to use the MAKEA macro.

Be warned, however, that the ugly way exposes counter-intuitive behavior. For example, A* p = MAKEA(a | c); is different from A* p = MAKEA( (a | c) ); and char mask = a | c; A* p = MAKEA(mask);