Overloading assignment operator

Code:

IntArray::IntArray(const IntArray& h){
    lo = h.lo;
    hi = h.hi;
    first = h.first;
    second = h.second;
    len = h.len;
    arr = h.arr;
}

Seems like a mistake. arr is a pointer so if you do just a plain assignment you end up with two pointers sharing the memory. Since you are making a new object, this seems wrong. The pointer, h.arr, could be deleted, affecting this->arr.

One way to fix it is to make a deep copy:

Code:

arr = new int[h.len];
for (int i = 0; i < len; i++) {
   arr[i] = h.arr[i];
}

Just like that. Now each new object has its own copy of arr.

Another way to fix it is to use shared_ptr, but you have to want the semantics of that type, and I'm not sure that you do.

Originally Posted by whiteflags

Ok well I maintain my advice, for the most part. Even discounting my misgivings about the design, you need to modify the current object (pointed to by this, if that wasn't clear before) to get anywhere. Your code does not modify the current object in any way. All of the changes you want are made to temp, not this. Temp is destroyed by the time operator = returns, so that doesn't help matters.

I read up some more on the this pointer and understand what you mean now. I thought my code worked but it actually didn't. I changed it to this:

Code:

IntArray& IntArray::operator=(const IntArray& h){
    if (len != h.len)
        hault();
    else if(len == h.len){
        for(int i = 0; i < len; i++){
            arr[i] = h.arr[i];
        }
    }
    return *this;
}

Now it works great. I know the assignment is a little obscure and pointless, but I think he just wants us to understand how overloading operators work.
Just a quick question on the this pointer...So when you are returning *this, it is the same thing as returning the IntArray object on the left hand side of the assignment operator?

Elysia - Thanks for pointing that out, it fixed another problem I was having.

EDIT: Just saw your post whiteflags...I didn't realize that, thanks for pointing it out also!

Just a quick question on the this pointer...So when you are returning *this, it is the same thing as returning the IntArray object on the left hand side of the assignment operator?

No. The assignment operator has changed the current object (the object on the left hand side) to be like the object on the right hand side.

Code:

a = b;
a.operator=(b);

Same thing really. So what you return is in fact a after the changes are made.

Ah alright, that makes sense.
Thanks for all the help everyone! It's much appreciated

Originally Posted by ryanmcclure4

...So when you are returning *this, it is the same thing as returning the IntArray object on the left hand side of the assignment operator?

It is, but it is also returning the current instance you are working on.
So

a = b

would invoke a.operator = (b)

which would return a reference to the left-hand side, a.
That allows you to chain it.

O_o

Elaborating on "chaining" (I'm elaborating because people have a disturbing tendency to get it wrong in their minds.):

Code:

a = b = c;

Code:

a.operator=(b.operator=(c));

Code:

a << b << c;

Code:

(a.operator<<(b)).operator<<(c);

It happens this way because of operator precedence and associativity.

It is easy to get tripped up on that so stick that phrase into your favorite search engine and bookmark it for when it does cause you a problem.

Soma