How do I do a deep copy in c++

Question

I am trying to do a deep copy of class B, but A doesn't get set.

Why does b3->print return a garbage number instead of 1?

From what I understand, b2 and b3 are both pointing to the same A object. but I created a new object on the heap with B's copy constructor. so why are they both still poiting to the same object?

I hope this makes sense.

#include <cstdlib>
#include <iostream>

using namespace std;

class A{
      int num;
public:
       A(int n):num(n){ cout<< "A "<< num << " constructor" <<endl;}  
       ~A(){ cout<< "A "<< num <<" destructor. " <<endl; }   

       int print(){
        cout<< num<< endl;
       }
};

class B{
      A *a;
      int num;
public:
       B(int n):num(n){
           a = new A(n);
           cout<< "B "<< num <<" constructor" <<endl;    
       }  
       ~B(){
            delete a; 
            cout<< "B "<< num <<" destructor"<<endl; 
       }    
       // Copy contructor
       B(const B & b): a(new A(b.num)){ 
       } 

       <strike>int<\strike> void print(){
        cout<< num << endl;
       }

       int get_num(){
           return num;
       }
};

int main(int argc, char *argv[])
{ 
    B *b2 = new B(1);
    B *b3(b2);
    b2->print();
    delete b2;
    b3->print();
    system("PAUSE");
    return EXIT_SUCCESS;
}

Answer 1

B *b3(b2); doesn't do what you think.

It's equivalent to B* b3 = b2. The pointers will point to the same location. When you do delete b2;, you're also freeing the memory pointed to by b3.

To do a deep copy, do:

 B* b3 = new B(*b2);

There's also undefined behaviour here:

int print(){
   cout<< num << endl;
}

because you never return. Change the return type to void.

To get the value expected:

B(const B & b): a(new A(b.num)), num(b.num){ 
} 

Answer 2

Other answers to this question will explain about how pointers work, but you should also understand that not using pointers is a better solution. C++'s default behaviors work well with value semantics. If you hold objects by value then the default copy ctor and assignment operators will do a 'deep copy'.

class B{
    A a;
    int num;
public:
    B(int n): a(n), num(n){
        cout<< "B "<< num <<" constructor" <<endl;    
    }    

    void print(){
        cout<< num << endl;
    }

    int get_num(){
        return num;
    }
};

Also, if you do use owning pointers you should usually use smart pointers.

Answer 3

I think you probably intended to write something like this:

#include <iostream>

class A
{
public:
    A(int n) : num_(n) {}

    void print() { std::cout << num() << std::endl; }

    int num() const { return num_; }

private:
    int num_;
};

class B
{
public:
    B(int n) : a(n) {}

    int num() const { return a.num(); }

private:
    A a;
};

int main()
{
    B b(1);
    B b2 = b; // deep copy
}

As you can see:

1. B doesn't have its own num_ member. Duplication should be avoided.
2. There's no need to implement the copy constructor or assignment operator (rule-of-three).
3. Not need to use new here.

Answer 4

here you are not copying b2

B *b3(b2);

instead you are making b3 point to b2

you should have

B *b3 = new B(*b2);

Answer 5

There is no such things as shallow/deep copy in c++. You either have values or pointers/references that get copied, and that fully defines the semantics of the copy operation.