C++如何替换构造函数开关？

Question

我想用更优雅的东西代替大开关。

class Base
{
public:
  Base(void*data, int size);
  virtual void Something() = 0;
}
class A : public Base
{
public:
  A(void*data, int size) : Base(data, size) {}
  void Something() override;
}
class B : public Base
{
public:
  B(void*data, int size) : Base(data, size) {}
  void Something() override;
}
...

{
  char c = input;
  switch (c)
  {
    case 'a':
    {
      A obj(data, size);
      obj.Something();
      break;
    }
    case 'b':
    {
      B obj(data, size);
      obj.Something();
      break;
    }
    ...
  }
}

正如您在示例类中看到的那样，A 和 B 与外部没有区别。 我想找到一种方法来消除仅实例化正确类并在其上调用相同方法的开关，在我的真实代码中，该开关超过 1000 行长，并且有更多的类，但我找不到任何方法摆脱它。

在实际代码中，我有 2 个枚举而不是 char，还有更多开关，但我希望问题很清楚。

我的一个想法是在基类上使用模板，但我没有找到一种方法来实例化正确的子类而不需要那个巨大的开关。

编辑 我从网络接收数据包并想解析它并处理它。这些类a, b, ... 没有任何私有或公共成员，基类只有指向日期的原始指针和指向响应套接字的共享指针（也来自构造函数）。

我希望编译器使用 templates? 或其他一些机制为我生成该开关，以删除重复的源代码。目前它仍处于测试阶段，但它每秒处理大约 1000 个数据包，所以我不想在堆上分配和释放时移除开关并失去性能。

Answer 1

找到static_for 的实现，它本身就很简单：

using list = std::tuple<A, B, C, D, E, F, G, ...>;

const auto n = c - 'a';
static_for<std::tuple_size<list>()>([&](auto N){
    if (n != N)
        return;
    using T = std::tuple_element_t<list, N>;
    T obj(data, size);
    obj.Something();
});

进一步考虑：

1. 如果它们都具有相同的多态接口，您可以决定只使用它来创建对象。

2. 如果你的射程中有空位，if constexpr 和 std::is_same 是你的朋友。

3. 使用一些专用的类型列表类型而不是 std::tuple 可能会更好，但这在紧要关头可以工作。

static_for() 的未完善、快速和肮脏的示例实现：

template <std::size_t Is, class F>
void static_for_impl(F&& f, std::index_sequence<Is...>) {
    f(std::integral_constant<std::size_t, Is>()), ...;
}

template <std::size_t N, class F>
void static_for(F&& f) {
    static_for_impl(f, std::make_index_sequence<N>());
}

Answer 2

如果构造函数完全相同并且Something 方法的调用方式相似，那么您应该可以使用这样的模板：

template<typename T>
void DoSomething(void*data, int size){
    T t(data, size);
    t.Something();
}
..
{
    switch(input){
        case 'a': DoSomething<A>(..); break;
        case 'b': DoSomething<B>(..); break;
    }
}

如果您想验证模板是Base 的派生类，您可以使用is_base_of。

由于您打开了一个未知变量（在本例中为 char），我不确定您将如何最小化开关，除非遵循模式 suggested by Alan Birtles。

Answer 3

这样的事情应该可以工作：

#include <map>
#include <functional>
#include <memory>

typedef std::function< std::unique_ptr< Base >( void* data, int size ) > Factory;
std::map< char, Factory > factories =
{
    { 'a', []( void* data, int size ){ return std::make_unique<A>( data, size ); } },
    { 'b', []( void* data, int size ){ return std::make_unique<B>( data, size ); } }
};
char input = 'a';
void* data = 0;
int size = 0;
auto factory = factories.find( input );
if ( factory != factories.end() )
{
    factory->second( data, size )->Something();
}

您只需在每个类的工厂列表中添加一行。

如果您使用的是从 0 开始的连续值的枚举，那么您可以只使用数组而不是 std::map，例如：

enum class Class
{
    a,
    b
};

Factory factories[] =
{
    []( void* data, int size ){ return std::make_unique<A>( data, size ); },
    []( void* data, int size ){ return std::make_unique<B>( data, size ); }
};
Class input = Class::a;
factories[static_cast<size_t>(input)]( data, size )->Something();

Answer 4

您可以使用简单的工厂方法通过所需的类型和构造函数参数创建对象，如下例所示。使用继承和虚函数时不要忘记虚析构函数。

#include <memory>

class Base
{
public:
    Base(void* data, int size) {};
    virtual ~Base() {}
    virtual void Something() = 0;
};

class A : public Base
{
public:
    A(void* data, int size) : Base(data, size) {}
    void Something() override {};
};

class B : public Base
{
public:
    B(void* data, int size) : Base(data, size) {}
    void Something() override {};
};

Base* MyFactory(char type, void* data, int size)
{
    switch (type)
    {
        case 'a': return new A(data, size);
        case 'b': return new B(data, size);
        default:
            return nullptr;
    }
}

int main()
{
    std::unique_ptr<Base> obj1(MyFactory('a', nullptr, 1));
    obj1->Something();
    std::unique_ptr<Base> obj2(MyFactory('b', nullptr, 1));
    obj2->Something();
}