c++ - 如何使用嵌套枚举实现代码重用

Question

我正在尝试构建一个类，使其子类将具有 C++11 enum class 属性，以及关联的 setter/getter:

class Base { 
  public:
    enum class MyEnum {
        A,
        B
    } my_enum;

    Base() : my_enum(MyEnum::A) {}

    MyEnum get() { return my_enum; }
    void set(const MyEnum &ME) { my_enum = ME; } 
};

class Derived : public Base { 
  public:
    Derived(): Base() {
        my_enum = MyEnum::B;
    }
};

int main(int argc, char *argv[])
{
    Derived Deriv;

    // No problems!
    Deriv.get() == Derived::MyEnum::B;  

    return 0;
}

到目前为止，还不错!

但是，我希望派生类能够重新定义 MyEnum 枚举类，而不必一直重新实现 setter/getter/attribute:

// Base as before

class Derived : public Base {
  public:

    enum class MyEnum {
        C,
        D 
    }; // intention: to override Base's "my_enum" attribute

    Derived(): Base() {
        my_enum = MyEnum::C;  
        // ERROR: cannot convert 'Derived::MyEnum' to 'Base::MyEnum' 
    }
};

int main(int argc, char *argv[])
{
    Derived Deriv;

    // ERROR: no match for 'operator==' for types 'Base::MyEnum' and 'Derived::MyEnum'
    Deriv.get() == Derived::MyEnum::C;  

    return 0;
}

我明白问题是什么；我只是在寻找能够为这种情况重用代码的最干净的方法。

最好只通过继承(或者更确切地说，功能应该仅通过从 Base() 派生的行为提供给 Derived() 类)。

有什么建议吗？

Answer 1

您可以使 Base 成为模板，由枚举类型参数化，并使用特征类提供“默认”枚举类型，该类型可以由派生类型专门化。

template<typename T>
struct MyEnumTraits
{
    enum class type {
        A,
        B
    };

    static const type default_value = type::A;
};

template<typename T = void>
class Base { 
  public:

    typedef typename MyEnumTraits<T>::type MyEnum;
    MyEnum my_enum;

    Base() : my_enum(MyEnumTraits<T>::default_value) {}

    MyEnum get() { return my_enum; }
    void set(const MyEnum &ME) { my_enum = ME; } 
};

class Derived;

template<>
struct MyEnumTraits<Derived>
{
    enum class type {
        C,
        D 
    };
    static const type default_value = type::C;
};

class Derived : public Base<Derived> {
    // ...

但是现在不同的派生类型会有不同的基类，这很可能不是你想要的。您可以通过保留非模板 Base 并将 getter 和 setter 移动到从 Base 派生的中间类模板中，然后派生类型从中派生来解决这个问题。

class Base { ... };

template<typename T = void> class GetterSetterImpl : public Base { ... };

class Derived : public GetterSetterImpl<Derived> { ... };