shallow copy issue!

Question

Have a look at the following code you are not required to read the whole code just read the code of copy constructor and the main program.
the following statement in the copy constructor

//the statement below should do the shallow copy 
    ptr[currentsize++]=object.ptr[i];

this statement should do a shallow copy in case of array of pointers so please see the code of copy constructor and the main function i have mentioned the problemes in the code.

#include<iostream.h>
template<typename t>
class vector
{
public:
    vector(int size);
    vector(const vector<t>&);
    void insert(t);
    void display()const;
    void makeEmpty();//sets all pointers to NULL
private:
    t* ptr;
    int size;
    int currentsize;
};
template<typename t>
vector<t>::vector<t>(int s)
{
    currentsize=0;
    size=s;
    ptr=new t[size];
}
//copy constructor
template<typename t>
vector<t>::vector<t>(const vector<t>& object)
{
    size=object.size;
    ptr=new t[size];
    currentsize=0;
    for(int i=0;i<object.currentsize;i++)
    {
        //the statement below should do the shallow copy 
        ptr[currentsize++]=object.ptr[i];
    }
}
template<class t>
void vector<t>::insert(t element)
{
    if(currentsize < size)
        ptr[currentsize++]=element;
}
template<class t>
void vector<t>::display()const
{
    for(int i=0;i<currentsize; i++)
    {
        cout<<ptr[i]<<endl;
    }
}
template<class t>
void vector<t>::makeEmpty()
{
    for(int i=0;i<currentsize;i++)
        ptr[i]=NULL;
}
main()
{
    vector<char*>object(10);
    char *array[]={"zia","arshad","muneeb"};
    object.insert(array[0]);
    object.insert(array[1]);
    object.insert(array[2]);
    vector<char*> object1=object;
    cout<<"displaying the new object"<<endl;
    object1.display();
    object.makeEmpty();//sets all pointers to NULL
    //now here the object 1 should be changed but its not 
    cout<<"again displaying object1"<<endl;
    object1.display();//still displaying the three names 

    cout<<endl;
    system("pause");

}

Answer 1

You get exactly what you wrote. Your copying makes a copy of the array. You shouldn't expect changes to the first vector touch the second one.

Note that you've removed pointers to the strings in the first vector. In the second they stay intact.

Answer 2

For a shallow copy, just do:

ptr = object.ptr;

in the copy constructor.

The only reason you would loop through ptr like you've done there is specifically to do a deep copy...

EDIT:

Understand that when you do:

ptr=new t[size];

you're allocating a new memory block of size "size*sizeof(t)" to ptr.

And

ptr[currentsize++]=object.ptr[i];

Copies the contents of object.ptr[i] to ptr[currentsize].

You could also just omit the call to new and change that line to:

&ptr[currentsize++]=&object.ptr[i];

Answer 3

The copy is shallow w.r.t. the actual string data, but not the string pointers. The strings are still present in memory; doing anything to the pointers in the first object won't change the pointers in the second one.

Try changing ptr[i]=null in the your makeEmpty() function into strcpy(ptr[i], "a") and you should see them get changed in object2 too (as well as in the original char *array[]).

If you want an actual shallow copy that works like you want, just use ptr = object.ptr.

Answer 4

You aren't changing the pointers to NULL in object1 which is the object you are expecting to see no results from when you call display. Since object1 still has valid addresses contained within it, you're of course going to still see the results as the array of type t hasn't been destroyed/deallocated.

If in makeEmpty() you were destroying/destructing the objects, then you would get undefined behavior (probably a SEGFAULT) when you call object1.display(); as the pointers, though they still have addresses contained within them, are invalid as they point to destroyed memory.

Answer 5

Don't increment currentsize

//ptr[currentsize++]=object.ptr[i];
ptr[i]=object.ptr[i];

Answer 6

To understand what is being copied, modify your display function to this:

template<class t>
void vector<t>::display()const
{
    for(int i=0;i<currentsize; i++)
    {
        cout<<(void* )&ptr[i] << ": " << ptr[i]<<endl;
    }
}

This will not only show the contents of the pointer (as a string), but show where the pointer is being stored.

You should then modify your program to also do a object.display(). You will then see that there are two copies of the pointer. When you use makeEmpty() to zero out the pointers, you are only modifying one copy of the pointer.