Styjun

I am trying to make a deep copy of the object d of class Derived as in the code below:

class A 
public:
 int m_int;
 A* clone() 
 return new A(*this);
 
;

class Base 
public:
 A* m_a;
 virtual Base* clone() 
 A* new_a = new A();
 new_a = this->m_a->clone();
 Base* clone = new Base(*this);
 clone->m_a = new_a;
 return clone;
 
;

class Derived : public Base 
public:
 double m_dbl;
 virtual Derived* clone() 
 return new Derived(*this);
 
;

int main() 
 Derived* d = new Derived();
 d->m_dbl = 1.234;

 A* a = new A();
 a->m_int = -1;

 d->m_a = a;

 //clone d
 Derived d_copy = d->clone();

 //changing values of d's attributes must not affect d_copy
 a->m_int = 10;
 d->m_dbl = 3.456;

 //check d_copy
 cout << "m_int " << d_copy->m_a->m_int << endl;
 cout << "m_dbl " << d_copy->m_dbl << endl;

output:

m_int 10 //wrong, should be -1;
m_dbl 1.234 //correct

As you can see, simply returning new Derived(*this) in Derived's clone() method is wrong since it does not deep-copy m_a.

If I "bring down" the deep-copying of m_a from Base to Derived then I will get the correct answer:

 virtual Base* clone() = 0;

 ...

 virtual Derived* clone() 
 A* new_a = new A();
 new_a = this->m_a->clone();
 Derived* clone = new Derived(*this);
 clone->m_a = new_a; 
 return new Derived(*this);
 
 //gives out m_int = -1

If this is the case does this mean that each time I create further derived classes from Derived, I always have to "bring down" the contents of clone() to them?

Also, if for example Base has two derived classes Derived1 and Derived2, does this mean that I have to deep-copy the members of Base in each of them?

Any other ways to approach this?

You can consider of implementing the copy constructor that always is doing deep copy. In such case your clone implementation will always be trivial:

class Base 
public:
 A* m_a;
 Base(const A& other)
 : m_a(other.m_a->clone())
 
 

 virtual Base* clone() 
 return new A(*this);
 
;

class Derived : public Base 
public:
 double m_dbl;
 Derived(const Derived& other)
 : m_dbl(other.m_dbl)

 virtual Derived* clone() 
 return new Derived(*this);
 
;

If you don't want to change the behavior of the default constructor (you want the default constructor to make shallow copy for example) the alternative is to move copy implementation to a CopyTo method, so you can reuse it:

class Base 
public:
 A* m_a;
 static void CopyTo(const Base& from, Base& to)
 
 to.m_a = from.m_a->clone();
 

 virtual Base* clone() 
 Base* result = new Base();
 CopyTo(*this, result);

 return result;
 
;

class Derived : public Base 
public:
 double m_dbl;

 static void CopyTo(const Base& from, Base& to)
 
 Base::CopyTo(from, to);
 to.m_dbl= from.m_dbl;
 

 virtual Derived * clone() 
 Derived * result = new Derived ();
 CopyTo(*this, result);

 return result;
 

 virtual Derived* clone() 
 return new Derived(*this);
 
;