c++ - 用于类构建的 2 个模板化构造函数与可变参数模板的组合。如何？

Question

我创建了一些小型工厂类。请参阅下面的代码。工厂使用带有键和类创建器函数的简单映射。挑战在于我想为 createInstance 函数使用不同的签名。这样，我就可以使用具有不同构造函数签名的不同派生类。因此，我将能够将不同的值传递给类的构造函数。

因为我不能在 std::function 和 std::map 中存储具有不同签名的函数，所以我写了一个简短的包装器来“删除”类型参数部分。所以，基本上我可以将函数存储在 std::function 中，最后存储在 std::any 中。

代码运行良好。您可以毫无问题地编译和运行它。

另外附上一些测试代码。

现在我的问题:

我试图在我的类 “Creator” 中只提出一个构造函数。但我无法做到这一点。在我看来应该是可以的。我想请求您的支持，以提出一个可能的解决方案。

请注意:我正处于重构阶段。所以代码还不够“完美”。

#include <iostream>
#include <map>
#include <utility>
#include <functional>
#include <any>

// Some demo classes ----------------------------------------------------------------------------------
struct Base {
    Base(int d) : data(d) {};
    virtual ~Base() { std::cout << "Destructor Base\n"; }
    virtual void print() { std::cout << "Print Base\n"; }
    int data{};
};
struct Child1 : public Base {
    Child1(int d, std::string s) : Base(d) { std::cout << "Constructor Child1 " << d << " " << s << "\n"; }
    virtual ~Child1() { std::cout << "Destructor Child1\n"; }
    virtual void print() { std::cout << "Print Child1: " << data << "\n"; }
};
struct Child2 : public Base {
    Child2(int d, char c, long l) : Base(d) { std::cout << "Constructor Child2 " << d << " " << c << " " << l << "\n"; }
    virtual ~Child2() { std::cout << "Destructor Child2\n"; }
    virtual void print() { std::cout << "Print Child2: " << data << "\n"; }
};
struct Child3 : public Base {
    Child3(int d, long l, char c, std::string s) : Base(d) { std::cout << "Constructor Child3 " << d << " " << l << " " << c << " " << s << "\n"; }
    virtual ~Child3() { std::cout << "Destructor Child3\n"; }
    virtual void print() { std::cout << "Print Child3: " << data << "\n"; }
};


using Ret = std::unique_ptr<Base>;

template <typename ... Args>
using Func = std::function<Ret(Args...)>;

// ---------------------------------------------------------------------------------------------------
// Hide away the different signatures for std::function
class Creator
{
public:
    Creator() {}

    // I want to combine the follwong 2 constructors in one
    template<typename Function>
    Creator(Function&& fun) : Creator(std::function(fun)) {}
    template<typename ... Args>
    Creator(Func<Args...> fun) : m_any(fun) {}

    template<typename ... Args>
    Ret operator()(Args ... args)   { return std::any_cast<Func<Args...>>(m_any)(args...);  }
protected:
    std::any m_any;
};


template <class Child, typename ...Args>
std::unique_ptr<Base> createClass(Args...args) { return std::make_unique<Child>(args...); }

// The Factory ----------------------------------------------------------------------------------------
template <class Key>
class Factory
{
    std::map<Key, Creator> selector;
public:
    Factory(std::initializer_list<std::pair<const Key, Creator>> il) : selector(il) {}

    template <typename ... Args>
    Ret createInstance(Key key, Args ... args) {
        if (selector.find(key) != selector.end()) {
            return selector[key](args ...);
        }
        else {
            return std::make_unique<Base>(0);
        }
    }
};

int main()
{
    Factory<int> factory { 
        {1, createClass<Child1, int, std::string>},
        {2, createClass<Child2, int, char, long>},
        {3, createClass<Child3, int, long, char, std::string>}
    };

    // Some test values
    std::string s1(" Hello1 "); std::string s3(" Hello3 ");
    int i = 1;  const int ci = 1;   int& ri = i;    const int& cri = i;   int&& rri = 1;

    std::unique_ptr<Base> b1 = factory.createInstance(1,   1, s1);
    std::unique_ptr<Base> b2 = factory.createInstance(2,   2, '2', 2L);
    std::unique_ptr<Base> b3 = factory.createInstance(3,   3, 3L, '3', s3);

    b1->print();
    b2->print();
    b3->print();
    b1 = factory.createInstance(2, 4, '4', 4L);
    b1->print();
    return 0;
}

所以，再次，我想摆脱 2 个构造函数

    template<typename Function>
    Creator(Function&& fun) : Creator(std::function(fun)) {}

    template<typename ... Args>
    Creator(Func<Args...> fun) : m_any(fun) {}

最后只有一个。怎么办？

抱歉代码太长。

Answer 1

如何简单地删除采用 std::function 的构造函数？

template<typename Function>
Creator(Function&& fun) : m_any(std::function(fun)) {}

只有当 fun 还不是 std::function 时，它才会被包装。如果它是一个 std::function 那么它就是一个 noop。

Live example

---

看看你的代码，你只使用函数指针作为你的工厂函数。您可以直接使用函数指针而不是 std::function 来为自己节省一些间接寻址，它已经是一个类似于 std::any 的层。

template <typename ... Args>
using Func = std::add_pointer_t<Ret(Args...)>;

// in you class:

template<typename Function, std::enable_if_t<std::is_pointer_v<Function>, int> = 0>
Creator(Function fun) : m_any(fun) {}

如果你使用它，在 C++20 中你可以移除丑陋的 enable if 并使用一个概念:

template<typename T>
concept FunctionPointer = requires(T t) {
    requires std::is_pointer_v<T>;
    requires std::is_function_v<std::remove_pointer_t<T>>;
    { std::function(t) };
};

// then in your class:

Creator(FunctionPointer auto fun) : m_any(fun) {}

Live example