c++ - 隐式转换未按预期工作

我已经编写了一个简单的Flags类，但是操作符定义遇到了问题。似乎我要依靠一些不存在的隐式转换规则。

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;
}

编译时出现此错误:

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;

我的理解是，SomeEnum之一被隐式转换为Flags<Enum>，然后传递给正确的运算符。我错过了什么规则？

编辑:

我查看了https://stackoverflow.com/questions/9787593，但是建议的解决方案(非成员运算符(operator))无法解决我的问题。
我确实删除了全局定义并添加了以下成员:

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

但是错误仍然相同(live demo)。

最佳答案

为了知道SomeEnum可转换为Flags<SomeEnum>，它必须已经将Enum模板参数推导出为SomeEnum，但是由于它们都不匹配Flags<Enum>，因此无法从参数中推论得出。

也就是说，必须先进行模板参数推导，然后才能检查到其他类型的转换。

您可以调整函数，以便只有一个参数参与参数推导:

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

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

或等效地:

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

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

这在非推导上下文中使用Enum模板参数，因此仅另一个参数用于推导。

但是这样做之后，您现在有了模棱两可的重载，因为编译器无法知道是要转换第一个参数还是第二个参数。

您需要添加一个接受两种SomeEnum类型的重载，并显式执行到Flags<SomeEnum>的转换。如果枚举类型应与operator|一起使用，则应定义该运算符本身。

另一个不涉及更改枚举类型的选项是添加一个将枚举器变成Flags对象的助手:

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

那么您可以说SomeEnum::TWO | flags(SomeEnum::TWO)避免歧义。

从风格上讲，don't use ALL_CAPS for enumerators。

关于c++ - 隐式转换未按预期工作，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/47230960/