Nrthugu

I have defined an enum that I want to use for storing flags in variables. The intent is to be able to set several flags, and being able to check which ones are set.

For this purpose, I need two operations: one to find out if a is in b, and a second one to find out if a is not in b. I implemented them using operator overloads. I picked <= and != arbitrarily:

enum Flag { NoFlags, B, C, D=4 };



inline Flag operator |(Flag a, Flag b) {

    return static_cast<Flag >(static_cast<int>(a) | static_cast<int>(b)); }



inline bool operator <=(Flag a, Flag b) { return a == (a & b); }



inline bool operator !=(Flag a, Flag b) { return !(a<=b); }

This works fine. So for example:

Flag flags1 = A|C;

Flag flags2 = B|D;

Flag flags3 = NoFlags|A|B|C|D;



A <= flags1 //true

A != flags2 //true

C != flags3 //false

B <= flags1 //false

I picked <= and != arbitrarily. I know they normally have completely different meanings. So I wonder:

• is there a commonly accepted practice of using other operators for representing these two operations ?




• Or would it be better to use functions instead of operator overloads ?

Most readers of your code (and maybe even your future self) will get very confused, because the meaning you give to the operators is not consistent with the standard operators. For example:

• 
  !(a <= b) is expected to be the same as a>b
  


• 
  !(a != b) is expected to be the same as a==b
  


• 
  flags1 != flags3 would no longer mean that exactly the same flags are set in both variables

For this reason, and according to the principle of least astonishment, I'd strongly advise against your choice.

The common practice with operators on flags is to use | to set flags and & in combination with ~ to reset flags, and & to test flags. But this is done, assuming predictable bitwise operations, and not a higher level interface as yours.

In your case, I'd recommend using functions instead of operators, and let the function names clearly express your intent (e.g. is_included()). I'd even suggest to consider enum classes with member functions for a better encapsulation.

Since you seem to consider your Flag variables as a set of combined individual flags, you could get inspired by the std::set interface if you're looking for a consistent and known naming scheme (e.g. insert(), find(), contains(), merge(), etc...).