使用可变参数模板的工厂模式？

Question

我有一个摘要class

template <class T> struct A { /* virtual methods */ };

和几个具有各种构造函数的具体派生 classes

// The constructor of B takes 1 input
template <class T>
struct B
    : public A<T>
{
    B() { /* default ctor */ }
    B( T *input ) { /* initializer */ }

    // .. implement virtual methods
}


// The constructor of C takes 2 inputs
template <class T>
struct C
    : public A<T>
{
    double some_member;

    C() { /* default ctor */ }
    C( T *input, double& value ) { /* initializer */ }

    // .. implement virtual methods
}

我创建了一个 returns 指向 A 的工厂，我正在尝试使用可变参数模板将输入转发到所选派生 class 的构造函数。它工作正常，但是 我不得不为案例 with/without 构造函数输入复制代码，我正在寻找一种方法来防止代码重复 （见下文）。

template <class T>
struct A_Factory
{
    typedef std::shared_ptr<A> out_type;

    // Version without constructor inputs
    static out_type create( id_type id )
    {
        out_type out;
        switch (id)
        {
            // .. select the derived class
            case Type_B:
                out.reset( new B() );
                break;
        }
        return out;
    }

    // Version with constructor inputs
    template <class... Args>
    static out_type create( id_type id, Args&&... args )
    {
        out_type out;
        switch (id)
        {
            // .. select the derived class
            case Type_B:
                out.reset( new B( std::forward<Args>(args)... ) );
                break;
        }
        return out;
    }
};

很抱歉问了这么长的问题。任何缩短本文的建议表示赞赏。

Answer 1

我们可以使用 SFINAE 和 std::is_constructible type trait (h/t ) 来解决这个问题。

我们只需要一个创建函数，它将分派给其他函数：

template <class... Args>
static std::shared_ptr<A> create( id_type id, Args&&... args )
{
    switch (id) {
    case Type_B:
        return create<B>(std::forward<Args>(args)...);
    case Type_C:
        return create<C>(std::forward<Args>(args)...);
    // ...
}

每个基于标签的 create 函数将调用正确的构造函数或 return nullptr 如果这样的一个不存在：

// possible to construct
template <typename T, typename... Args>
std::enable_if_t<
    std::is_constructible<T, Args...>::value,
    std::shared_ptr<T>
>
create(Args&&... args) {
    return std::make_shared<T>(std::forward<Args>(args)...);
}

// impossible to construct
template <typename T, typename... Args>
std::enable_if_t<
    !std::is_constructible<T, Args...>::value,
    std::shared_ptr<T>
>
create(Args&&... ) {
    return nullptr;
}

使用可变参数模板的工厂模式？

Factory pattern using variadic template?

c++

factory-pattern

variadic-templates

c++11