与c++中Prototype模式的示例解释混淆

Question

有人发布了关于这个模式的问题，但没有解决我脑海中提出的问题，所以发布了我的问题……

在上面的例子中，如果所有的实例都是由s_prototypes变量初始化的，下一次如果克隆方法中的任何对象都将被新对象替换，那么现有的对象会发生什么？？它会造成内存泄漏吗？？

就我对上述例子的理解，有两种说法使我感到困惑

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

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

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];
}

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

Stooge* Factory::s_prototypes[] = {
   0, new Larry, new Moe, new Curly
};
Stooge* Factory::make_stooge( int choice ) {
   return s_prototypes[choice]->clone();
}

Output
Larry(1) Moe(2) Curly(3) Go(0): 2
Larry(1) Moe(2) Curly(3) Go(0): 1
Larry(1) Moe(2) Curly(3) Go(0): 3
Larry(1) Moe(2) Curly(3) Go(0): 0
Moe: slap head
Larry: poke eyes
Curly: suffer abuse

但是当我们通过make_stooge方法调用克隆方法时，它将返回新对象，如果返回新对象并将其替换为现有对象，则现有对象将在此处造成内存泄漏(因为新运算符完全创建独立对象，而不是在此处返回现有对象)……

这个例子把我搞糊涂了……

Answer 1

您的代码中没有内存泄漏，因为新创建的对象小心地存储在vector (这里是roles)中。

然后从该向量中使用它们，并在程序结束之前销毁它们：

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

但在退出main之前使用return 0;会更好……

为要派生的类创建虚拟析构函数是一种很好的做法:如果Larry等类中的任何一个具有非平凡的析构函数，那么当您通过基类指针删除它们时，就不会使用它：

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

对于s_prototypes的4个静态对象，它们在调用main之前在程序启动时被静态初始化，并且它们永远不会被修改。他们的clone方法被调用来创建新对象，但是s_prototype仍然指向旧对象-这就是为什么存储和删除新创建的对象很重要的原因。

这4个对象确实存在内存泄漏，因为它们永远不会被显式销毁。通常认为以这种方式泄漏静态对象是可以接受，因为它们的生命周期延长到程序结束，此时所有的内存都被释放了。如果调用析构函数很重要，您还应该为它们创建静态实例：

static Larry _larry;
static Moe _moe;
static Curly _curly;
Stooge* Factory::s_prototypes[] = {
   0, &_larry, &_moe, &_curly
};

如果您使用以下命令显式销毁：

   virtual ~Stooge() {
       cout << "Delete " << this << endl;
   }

稍微改变一下程序的结尾：

   for (int i=0; i < roles.size(); ++i)
      delete roles[i];
   cout << "END" << endl;
   return 0;
}

输出将如下所示：

...
Delete 001ADB78
END
Delete 00F350A0
Delete 00F3509C
Delete 00F35098

清楚地显示静态对象在程序结束后被销毁。

Answer 2

嗯，你说的对，s_prototypes中的指针永远不会被删除，但至少这些对象打算在程序的整个运行时都存在，所以除非有一个特定的操作需要在它们的析构函数中执行，否则如果它们在程序终止之前没有被删除，那就不是世界末日。这远远比不上有可能持续泄漏内存的代码那么糟糕，因为这会导致程序使用的内存不断增加。

如果您愿意，可以将它们替换为静态实例，如下所示：

#include <iostream>
#include <vector>
using namespace std;

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

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

class Factory {
public:
   static Stooge* make_stooge( int choice );
private:
   static Larry larry;
   static Curly curly;
   static Moe moe;
};

int main() {
   vector<Stooge*> 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];
}

Stooge* Factory::make_stooge( int choice ) {
   switch(choice) {
   case 1:
      return larry.clone();
   case 2:
      return curly.clone();
   case 3:
      return moe.clone();
   default:
      return nullptr;
   }
}