1

我有一个类（MyFactory），它产生 A 类型的对象。（myFactory 将是一个实例）我想允许用户扩展 A 类（例如到 B 类），并覆盖 A 的虚拟方法。

例如，不想扩展 A 的用户：

A* myObject = myFactoryInstance.createObject();

而我目前对使用 B 扩展 A 的用户的技巧：

B* myObjectPrepare = new B()
myFactoryInstance.setNextObject( myObjectPrepare );
A* myObject = myFactoryInstance.createObject(); // Will look for a "next_object"
     /* Here, myObject (which is myObjectPrepare modified by createObject) 
        methods will dynamically link to B class methods. */

我的目标是促进这个操作。

.

我试过 ：

  template <class T>
  void MyFactory::set_requests_class() {
      new T(); 
      /* I don't want an instance, now. Just memorize class type
         at compilation time, and make instances of T along exec
      */
  }

（用法：set_requests_class()；问题：我不想生成实例）

这可能是一个解决方案：

myFactoryInstance.createObject<YourObjectTypeHere>();

但我不想强制模板参数（属性的默认参数只能从 c++11 开始）：我想让不想扩展 A 的用户保持非常简单。我不能出于同样的原因，修改“createObject”签名。

（我未来的技巧是实例化 B 对象，将其保留为属性并为新实例克隆它）

提前感谢您（任何建议将不胜感激）

4

1 回答 1

2

最简单的方法就是重载createObject。看这个例子：

class A
{
public:
    A() { std::cout << "A"; }
};

class Subclass1 : public A
{
public:
    Subclass1() { std::cout << "Subclass1"; }
};

class AFactory
{
public:
    A* createInstance()
    {
        return new A();
    }
    template<typename Tsubclass>
    A* createInstance()
    {
        return new Tsubclass();
    }
};

int main()
{
    AFactory fact;
    A* pa = fact.createInstance();// creates A
    A* psubclass1 = fact.createInstance<Subclass1>();// creates Subclass1

    delete pa;
    delete psubclass1;
    return 0;
}

如果您需要保留您的设计，在实际创建对象之前设置要创建的类型，那么您可以使用如下所示的辅助工厂来完成。不过，这不是一个很好的设计。基本上，工厂类现在基本上只是充当转换结果的包装器。从外面看，似乎有更好的设计。

struct A
{
    A() { std::cout << "A"; }
};

struct Subclass1 : A
{
    Subclass1() { std::cout << "Subclass1"; }
};

struct GenericAFactoryBase
{
    virtual A* createInstance() = 0;
};

template<typename Tsubclass>
struct GenericAFactory : GenericAFactoryBase
{
    A* createInstance() { return new Tsubclass(); }
};

struct AFactory
{
    std::shared_ptr<GenericAFactoryBase> genericFactory;

    AFactory()
    {
        genericFactory.reset(new GenericAFactory<A>());
    }

    A* createInstance()
    {
        return genericFactory->createInstance();
    }
    template<typename Tsubclass>
    void SetType()
    {
        genericFactory.reset(new GenericAFactory<Tsubclass>());
    }
};

int main()
{
    AFactory fact;
    A* pa = fact.createInstance();// creates A

    fact.SetType<Subclass1>();
    A* psubclass1 = fact.createInstance();// creates Subclass1

    delete pa;
    delete psubclass1;
    return 0;
}
于 2012-09-22T22:17:33.790 回答