Using references and *this?

Consider the following class.

Code:

class complex
{
private:
int r,i;

public:
    complex operator + (complex c2)
    {
        r = r + c2.r;
        i = i + c2.i;
        return *this;
    }
...
};

If I make a call in main as:

Code:

c3 = c1 + c2

(assuming c1,c2,c3 are all declared and initialized)

then, the overloaded function would return the object c3 itself, right?

What if I change the function to return a reference?

Code:

    complex& operator + (complex c2)
    {
        r = r + c2.r;
        i = i + c2.i;
        return *this;
    }

What is the difference between the two? Does the first function cause a copy of the object pointed to by *this to be created and then copied back to c3? And what about in the latter case?Am I missing something here?

Originally Posted by black_stallion

then, the overloaded function would return the object c3 itself, right?

No, it would return a copy of c1.

Originally Posted by black_stallion

Does the first function cause a copy of the object pointed to by *this to be created and then copied back to c3?

Conceptually, yes. However, the copy might be elided such that you only have the call to operator+ and copy assignment operator=.

Originally Posted by black_stallion

And what about in the latter case?

In the latter case, there is no copy returned, but then due to the copy assignment copying will still be done.

Originally Posted by laserlight

Conceptually, yes. However, the copy might be elided such that you only have the call to operator+ and copy assignment operator=.

Might be? Does that mean this copy is sometimes deleted and sometimes not(and thereby wasting memory if I make such repeated calls)?

Originally Posted by black_stallion

Might be? Does that mean this copy is sometimes deleted and sometimes not(and thereby wasting memory if I make such repeated calls)?

The copy (if made) is on the stack, so no question of 'delete'. It is the time && space wasted, that counts.
The standard allows the compilers, to optimize that copy out.

Okay I see..Thanx!

By the way, your implementation is horribly broken, because in 'c3 = c1 + c2', it actually modifies c1.

The standard way to implement arithmetic operators is to first implement the compound assignment operator and then implement the normal operator in terms of that as a free function:

Code:

class complex {
  int r, i;
public:
  complex &operator +=(complex other) {
    r += other.r;
    i += other.i;
    return *this;
  }
};

complex operator +(complex left, complex right) {
  complex tmp = left;
  tmp += right;
  return tmp;
}

I'm passing complex by value because it's small enough that it would usually be a good idea (depending on some details). Larger things, or things that aren't trivial to copy, should be passed by const reference.

Originally Posted by CornedBee

By the way, your implementation is horribly broken, because in 'c3 = c1 + c2', it actually modifies c1.
The standard way to implement arithmetic operators is to first implement the compound assignment operator and then implement the normal operator in terms of that as a free .

Yes I realized that..I've already modified my code. Thanks!