C ++ 11重载运算符，用于类中放置的枚举类

Question

this is my first try to use enum classes for my projects, but I have the problem that I can't compile my code if the enum class is placed inside of another class. I try to define the operator overloading like my example and I try to do it outside, too. All works fine if I place the enum class outside the class. Whats wrong? How to overloading the operator if I what to use it placed in an class?

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

Answer 1

The enum class can be inside another class, but the operator definition must be at namespace scope.

Also note that the operator is computing a new value and as such, it cannot return a reference, as there would be nothing to which the reference could bind. It should return by value instead.

In total:

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

Answer 2

I would write it as:

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

This way, it no longer matters whether or not MyClass is in a namespace , and the correct underlying_type is used to perform the bitwise math.

Answer 3

Fixed code for the operator:

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

Answer 4

As you wrote your following main() code line:

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

It will expect namespace operator, so the operator should be placed outside the MyClass (but within the MyNamespace):

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

also, as stated in above answer you can not return a temporary memory (as reference), so either return by-value or define static variable in the operator and return it.