c++ - 如何创建一个工厂函数模板来构造给定任意数量参数的对象？

Question

用一些代码更容易解​​释，所以我先举个例子:

#include <iostream>
#include <vector>

class Base {
public:
    int integer;

    Base() : integer(0) {}
    Base(int i) : integer(i) {}
};

class Double: public Base {
public:
    Double(int i) { integer = i * 2; }
};

class Triple: public Base {
public:
    Triple(int i) { integer = i * 3; }
};

template<typename T>
Base* createBaseObject(int i) {
    return new T(i);
};

int main() {
    std::vector<Base*> objects;

    objects.push_back(createBaseObject<Double>(2));
    objects.push_back(createBaseObject<Triple>(2));

    for(int i = 0; i < objects.size(); ++i) {
        std::cout << objects[i]->integer << std::endl;
    }

    std::cin.get();
    return 0;
}

我正在尝试创建一个函数，该函数将返回一个 Base 指针，该指针指向从 Base 派生的对象。在上面的代码中，函数 createBaseObject 允许我这样做，但它限制了我，因为它只能创建将单个参数带入其构造函数的派生类。

例如，如果我想创建一个派生类 Multiply:

class Multiply: public Base {
public:
    Multiply(int i, int amount) { integer = i * amount; }
};

createBaseObject 无法创建 Multiply 对象，因为它的构造函数有两个参数。

我最终想做这样的事情:

struct BaseCreator {
    typedef Base* (*funcPtr)(int);
    BaseCreator(std::string name, funcPtr f) : identifier(name), func(f) {}

    std::string identifier;
    funcPtr func;
};

然后，例如，当我得到与 identifier 匹配的输入时，我可以创建一个与该标识符相关联的任何派生类的新对象以及输入的任何参数，并将其推送到容器中。

p>

---

在阅读了一些回复后，我认为这样的东西可以满足我的需要，能够按程序创建一个对象的实例？不过我对模板不太了解，所以我不知道这是否合法。

struct CreatorBase {
    std::string identifier;
    CreatorBase(std::string name) : identifier(name) {}

    template<typename... Args>
    virtual Base* createObject(Args... as) = 0;
};

template<typename T>
struct Creator: public CreatorBase {
    typedef T type;

    template<typename... Args>
    Base* createObject(Args... as) {
        return new type(as...);
    }
};

---

好的，这是我到目前为止设法想出的另一个半解决方案:

#include <boost\lambda\bind.hpp>
#include <boost\lambda\construct.hpp>
#include <boost\function.hpp>

using namespace boost::lambda;
boost::function<Base(int)> dbl = bind(constructor<Double>(), _1);
boost::function<Base(int, int)> mult = bind(constructor<Multiply>(), _1, _2);

这与原来的限制相同，因为我不能有一个指针同时指向 dbl 和 mult。

Answer 1

C++11 variadic templates可以为您做这件事。

您已经有了新的派生类:

class Multiply: public Base {
public:
    Multiply(int i, int amount) { integer = i * amount; }
};

然后改变你的工厂:

template<typename T, typename... Args>
Base* createBaseObject(Args... as) {
    return new T(as...);
};

最后，允许推导参数:

objects.push_back(createBaseObject<Multiply>(3,4));

Live demo.

---

不过，正如其他人所说，这一切似乎都毫无意义。大概您的真实用例不那么做作。