Question

class Cloneable
{
 public:
   virtual Cloneable* clone() const = 0; //return copy of itself
   virtual ~Cloneable() {}
};

class A
{
 public:
   A(const A& a);    
   ~A();  

 private:
   Cloneable* b;
   Cloneable* c;
   std::string* s;     
};

A::~A()  
{
 delete b;
 delete c;
 delete s;
}

请帮助我理解可复制模式。我不明白如何实现A类的构造函数，复制构造函数以及如何使用它？

Answer 1

首先，您需要区分复制构造函数和克隆模式。

复制构造函数是一个用于创建类副本的构造函数。

MyClass a;
MyClass copy(a); // calls the copy constructor

您（通常）不需要自己实现它，编译器会为您创建一个所谓的隐式复制构造函数。但是，如果您需要实现（例如，因为您编写了管理资源的类），请考虑规则为5（Rule-of-Three becomes Rule-of-Five with C++11?）。

复制构造函数不是虚拟的（事实上，构造函数永远不是虚拟的）。

克隆模式的典型用例是：

#include <memory>
class MyAbstractClass {
  virtual void someFunction();
};
class MyHeir : public MyAbstractClass {
  virtual void someFunction() override { /* TODO */ }
};
class MyHeir2 : public MyAbstractClass {
  virtual void someFunction() override { /* TODO */ }
};
std::unique_ptr<MyAbstractClass> ptr1 = std::make_unique<MyHeir>();
std::unique_ptr<MyHeir> clone; // TODO: clone

编译器无法在编译时知道ptr1是否包含MyHeir或MyHeir2的实例。这就是你需要克隆模式的原因。你基本上只是实现了一个复制类的虚函数（读取：调用复制构造函数）。

// in MyAbstractClass
virtual MyAbstractClass* clone() = 0;
// in MyHeir
virtual MyHeir * /* return type covariance */ clone() {
  return new MyHeir(*this); // call to the (implicit) copy constructor
}
// in MyHeir2
virtual MyHeir2 * /* return type covariance */ clone() {
  return new MyHeir2(*this);
}

现在你可以做到：

std::unique_ptr<MyHeir> clone = ptr1->clone();

如何实现Cloneable类？

1 个答案: