原型设计模式示例(c++)

Question

我正在学习原型设计模式，并从一个在这篇文章上用源制造表示的例子中感到困惑。

class Stooge
{
public:
   virtual void slap_stick() = 0;
   virtual Stooge* clone() = 0;
};

class Larry : public Stooge
{
public:
   void slap_stick()
   {
      cout << "Larry: poke eyes\n";
   }
   Stooge*   clone() { return new Larry; }   
};
class Moe : public Stooge
{
public:
   void slap_stick()
   {
      cout << "Moe: slap head\n";
   }
   Stooge*   clone() { return new Moe; }   
};
class Curly : public Stooge
{
public:
   void slap_stick()
   {
      cout << "Curly: suffer abuse\n";
   }
   Stooge*   clone() { return new Curly; }
};

class Factory
{
public:
   static Stooge* make_stooge( int choice );
private:
   static Stooge* s_prototypes[4];
};

Stooge* Factory::s_prototypes[] = {0, new Larry, new Moe, new Curly};

Stooge* Factory::make_stooge( int choice )
{
   return s_prototypes[choice]->clone();
}

int main()
{
   vector roles;
   int    choice;

   while (true)
   {
      cout << "Larry(1) Moe(2) Curly(3) Go(0): ";
      cin >> choice;
      if (choice == 0)
         break;
      roles.push_back(Factory::make_stooge( choice ) );
   }

   for (int i=0; i < roles.size(); ++i)
      roles[i]->slap_stick();
   for (int i=0; i < roles.size(); ++i)
      delete roles[i];
}

基于描述的原型设计模式

• 指定要使用原型实例创建的对象类型，并通过复制该原型创建新对象。

根据这的说法。原型设计模式是一种通过复制或克隆现有对象的属性来实例化类的设计模式。

据我所知，复制类的正常方法是使用复制构造函数、重载operator=或实现克隆函数，通过复制现有对象的所有属性来实例化一个新对象。

在上面的示例中，我不知道它是如何通过复制原型来实现创建新对象的，因为或者复制构造函数，既没有重载operator=，也没有定义适当的克隆函数。

所以，我可以假设这不是原型设计模式的实现吗？或者我的假设是错误的，我不理解这个例子？

编辑： As @宋元窑

在这个例子中，它是新创建的对象，没有复制任何东西

因此，我认为上面的例子不是原型模式的适当例子，因为它并不代表原型模式的主要目标。

Answer 1

首先，不需要克隆调用方法的对象，您完全可能有一个Manager或Factory，其中有一个用于克隆对象的方法，即：

Object Factory::clone( Object &){

}

此外，确实可以使用复制构造函数，但是复制构造器的缺点是它只适用于具体的类。如果为了更好的设计决策，您只向用户提供了object (接口/纯虚拟)，那么您就不能在客户端使用复制构造函数，所以如果预期的使用是克隆一个项，那么可以通过添加Clone方法来解决这个问题

class BaseVirtualClass{
public:
    virtual int foo() = 0;
    virtual BaseVirtualClass * clone() = 0;
    virtual ~BaseVirtualClass(){}
};

class DerivedClass: public BaseVirtualClass{
    int state;
public:
    DerivedClass(int a):state(a){}
    DerivedClass( const DerivedClass & other)
        : state(other.state){}
    int foo(){ // override
        return state;
    }

    BaseVirtualClass * clone(){ //override
         // I'm using copy constructor here, but hidden from user
         return new DerivedClass( *this);
    }
};

用法：

BaseVirtualClass * obj = factory.createObject();
BaseVirtualClass * clone = obj->clone();

有时你也想通过工厂来做这件事：

BaseVirtualClass * obj = factory.createObject();
BaseVirtualClass * clone = factory.clone(obj);

注意:除了修复缺少的复制构造函数外，当只提供指向抽象类的指针时，Clone方法有明确的意图复制创建深拷贝的对象状态，而不必编写锅炉板代码来重新创建处于特定状态的对象。当创建对象的责任不是对象(因为您必须使用带有自定义分配器或其他复杂依赖项的工厂)时，克隆方法将被移到Factory中。

编辑：

在我看来，提问者在互联网上找到的代码示例似乎是一个边缘案例。这些对象在技术上是克隆的(除了类型之外，它们没有状态，因此它们具有相同的状态)，但我不认为这是原型模式的一个很好的例子：

1. 当有一些具有有趣的状态的复杂对象需要以某种方式复制时，我想使用原型模式。
2. 最重要的部分是状态的复制，因此内部实现也应该是显式的，说明(为了内部文档的目的，保留相同状态的对象可能是不明确的)。