std:：使用可变模板函数绑定

Question

我试图编写一个通用的obj工厂，使用可变模板调用各种类的构造函数。代码如下：

#include <iostream>
#include <string>
#include <memory>
#include <functional>
#include <unordered_map>

template<typename T>
class ObjFactory {
public:
    typedef std::shared_ptr<T>              ObjPtr;
    typedef std::function<ObjPtr(void)>     CreatorFunc;
public:
    void registerCreator(const std::string &name, const CreatorFunc &creator)
    { m_dictCreator[name] = creator; }

    ObjPtr getObj(const std::string &name) const
    {
        auto it = m_dictCreator.find(name);
        return (it == m_dictCreator.end() ? nullptr : (it->second)());
    }
private:
    std::unordered_map<std::string, CreatorFunc>   m_dictCreator;
};


using namespace std;

struct Base {
    virtual ~Base() {}
    virtual void greet() const
    { cout << "I am Base" << endl; }
};

struct Derived : Base {
    Derived() : x(0), y(0) {}
    Derived(int a, int b) : x(a), y(b) {}
    int x, y;

    virtual void greet() const
    { cout << "I am Derived x = " << x << " y = " << y << endl; }
};

template<typename T, typename... Args>
std::shared_ptr<T> create_obj(Args... args)  // This OK
// std::shared_ptr<T> create_obj(Args&&... args) // WRONG
{ return std::make_shared<T>(std::forward<Args>(args)...); }

int main()
{
    ObjFactory<Base> factory;
    factory.registerCreator("default", create_obj<Derived>);
    factory.registerCreator("withArgs", std::bind(create_obj<Derived, int, int>, 1, 2));

    do {
        auto pObj = factory.getObj("default1");
        if (pObj) { pObj->greet(); }
    } while (0);

    do {
        auto pObj = factory.getObj("withArgs");
        if (pObj) { pObj->greet(); }
    } while (0);

    return 0;
}

在大多数例子中，变量arg总是这样写“Args”

错误：没有可行的转换从'__bind（

在移除“

但我不知道为什么？

Answer 1

当使用转发引用时，您需要让参数被推断出来，否则您无法完美地转发它们，因为您不知道用于它们的真正类型。

在您的案例中，您给出了一个类型create\u obj

您将可调用项分配给一个常量CreatorFunc

替换create_obj

真正的解决方案是使用lambda。

Answer 2

通用参考仅在推导的上下文中起作用。当显式指定模板参数时，它们不会像您期望的那样工作。

给定函数模板

template <typename... Args>
void foo(Args&&... args) {}

还有那个电话

int a = 1;
int b = 2;
foo(a, b);

Args将被推断为{int

如果使用参数的右值调用它（即foo（1，2）），则Args将被推断为{int，int}，并且Args中的值类型将变为{int>

这是通用引用的基础，现在让我们看看当你调用时会发生什么

auto fn = std::bind(foo<int, int>, 1, 2);
fn();

这里，您不允许进行模板参数推断，因此Args是{int，int}，因此foo需要{int>类型的参数

正确执行此操作的方法是使用lambda而不是std:：bind：

auto fn = []() { foo(1, 2); };
fn();

使用lambda时，模板参数推断工作正常，1和2保持右值。一切都按预期进行，通用引用也发挥了作用，因为它们是在推导的上下文中使用的。