C++ C++；11类内放置枚举类的重载运算符

这是我第一次尝试在我的项目中使用enum类，但我有一个问题，即如果enum类放在另一个类中，我就无法编译代码。 我试着像我的例子一样定义操作符重载，我也试着在外部进行。 如果我将enum类放在类之外，所有这些都可以正常工作。 怎么了？如果我在类中放置了如何使用操作符，如何重载操作符

#include <cstdint>

namespace MyNamespace
{
    class MyClass
    {
    public:
        enum class MyEnum_t
        {
            VALUE_0 = 0x0,
            VALUE_1 = 0x1,
            VALUE_2 = 0x2,
            VALUE_3 = 0x4,
            VALUE_4 = 0x8 
       };

        inline MyEnum_t &operator|(MyEnum_t lhs, MyEnum_t rhs)
        {
            return static_cast<MyEnum_t>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
        }
}

int main()
{
    MyNamespace::MyClass::MyEnum_t test = MyNamespace::MyClass::MyEnum_t::VALUE_0;

    test = MyNamespace::MyClass:MyEnum_t::VALUE_1 | MyNamespace::MyClass::MyEnum_t::VALUE_2;

    return 0;
}

#包括
名称空间MyNamespace
{
类MyClass
{
公众：
枚举类MyEnum\u t
{
值_0=0x0，
值_1=0x1，
值_2=0x2，
值_3=0x4，
值_4=0x8
};
内联MyEnum_t&运算符（MyEnum_t lhs，MyEnum_t rhs）
{
返回静态施法（静态施法（lhs）|静态施法（rhs））；
}
}
int main（）
{
MyNamespace:：MyClass:：MyEnum\u t test=MyNamespace:：MyClass:：MyEnum\u t:：VALUE\u 0；
test=MyNamespace:：MyClass:MyEnum_t:：VALUE_1 | MyNamespace:：MyClass:：MyEnum_t:：VALUE_2；
返回0；
}

枚举类可以位于另一个类内，但运算符定义必须位于命名空间范围内

还请注意，运算符正在计算一个新值，因此，它不能返回引用，因为引用不能绑定到任何内容。它应该按值返回

总计：

namespace MyNamespace
{
    class MyClass
    {
    public:
        enum class MyEnum_t
        {
            VALUE_0 = 0x0,
            VALUE_1 = 0x1,
            VALUE_2 = 0x2,
            VALUE_3 = 0x4,
            VALUE_4 = 0x8 
       };
    };

    inline MyClass::MyEnum_t operator|(MyClass::MyEnum_t lhs, MyClass::MyEnum_t rhs)
    {
       return static_cast<MyEnum_t>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
    }
}

名称空间MyNamespace
{
类MyClass
{
公众：
枚举类MyEnum\u t
{
值_0=0x0，
值_1=0x1，
值_2=0x2，
值_3=0x4，
值_4=0x8
};
};
内联MyClass:：MyEnum_t运算符|（MyClass:：MyEnum_t lhs，MyClass:：MyEnum_t rhs）
{
返回静态施法（静态施法（lhs）|静态施法（rhs））；
}
}

操作员的固定代码：

inline MyClass::MyEnum_t operator|(MyClass::MyEnum_t lhs, MyClass::MyEnum_t rhs)
{
    return static_cast<MyClass::MyEnum_t>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
}

内联MyClass:：MyEnum_t运算符|（MyClass:：MyEnum_t lhs，MyClass:：MyEnum_t rhs）
{
返回静态施法（静态施法（lhs）|静态施法（rhs））；
}

我会这样写：

class MyClass
{
public:
    enum class MyEnum_t
    {
        VALUE_0 = 0x0,
        VALUE_1 = 0x1,
        VALUE_2 = 0x2,
        VALUE_3 = 0x4,
        VALUE_4 = 0x8,
    };

    friend MyEnum_t operator|(MyEnum_t lhs, MyEnum_t rhs)
    {
        using UT = std::underlying_type<MyEnum_t>::type;
        return static_cast<MyEnum_t>(static_cast<UT>(lhs) | static_cast<UT>(rhs));
    }
};

class-MyClass
{
公众：
枚举类MyEnum\u t
{
值_0=0x0，
值_1=0x1，
值_2=0x2，
值_3=0x4，
值_4=0x8，
};
friend MyEnum_t运算符（MyEnum_t lhs，MyEnum_t rhs）
{
使用UT=std:：底层_type:：type；
返回静态施法（静态施法（lhs）|静态施法（rhs））；
}
};

---

这样，无论

MyClass

是否在

名称空间中，都不再重要，正确的
基础类型将用于执行按位计算。
编写以下main（）代码行时：

test=MyNamespace:：MyClass:MyEnum_t:：VALUE_1 | MyNamespace:：MyClass:：MyEnum_t:：VALUE_2

它需要名称空间运算符，因此该运算符应放在MyClass之外（但在MyNamespace内）：

MyClass:：MyEnum_t运算符|（MyClass:：MyEnum_t lhs，MyClass:：MyEnum_t rhs）
{
返回静态施法（静态施法（lhs）|静态施法（rhs））；
}

此外，正如上面的回答所述，您不能返回临时内存（作为参考），因此可以按值返回，也可以在运算符中定义静态变量并返回它。
“我无法编译代码”，因此请提供错误消息。您的类定义缺少一个右括号和分号。最好在发布之前对这些内容进行排序，这样代码就会显示出您正在询问的问题。
MyClass:：MyEnum_t&operator |（MyClass:：MyEnum_t lhs，MyClass:：MyEnum_t rhs）
应该放在类之外。可能需要修复运算符的返回类型。我同意您的看法，这必须是正确的方法，但它无法编译。如果我尝试编译它，我会收到消息：“错误：'MyEnum_t'未命名类型”“如果我尝试修复返回值，请添加“MyClass:：”我得到：“错误：无法将类型为'MyNamespace:：MyClass:：MyEnum\u t&'的非常量左值引用绑定到类型为'MyNamespace:：MyClass:：MyEnum\u t'的右值”“@Mnemonic这是因为引用，正如StoryTeller正确指出的那样。答案已编辑。@Angew在您的解决方案中有一件事是错误的。返回值的范围。修复后，它将编译。谢谢。@Mnemonic“在您的解决方案中有一件事是错误的”：嗯，它只是从Q中复制粘贴的，所以它不是真正的“我的”解决方案。我只是没有注意到，因为
&
放在了一个不寻常的地方（通常是按类型而不是按函数名放置）。无论如何，这就是我在回答中提到的编辑。
MyClass::MyEnum_t operator|(MyClass::MyEnum_t lhs, MyClass::MyEnum_t rhs)
{
    return static_cast<MyClass::MyEnum_t>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
}