0

主类.h：

namespace Alpha{ enum class Parameters; }
namespace Beta { enum class Parameters; }
MainClass{
public:
  enum class Type{ Type_A, Type_B };
  MainClass(const Type t);

  void DoStuff(const Parameters p);
private:
  void doesStuff(const int p_val);
};

主类.cpp：

/* define values for Alpha::Parameters, Beta::Parameters here or elsewhere, and included */
MainClass::MainClass(const Type t){
  /* not sure how to do this. But essentially by switching based on 't' use either Alpha::Parameters or Beta::Parameters */
}

MainClass::DoStuff(const Parameters p){
  int p_value = static_cast<int>(p);
  doesStuff(p_value);
}

这就是我希望能够做到的。这可能吗？实际上，如果enum 类表现得像一个具有继承的类，那就太好了，但我知道我不能那样做。我尝试重写的次数越多，它就会一直螺旋式上升，直到我几乎要为每个案例编写特定的类（我在示例中不止两个）。但是代码非常相似，真的。

我也知道另一种选择是允许DoStuff(const Parameters p)只是一个DoStuff(const int p_val)并在外部进行静态转换......但是我必须在其他地方进行所有静态转换，我不'没有得到很好的枚举类类型检查。

如果不可能，那很好……但如果是这样，那就太糟糕了。

4

2 回答 2

3

你试过模板吗？

class Main {
    template < typename PARAMETERS >
    void DoStuff(const PARAMETERS p) {
        doesStuff(static_cast<int>(p));
    }
}

然后，如果需要，您可以为每个参数类型提供特化。

我错过了关于确定构造函数中哪个 T 的第一部分。通常我会使用类模板来实现它，如下所示：

#include <iostream>

namespace Alpha{ enum class Parameters { A, B, C }; }
namespace Beta { enum class Parameters { a, b, c }; }

template < typename P >
class MainClass{
public:
    MainClass() { }

    void DoStuff(const P p) {
        int p_value = static_cast< int >(p);
        doesStuff(p_value);
    }

private:
    void doesStuff(const int p_val) {
        std::cout << "DoesStuff " << p_val << std::endl;
    }
};

int main(int argc, const char** argv) {

    MainClass< Alpha::Parameters > alpha;
    alpha.DoStuff(Alpha::Parameters::A);
    alpha.DoStuff(Alpha::Parameters::B);
    alpha.DoStuff(Alpha::Parameters::C);
    MainClass< Beta::Parameters > beta;
    beta.DoStuff(Beta::Parameters::a);
    beta.DoStuff(Beta::Parameters::b);
    beta.DoStuff(Beta::Parameters::c);
    return 0;
}

但是，如果 DoStuff 是唯一依赖于要使用的参数的部分，我会使用模板函数。

于 2015-01-06T16:20:31.690 回答
1

您可以通过函数重载和最少的函数体代码来实现这一点。

MainClass::DoStuff(Alpha::Parameters p){
    int p_value = static_cast<int>(p);
    doesStuff(p_value);
}
MainClass::DoStuff(Beta::Parameters p){
    int p_value = static_cast<int>(p);
    doesStuff(p_value);
}
MainClass::DoStuff(Etcetera::Parameters p){
    int p_value = static_cast<int>(p);
    doesStuff(p_value);
}

所有的实现都在doesStuff()函数中。

这仍然允许您保留使用不同枚举的现有函数调用。

但是，这种类型检查可能没有您想象的那么有价值……此代码假定所有枚举都将保持相同。如果您只更改其中一个（例如 Beta::Parameters 枚举），它将破坏此代码，并且您将引入一个错误而没有任何警告。

于 2015-01-06T17:29:45.903 回答