Polymorphic copy constructor

[Zaita]

Ok. I am having a mind blank. But I am hoping there is an easy way to achieve what I want to do.

I have a vector<Parent*> that contains a collection of Child1-N* classes where each child inherits from Parent either directly, or indirectly (Nth-Level).

What I want to do is clone the contents of the vector invoking all the child copy constructors (yes, only require a shallow-copy) so I have 2 complete individual vectors with the same number, and type of objects that match parameters but are NOT pointing to the same memory space.

Some sample code showing what I mean:

#include <string>
#include <iostream>

using namespace std;

class Parent {
public:
  Parent() : name("Unknown") { }
  string name;
  virtual void foo() { cout << "Inside Parent" << endl; }
};

class Child: public Parent {
public:
  void foo() { cout << "Inside Child" << endl; }
};

int main() {

  Parent *P1, *P2;
  Child *C1 = new Child();

  P1 = C1;
  P1->name = "P1";
  P1->foo(); // Inside-Child C1

  P2 = &(*C1); // How to invoke a child's copy constructor here?
  // P2 = new Parent((*C1)); // Foo will then call Inside-Parent()
  P2->foo(); // Inside-Child C1
  P2->name = "P2";

  cout << P1->name << " & " << P2->name << endl; // Prints P2 & P2
  // Want it to print P1 and P2.

  // Ignore obvious memory leak
  return 0;
}

Some solutions I know of:
- dynamic_cast<> to each type of child until you hit a match, then invoke the individual constructor. Don't really like this idea because of the large amount of code that would need to be written.

- Create a CParent* Child::clone(ChildN*) function that will call it's own copy constructor and make it pure virtual on the parent.

Something easier and obvious I have missed?

[jsmith]

Yes, the clone pattern is what you want, and is exactly as you described.

[Zaita]

Hmm yea. The Prototype pattern (Clone to you ;)). I did really want to avoid that, but it does seem like the most efficient way. Buggar =\

[Zaita]

For those wondering. My solution is going to be the Prototype pattern. It's the best method, but unfortunately requires a significant amount of code.

Here is my example code with it implemented:

#include <string>
#include <iostream>

using namespace std;

class Parent {
public:
  Parent() : name("Unknown") { }
  string name;
  virtual void foo() { cout << "Inside Parent" << endl; }
  virtual Parent* clone() = 0;
};

class Child: public Parent {
public:
  void foo() { cout << "Inside Child" << endl; }
  Parent* clone() { return new Child(*this); }
};

int main() {

  Parent *P1, *P2;
  Child *C1 = new Child();

  P1 = C1;
  P1->name = "P1";
  P1->foo(); // Inside-Child C1

  P2 = P1->clone();
  // P2 = new Parent((*C1)); // Foo will then call Inside-Parent()
  P2->foo(); // Inside-Child C1
  P2->name = "P2";

  cout << P1->name << " & " << P2->name << endl; // Prints P2 & P2
  // Want it to print P1 and P2.

  // Ignore obvious memory leak
  return 0;
}