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?

Quote:

---

Originally Posted by black_stallion

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

---

No, it would return a copy of c1.

Quote:

---

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=.

Quote:

---

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.

Quote:

---

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)?

Quote:

---

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.

Quote:

---

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!