如何从头文件中父级内部的嵌套 class 调用重载运算符？

Question

我有一个枚举 class E 嵌套在 class C 中。我想将它用作位标志，所以我重载了它的运算符。

我的 class C 包含使用重载运算符的函数 test()。因为只有两行，所以位于要内联的头文件中。不过这个函数并没有调用重载运算符，而是使用了默认的运算符。

我理解可能是因为我的运算符是在classC之后定义的，所以C并不知道它们的存在。我可以将嵌套枚举移到外面并在 class C 之前定义运算符，但我想知道，有没有办法在保留 C::E 层次结构的同时做到这一点？

main.cpp

#include "myenum.h"

int main() {
    std::cout << "Should be false (main): " << ((C::E::e2 | C::E::e4) != C::E::e4) << std::endl;
    C c(C::E::e2 | C::E::e4);
    c.test(C::E::e4);
    return 0;
}

myenum.h

#pragma once

#include <iostream>

class C {
public:
    enum class E {
        e2 = 2,
        e4 = 4
    };

    const E e;

    C(E e) : e(e) {}

    void test(E e) {
        std::cout << "Should be false (test): " << (this->e != e) << std::endl;
    }
};

// Flag active
inline bool operator==(C::E lhs, C::E rhs) {
    auto l = static_cast<std::underlying_type<C::E>::type>(lhs);
    auto r = static_cast<std::underlying_type<C::E>::type>(rhs);
    auto value = l & r;
    return value == r || value == l;
}

// Flag inactive
inline bool operator!=(C::E lhs, C::E rhs) {
    std::cout << "Overloaded operator call" << std::endl;
    return !(lhs == rhs);
}

inline C::E operator|(C::E lhs, C::E rhs) {
    return (C::E)(static_cast<std::underlying_type<C::E>::type>(lhs) | static_cast<std::underlying_type<C::E>::type>(rhs));
}

Answer 1

class C {
public:
    enum class E {
        e2 = 2,
        e4 = 4
    };

    const E e;

    C(E e) : e(e) {}

    inline void test(E e); // function must be inline
};

// Flag active
inline bool operator==(C::E lhs, C::E rhs) ...


// implement later
inline void C::test(C::E e) {
  // do stuff
}

我想不出适合您的版本的模板。
也许这将是最好的。

如何从头文件中父级内部的嵌套 class 调用重载运算符？

How to call an overloaded operator from a nested class inside parent in a header file?

c++

operator-overloading

header-files

inner-classes