implicit conversion not working as expected

Question

I have written a simple Flags class, but face a problem with my operator definition. It seems like I'm relying on some nonexistent implicit conversion rule.

enum class SomeEnum { ONE, TWO, THREE };

template<typename Enum>
class Flags {
    Flags(const Flags& f) { };
    Flags(Enum e) { };

    Flags& operator |=(Flags<Enum> f) {
        //...;
        return *this;
    }
};

template<typename Enum>
Flags<Enum> operator |(Enum a, Flags<Enum> b) { return b | a; }

template<typename Enum>
Flags<Enum> operator |(Flags<Enum> a, Enum b) { return a |= b; }

int main() {
    Flags<SomeEnum> flags = SomeEnum::ONE | SomeEnum::TWO;
    return 0;
}

While compilation I get this error:

implicit.cpp: In function ‘int main()’:  
implicit.cpp:26:40: error: no match for ‘operator|’ (operand types are ‘SomeEnum’ and ‘SomeEnum’)  
  Flags<SomeEnum> flags = SomeEnum::ONE | SomeEnum::TWO;

My understanding was, that one of the SomeEnums is implicitly converted into a Flags<Enum>, and then passed to the correct operator. What rule am I missing?

EDIT:

I have looked at https://stackoverflow.com/questions/9787593, but the proposed solution (nonmember-friend operator) did not solve my problem. I did remove the global definitions and add these members:

friend Flags operator |(Enum a, Flags b) { return b | a; }
friend Flags operator |(Flags a, Enum b) { return a |= b; }

But the error is still the same (live demo).

Answer 1

In order to know that SomeEnum is convertible to Flags<SomeEnum> it would already have to have deduced the Enum template argument as SomeEnum, but it can't deduce that from the arguments because neither of them matches Flags<Enum>.

i.e. the template argument deduction has to happen before conversions to another type can be checked.

You can adjust the functions so that only one argument participates in argument deduction:

template<typename T> struct nondeduced { using type = T; }

template<typename Enum>
Flags<Enum> operator |(Enum a, Flags<typename nondeduced<Enum>::type> b)

or equivalently:

template<typename E> struct FlagType { using type = Flags<E>; }

template<typename Enum>
Flags<Enum> operator |(Enum a, typename FlagType<Enum>::type b);

This uses the Enum template argument in a non-deduced context, so only the other argument is used for deduction.

But after doing that you now have ambiguous overloads, because there's no way for the compiler to know whether you want the first argument to be converted, or the second argument.

You need to add an overload that takes two SomeEnum types, and performs the conversions to Flags<SomeEnum> explicitly. If an enumeration type is supposed to be used with operator| then it should define that operator itself.

Another option that doesn't involve changing the enumeration types would be to add a helper that turns an enumerator into a Flags object:

template<typename Enum>
inline Flags<Enum> flags(Enum e) { return Flags<Enum>(e); }

then you can say SomeEnum::TWO | flags(SomeEnum::TWO) which avoids the ambiguity.

As a stylistic point, don't use ALL_CAPS for enumerators.