Question

我经常遇到这个恼人的怪癖。

说我有类似

的东西

enum class Thing {Ex1, Ex2, Ex3}

我有一个Thing的实例，并希望根据它创建一个特定的类，它最终看起来像这样

switch(_thing){
    case Thing::Ex1:
        ptr = new Class1();
        break;

     case Thing::Ex2:
         ptr = new Class2();
         break;

     case Thing::Ex3:
         ptr = new Class3();
         break; 
}

等等。有10-20个这样的陈述，它看起来非常糟糕。这是不可避免的，还是有办法改善这个？

Answer 1

不幸的是，C ++仍然没有反思。您可以考虑经过验证的X宏，如果您的代码中有多个位置，您必须使用相同的值映射到类型：

#define CASES \
    X(Thing::Ex1, Class1) \
    X(Thing::Ex2, Class2) \
    X(Thing::Ex3, Class3) \
    // ...
// ...
switch (_thing) {
#define X(v, T) \
    case (v): \
        ptr = new (T)(); \
        break;
    CASES
#undef X
}
// ... do other things with CASES and a different X macro
// ...
#undef CASES

Answer 2

如果项目数量变大，那么在＆＃34; Things＆＃34;之间创建关联（也就是map）是有意义的。和工厂方法。说Python很容易，但在C ++中可能会有点痛苦。

typedef Baseclass * (*factoryMethod) (void);

// factories contains the association between types and constructors
std::map <std::string, factoryMethod> factories;

// If possible, it's often a good idea to make these methods static members of Baseclass.
Baseclass * factoryMethodA(void)
{
  return new ClassA();
}

Baseclass * factoryMethodB(void)
{
  return new ClassB();
}
// &ct

my_map["A"] = factoryMethodA;
my_map["B"] = factoryMethodB;
// &ct

用法只是......

ptr = factories[classname]();

如果您正在使用C ++ 11，我可以使用lambdas节省大量的输入，以至于这是一个非常有用的编程工具。

#include <iostream>
#include <map>

class BaseClass {
  public:
  virtual void Print() = 0;
};

class ClassA : public BaseClass {
  public:
  void Print() { std::cout << "Hello "; }
};

class ClassB : public BaseClass {
  public:
  void Print() { std::cout << "World!\n"; }
};

typedef BaseClass * (*factoryMethod) (void);

std::map <std::string, factoryMethod> factories = {
  { "a", []()->BaseClass * {return new ClassA(); } },
  { "b", []()->BaseClass * {return new ClassB(); } }
};

int main (void)
{
  BaseClass * foo = factories["a"]();
  BaseClass * bar = factories["b"]();

  foo->Print();
  bar->Print();

  return 0;
}

这可以让你做一些巧妙的技巧，比如能够使用枚举以外的东西，因为你不再受switch的约束。此外，它允许您使用相同的代码处理不同的逻辑关联（在解析器中出现）。

PS 我在上面的代码中没有使用枚举，但想法是一样的。根据我的经验，每当我遇到这个问题时，将字符串直接与预期的行为联系起来就更容易了，所以我坚持认为。

Answer 3

C ++中隐藏了一个名为Template Metaprogramming的代码生成器。您可以使用它来生成您想要的工厂。您也可以使用Variadic模板（即C ++ 11功能）。

我来到了以下代码（我有点懒得实现正确的＆＃34;最后＆＃34;专门的createThing，所以我用void作为终结符）：

enum class Thing {Ex1, Ex2, Ex3};

class Class1 { virtual void f() {} };
class Class2 : public Class1 {};
class Class3 : public Class2 {};

template <Thing val_, typename Class_> 
struct MPLFactoryPair  {
    static constexpr Thing val = val_;
    using Class = Class_;
};

template<class head, typename... tail> 
struct MPLFactory {
    static Class1* createThing(Thing thing_) {
        if(thing_ == head::val) {
            return new typename head::Class();
        }
        return MPLFactory<tail...>::createThing(thing_);
    }
};

template<typename last> 
struct MPLFactory<last> {
    static Class1* createThing(Thing thing_) {
        return nullptr;
    }
};

using ThingFactory =
    MPLFactory<MPLFactoryPair<Thing::Ex1, Class1>, 
            MPLFactoryPair<Thing::Ex2, Class2>, 
            MPLFactoryPair<Thing::Ex3, Class3>, 
            void>;

它的主要问题是你应该希望编译器优化createThing中的尾调用。 GCC使用-O2：

<+20>:    test   %eax,%eax
<+22>:    je     0x400a5e <main(int, char**)+238>
<+28>:    cmp    $0x1,%eax
<+31>:    je     0x400a83 <main(int, char**)+275>
<+37>:    cmp    $0x2,%eax
<+40>:    jne    0x400a77 <main(int, char**)+263>

所以它变成了简单的if-else。不确定它是否会生成跳转表。

这是一个测试代码：

int main(int argc, char* argv[]) {
    volatile Thing thing = Thing::Ex2;
    Class1* ptr = ThingFactory::createThing(thing);

    std::cout << "ptr = " << ptr << std::endl 
            << "<Class2>(ptr) = "  << dynamic_cast<Class2*>(ptr) << std::endl
            << "<Class3>(ptr) = "  << dynamic_cast<Class3*>(ptr) << std::endl
            << std::endl;
}

对我而言，它输出：

ptr = 0x214c010
<Class2>(ptr) = 0x214c010
<Class3>(ptr) = 0

您也可以使用boost::mpl，但这并不容易。

枚举和初始化类

3 个答案: