2

我正在使用类工厂来动态创建对象。我使用这个答案是因为它的简单性（并且因为我使用的是 Qt）。

但现在我意识到我必须为我的构造函数添加一个参数

Item(bool newItem /* = true*/);

代替

Item();

对于参考答案中的代码：

template <typename T>
class ClassFactory
{
public:
    template <typename TDerived>
    void registerType(QString shape)
    {
        _createFuncs[shape] = &createFunc<TDerived>;
    }    
    T* create(QString shape)
    {
        typename QMap<QString, PCreateFunc>::const_iterator it = _createFuncs.find(shape);
        if (it != _createFuncs.end())
        {
            return it.value()();
        }
        return NULL;
    }    
private:
    template <typename TDerived>
    static T* createFunc()
    {
        return new TDerived();
    }
    typedef T* (*PCreateFunc)();
    QMap<QString, PCreateFunc> _createFuncs;
};

我注册了班级

classFactory.registerType <Type1_Item> ("type1");

需要的时候，我打电话

Item* item = classFactory.create("type1");

我试图在类工厂中添加一个额外的参数来表示构造函数参数，但我的尝试都导致错误。

为什么我需要它：简单案例：

  • 创建一个新对象 - 设置默认值；对于某些对象，它需要一个打开文件对话框，因为必须从文件中加载数据。

  • 加载对象 - 填充数据，包括包含文件信息的对象的文件名

为了能够调用“加载”函数，必须存在一个对象——这意味着如果我创建一个新对象，即使我不需要它，我也会触发一个打开文件对话框。

我看到的解决方法是有一个构造函数，然后是一个设置函数。但是......这意味着构造一个对象总是需要一个 2 函数调用，这似乎是一个糟糕的设计。

这就是为什么我正在寻找一种使用简单调用来注册和调用类的方法，例如

classFactory.registerType <Type1_Item> ("type1", bool);
Item* item = classFactory.create("type1", true);

有可能吗，我该怎么做？

4

5 回答 5

3

我能想到的一种方法是要求参数完全匹配。首先，我们将使用boost::any. 这是因为它们可能有不同的类型，所以我们需要一个异构容器：

QMap<QString, boost::any> _createFuncs;

我们的register函数将创建一个特定的函数指针来存储在说any：

template <typename TDerived, typename... T>
void registerType(QString shape)
{
    _createFuncs[shape] = &createFunc<TDerived, T...>;
}

where createFuncnow 需要额外的参数：

template <typename TDerived, typename... Args>
static T* createFunc(Args... args)
{
    return new TDerived(args...);
}

关键是我们在创造方面做什么。我们需要检查any我们为特定类型存储的是否是正确的类型：

template <typename... Args>
T* create(QString shape, Args... args)
{
    using FPtr = T*(*)(Args...);

    auto it = _createFuncs.find(shape);
    if (it != _createFuncs.end())
    {
        // ok, it points to some any. is it the right any?
        FPtr* fptr = boost::any_cast<FPtr>(&it.value());
        if (fptr) {
            return (*fptr)(args...);
        }

        // alternatively to the above, we can have createFunc
        // throw bad_any_cast if you pass the wrong arguments
        // which could be a loud, explicit failure rather than 
        // a silent one
        return boost::any_cast<FPtr>(it.value())(args...);
    }
    return nullptr;
}

这将允许它工作：

classFactory.registerType<Item, bool>("type1");
                              ^^^^^^
                              arg list

Item* item = classFactory.create("type1", true);
Item* item2 = classFactory.create<bool>("type1", 1);

但这会失败，因为any需要 a bool，而不是int：

Item* item3 = classFactory.create("type1", 1);
于 2015-05-11T18:19:05.033 回答
2

@Barry 的回答非常完整。但是，如果您只是对可以构造具有不同参数的构造函数的对象的简化工厂感兴趣，您可以执行以下操作：

// Factory method for classes having constructors
// that take an arbitary number of parameters

#include <memory>

class Factory
{
public:
    template<typename T, typename... Params>
    static std::unique_ptr<T> create(Params... params)
    {
        return std::make_unique<T>(params...);
    }
};

struct Foo
{
    Foo(int) {};
};

struct Bar
{
    Bar(bool, double) {};
};

int main()
{
    std::shared_ptr<Foo> foo = Factory::create<Foo>(42);
    std::shared_ptr<Bar> bar = Factory::create<Bar>(true, 42.5);
}

请注意，我在这里使用了智能指针，因此您不再需要跟踪new/deletes。

于 2015-05-11T18:26:00.127 回答
1

您可以使用此修改后的版本

template <typename T, typename ... Ts>
class ClassFactory
{
public:
    template <typename TDerived>
    void registerType(QString shape)
    {
        _createFuncs[shape] = &createFunc<TDerived>;
    }    
    T* create(QString shape, Ts... args)
    {
        typename QMap<QString, PCreateFunc>::const_iterator it = _createFuncs.find(shape);
        if (it != _createFuncs.end())
        {
            return it.value()(args...);
        }
        return nullptr;
    }    
private:
    template <typename TDerived>
    static T* createFunc(Ts... args)
    {
        return new TDerived(args);
    }
    typedef T* (*PCreateFunc)(Ts...);
    QMap<QString, PCreateFunc> _createFuncs;
};

并使用它

ClassFactory<Item, bool> classFactory;
classFactory.registerType <Type1_Item> ("type1");

Item* item = classFactory.create("type1", true);
于 2015-05-11T18:28:08.947 回答
0

如果所有对象都具有相同的参数类型（这里是布尔值），只需像这样更改 create 函数：

T* create(QString shape, bool param)   //modified
{
    typename QMap<QString, PCreateFunc>::const_iterator it = _createFuncs.find(shape);
    if (it != _createFuncs.end())
    {
        return it.value()(param);  //modified
    }
    return NULL;
}

并更改 createFunc ：

static T* createFunc(bool param)
{
    return new TDerived(param);
}
typedef T* (*PCreateFunc)(bool);
于 2015-05-11T18:13:09.687 回答
-1

我已经使用 C++11 参数包完成了这项工作：

// pack.cc
#include <utility>

template<class T, typename... P>
T * create(P&&... params)
{
    return new T(std::forward<P>(params)...);
}


class X
{
public:
    X() {}
};

class Y
{
public:
    Y(int) {}
};

int main()
{
    X * x = create<X>();
    Y * y = create<Y>(1);

    delete x;
    delete y;
}

编译这个例子g++ -std=c++11 -o pack pack.cc

于 2015-05-11T18:38:26.663 回答