Class Templates, Pointers, and transferring data between class objects

[Soneji]

I've been learning C++ for about 6 weeks now, and I've been able to figure out pretty much everything I have had a problem with.

This time, I'm at a loss. I'm not learning from the greatest book anyway, but here's the deal:

I was learning about template classes, and how to transfer data between two objects of the same class with pointers involved.

I was shown how to make the code "safe" by adding a copy constructor, an overloaded assignment operator, and a destructor.

The code only had one object, and I tried to add another object so I could transfer that data, and boom. Problem.

The code compiles with no errors, however when you run it, it gets to the last 'for' loop and crashes.

Here's the code:

#include <iostream>
using namespace std;
 
 
    template <class T>        
    class Array    
    {                
        T *ptr_to_array;
        int number;
    public:
        Array( int number_of_elements );
        Array( const Array &a );
        ~Array();
        T& operator=( const Array &a );
        T& operator[]( int index ){ return ptr_to_array[index]; }
    };
 
 
        template <class T>
        Array<T>::Array( int number_of_elements )
        {
            number = number_of_elements;
            ptr_to_array = new T[number];
        }    
 
 
        template <class T>
        Array<T>::Array( const Array &a )
        {
            number = a.number;
            T *ptr_to_array = new T[number];
 
            for( int index = 0; index < number; index++ )
            {
                ptr_to_array[index] = a.ptr_to_array[index];
            }
        }
 
 
        template <class T>
        T& Array<T>::operator=( const Array &a )
        {
            if ( this == &a ) return *this;
            delete[] ptr_to_array;        
 
            number = a.number;
            T *ptr_to_array = new T[number];
 
            for( int loop = 0; loop < number; loop++ )
            {
                ptr_to_array[loop] = a.ptr_to_array[loop];
            }
 
            return *this;
        }
 
 
        template <class T>
        Array<T>::~Array()
        {
            cout << "Deleting allocated memory" << endl;
            delete[] ptr_to_array;
        }
 
 
 
int main()
{
 
    const int nmbr_kids[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    Array<float> scores( 10 );
 
    for( int loop = 0; loop < 10; loop++ )
    {
        scores[loop] = nmbr_kids[loop];
    }
 
 
    for( int loop = 0; loop < 10; loop++ )
    {
        cout << "This is the value in scores element" << loop << ": " << scores[loop]  << endl;
    }
    cout << "\n\n";
 
 
// Problem code lies below...
 
    Array<float> newScores( scores );
 
    for( int loop = 0; loop < 10; loop++ )
    {
        cout << "This is the value in newScores element" << loop << ": " << newScores[loop] << endl;
    }
 
 
 
    return 0;
}
 

As you can see, it's long.

I added the array to the constant integer in main. (originally, it initialized to 5)
I also added the 'for' loops in main. (the ones in the method definitions are from the book )

This isn't homework or anything.
I just want to learn, so it's no rush. 8^)

-Soneji

[Soneji]

Nevermind.

I found some help.

Why the book was telling me to create new pointers in the copy constructor, and
assignment operator overload method, is beyond me.

If you need the answer, it's easy:

T *pnt_to_array = new T[number];

should read:

pntr_to_array = new T[number];

[JosAH]

Why the book was telling me to create new pointers in the copy constructor, and
assignment operator overload method, is beyond me.

By default, i.e. if you don't specify otherwise, when a object is copied the
values of all the members are copied from one object to its copy. Suppose
one of those members is a pointer pointing to somewhere. After copying all
member values both objects have a member pointing to the same thing.

This is scary because if the destructor desctructs that thing when the object
itself is destructed, the *other* object points to a zombie thing which has
been reaped and belongs to the memory heap again.

The default copy is called a 'shallow' copy and you most of the time are
supposed to make a 'deep' copy of objects (unless you have very special
reasons not to do so).

kind regards,

Jos

[Soneji]

Oops!

Sorry, that seemed clearer when I wrote it...

I know why I need to allocate new memory for the second object's pointer.

What I meant was, the author had me do this:

T *pntr = new T[number]; // creating a new pointer, and allocating memory.

instead of:

pntr = new T[number]; // allocating new memory for the object's already
// existing pointer.

The class itself holds the pointer. There was no need to make a new one, just
allocate new memory for the existing one in the copy constructor.

Isn't that correct?

I appreciate the help, There have been a few rough patches here and there.

Thanks!

-Soneji

[JosAH]

Isn't that correct?

Yep, that's correct; of course it doesn't make sense to allocate memory and
assign it to a local variable when you're deep copying an object. The local
variable will be gone when the function returns and the memory will be lost
for the posterity (read: memory leak).

kind regards,

Jos

[Soneji]

Yep, that's correct; of course it doesn't make sense to allocate memory and
assign it to a local variable when you're deep copying an object. The local
variable will be gone when the function returns and the memory will be lost
for the posterity (read: memory leak).

kind regards,

Jos

I want to make sure of this...

I understand what you're saying about the local variable.
The variable will lose scope once you leave the method, so allocating memory
for it is... Not smart.

But in this situation, (shortened from above):

    template <class T>
    Array<T> Array<T>::operator=(const Array &a)
    {
        if (this == &a)  return *this;
        delete[] ptr_to_array                  // *** Question 2 ***
        number = a.number;
        ptr_to_array = new T[number];   // *** Question 1. ***
    };
 

In question 1: 'ptr_to_array' is a pointer declared in the class, and it's the reason
for the "deep copy", so would this be the correct way to do it?

Or is it bad practice to allocate the memory for it, inside the method this way,
and if so... how should it be done?

As for question 2: Is the delete here to remove object1's pointer value from
object2's pointer?

When you allocate new memory for a pointer that holds a value, does it preserve
the value already within, or is it thrown off into limbo?

I really appreciate the help. I thought I had a good grasp on class pointers, and
allocating memory... I guess I was wrong.

8^)
Thanks again!

-Soneji

[JosAH]

    template <class T>
    Array<T> Array<T>::operator=(const Array &a)
    {
        if (this == &a)  return *this;
        delete[] ptr_to_array                  // *** Question 2 ***
        number = a.number;
        ptr_to_array = new T[number];   // *** Question 1. ***
    };
 

In question 1: 'ptr_to_array' is a pointer declared in the class, and it's the reason
for the "deep copy", so would this be the correct way to do it?

Yep, that's the way to do it; the object's member pointer should point to some
memory which you've just allocated.

As for question 2: Is the delete here to remove object1's pointer value from
object2's pointer?

Your new object's pointer member doesn't point to anything yet. You are
supplying a copy constructor so C++ leaves it all up to you to populate your
new object. If you hadn't supplied a copy constructor C++ would've generated
one which copies all members one by one (a shallow copy). Since you're
supplying your own copy ctor, you have to take care that all members are
initialized properly. And because that pointer didn't point to anything yet there's
no reason to delete anything.

When you allocate new memory for a pointer that holds a value, does it preserve
the value already within, or is it thrown off into limbo?

Preserve what? Most likely that content of the freshly allocated memory contains
rubbish or all zeros or whatever the default constuctor of type T had put into
every slot of that array. You want the array to contain exactly what the other
object (the one you're copying from) had in that array, so you have to copy that.

kind regards,

Jos

[Soneji]

Yep, that's the way to do it; the object's member pointer should point to some
memory which you've just allocated.


Your new object's pointer member doesn't point to anything yet. You are
supplying a copy constructor so C++ leaves it all up to you to populate your
new object. If you hadn't supplied a copy constructor C++ would've generated
one which copies all members one by one (a shallow copy). Since you're
supplying your own copy ctor, you have to take care that all members are
initialized properly. And because that pointer didn't point to anything yet there's
no reason to delete anything.

Ahh... See what I meant about not learning from the best book. :)

I couldn't figure out why that 'delete' was there, now I know, I don't need it!

Thanks so much for that!

Preserve what? Most likely that content of the freshly allocated memory contains
rubbish or all zeros or whatever the default constuctor of type T had put into
every slot of that array. You want the array to contain exactly what the other
object (the one you're copying from) had in that array, so you have to copy that.

kind regards,

Jos

You answered both my questions. :)

On the preserving value thing, I went dumb for a second. If the default copy
constructor was used, every value that was in object 1 would be transferred
into object 2. (leading to problems with the pointer)

My question meant, when they are transferred, and I make new memory,
would object 1's pointer still be in the memory, or would the memory overwrite
it?
But...

After reading your answer, I realized my mistake. Object 1's values would not
be transferred until I put the code in for it to do so.

I had a brain fart, and thought that object 1's values would be transferred before
my CC ran... but the default CC won't run with mine there.

Right? I hope this finally clears up my confusion.

Thanks you so much for your help.
You have been very patient with me and you didn't respond with a
holier-than-thou attitude like some people do.
Maybe one day, I can repay the favor. :)

Thanks again!
-Soneji

[JosAH]

Ahh... See what I meant about not learning from the best book. :)

I had a brain fart, and thought that object 1's values would be transferred before
my CC ran... but the default CC won't run with mine there.

Right? I hope this finally clears up my confusion.

Yep, right. And about a lot of those books: those trees used for those books
would've been worth more when turned into crappy toilet paper. Don't buy any
of those "... in twenty-one days", nor "... for dummies", nor anything at all
that has "Herbert Schieldt" on the cover. It's a waste of money.

kind regards,

Jos ;-)

[Soneji]

Yep, right. And about a lot of those books: those trees used for those books
would've been worth more when turned into crappy toilet paper. Don't buy any
of those "... in twenty-one days", nor "... for dummies", nor anything at all
that has "Herbert Schieldt" on the cover. It's a waste of money.

kind regards,

Jos ;-)

Thanks for the heads up! Unfortunately I bought the C++ in 21 days 4Th Ed.
5 years ago. :(

But it's gotta be better than the C++ Black Book that I'm learning from!

Almost done with it though ( thank god! )

Thanks again for all your help, it's really been... helpful! (oh, that was bad.)

Seriously, Thanks!

-Soneji