7

我需要一种基于作为 std::string 传递的类名来实例化对象的方法。这现在有效，但需要概括：

void* create(std::string name) {
    if(name == "classOne") return new ClassOne();
    else if(name == "classTwo") return new ClassTwo();
    /* ... */
}

我没有的：

  • 控制要实例化的类：可以是 30 个方类。不能对此类进行任何更改（即基础祖先、多态创建者方法等...）
  • 完整的类名列表：以后可以添加更多类，并且不应该对该工厂进行更改。
  • 要实例化的类的包装器：作为前两点的结果。

其他任何事情都是一回事。

最佳用例场景将是：

int main() {
    void *obj = create("classTree"); // create object based on the string name
    /* ... */
    // once we know by context which specific class we are dealing with
    ClassTree *ct = (ClassTree*)obj; // cast to appropiate class
    std::cout << ct->getSomeText() << std::endl; // use object
}

作为一个方面，也许是无关紧要的注意事项，考虑到要实例化的对象可能来自一个类或一个结构。

附加信息

我看到需要更多的上下文。这是我的特定用例，简化：

// registration mechanism
int main() {
    std::map< std::string, void(*func)(std::string, void*) > processors; // map of processors by class name
    processors["ClassFour"] = (void(*)(std::string, void*)) &classFourMessageProcessor; // register processor (cast needed from specific to generic)
}
// function receiving string messages
void externalMessageHandler(std::string msg) {
    std::string objType = extractTypeFromMessageHeader(msg); // extract type from message
    // now that we know what we are dealing with, create the specific object
    void *obj = create(objType); // << creator needed
    processors[objType](msg, obj); // dispatch message to process
}
// previously registered message processor
void classFourMessageProcessor(std::String msg, ClassFour *obj) {
    std::string streetAddress = msg.substr(10, 15); // knowing the kind of message we can extract information
    obj->moveTheEtherTo(streetAddress); // use the created object
}

附加信息

我正在使用带有最新 GNU 编译器的 C++11。

4

4 回答 4

5

您可以为每个类类型存储一个工厂函数。一个简单的方法是使用模板

template <typename T>
void* creator() {
  return new T();
}

并将它们也存储在地图中（即“ClassFour”链接到creator<ClassFour>和ClassFourMessageProcessor）。

编辑：为澄清起见，processors成为

typedef void* (*CreatorFunc)();
typedef void (*ProcessorFunc)(std::string, void*);

typedef std::pair<CreatorFunc, ProcessorFunc> Entry;
std::map< std::string, Entry > processors;

添加一个新类很简单

processors["SomeClass"] = Entry(creator<SomeClass>, ClassFourMessageProcessor);
于 2013-09-26T19:46:41.267 回答
0

这是一个例子：

  1. 对于每个类，创建一个 createInsrance() 函数（不是方法），该函数实例化一个实例并返回一个转换为 void* 的指针。请注意，此函数不是类的一部分 - 只是一个普通函数。
  2. 维护一个字符串映射到函数指针到 createInstance 类型函数。
  3. “注册”映射中的每个相关类 - 将字符串函数指针对添加到映射中。
  4. 现在通用 create 将在映射中搜索字符串并调用特定的 createInstane，返回新实例的 ptr。

现在您没有对类进行任何更改，并且可以在不重新编程工厂的情况下添加更多类。您可能至少将 #1 作为模板 - 确保让编译器实例化特定的实现。

于 2013-09-26T19:46:55.160 回答
0

也许以下带有查找表的方法将是一个不错的解决方案。

（注意：我不知道您使用的是哪个编译器，因此此解决方案适用于 c++03，如果您使用支持 c++11 的编译器，则可以使用 unordered_map 代替 map）

（注 2：您也可以使用智能指针，并注意返回值，这个例子我只想展示一个方法）

#include <iostream>
#include <string>
#include <map>
#include <vector>


struct ClassMaker
{
    virtual void* getInstance() const = 0;
    virtual ~ClassMaker() {}
};

class Factory
{
private:
    std::map<std::string, ClassMaker*> lookupTable;
    typedef typename std::map<std::string, ClassMaker*>::iterator Iterator;
public:
    void addClass(const std::string& key, ClassMaker* const newClassMaker)
    {
        lookupTable[key] = newClassMaker;
    }

    void* create(const std::string& key)
    {
        void* result = NULL;
        Iterator it = lookupTable.find(key);
        
        if(it != lookupTable.end())
            result = (it->second)->getInstance();
        return result;
    }

    void releaseTable()
    {
        for (Iterator it = lookupTable.begin(); it != lookupTable.end(); ++it)
            delete it->second;
    }
};

struct IntCreator : public ClassMaker
{
    void* getInstance() const
    {
        return new int;
    }

};

struct StringCreator : public ClassMaker
{
    void* getInstance() const
    {
        return new std::string;
    }

};



int main()
{
    Factory myFactory;
    myFactory.addClass("int", new IntCreator);
    myFactory.addClass("string", new StringCreator);
    
    int* myInt = reinterpret_cast<int*>(myFactory.create("int"));
    *myInt = 10;
    std::cout<< *myInt << std::endl;
    delete myInt;
    myFactory.releaseTable();
    return 0;
}
于 2013-09-26T20:12:03.033 回答
-1

你会考虑 Boost.MPL 吗？与 STL 不同，它允许创建包含类型而不是实例的容器。拥有从字符串到类型的映射将为您提供所需的工厂，不是吗？

于 2013-09-26T20:30:08.710 回答