I want to have a good understanding of the use of return *this in c++

Question

I want to have a good understanding of the use of return *this and take of instance we have

coord& coord::operator=(const coord& other)
{
    if (this== &other)
}

My concern here is the use of this and the use of return *this

What is it that you don't understand about it? Which book are you using to learn C++? — Lightness Races in Orbit, Feb 14 '18 at 01:14
What use of `return *this`? I don't see it, and I looked carefully. — Arnav Borborah, Feb 14 '18 at 01:18
check out [what is 'this'](https://stackoverflow.com/questions/16492736/what-is-the-this-pointer) and [dereferencing a pointer](https://stackoverflow.com/questions/4955198/what-does-dereferencing-a-pointer-mean) and [why assignment operator is the way it is](https://stackoverflow.com/questions/3105798/why-must-the-copy-assignment-operator-return-a-reference-const-reference) — kmdreko, Feb 14 '18 at 01:19
The expression `*this` represents the present class. In the assignment idiom, you are returning an instance of the present class, after data members from the `other` class have been assigned. — Thomas Matthews, Feb 14 '18 at 01:34
@LightnessRacesinOrbit That syntax is quite correct. Comparing pointers is a rather basic operation — Michaël Roy, Feb 14 '18 at 01:45
OK. if you want to split hairs... We all got the grist of what the OP meant. — Michaël Roy, Feb 14 '18 at 01:54

Michaël Roy · Answer 1 · 2018-02-14T02:18:14.127

0

It's quite simple:

coord& coord::operator=(const coord& other) 
{ 
   // the test on adresses below is to make sure we're not doing useless work.  
   // comparing pointers is fast.
   // making sure the addresses are different, we know we are not copying
   // the object onto itself.
   // It is both an optimization, and can, for certain memory operations, avoid bugs 
   // although modern compilers do avoid the memcpy/memmove bug, which was real pain a
   // while back.  Some CPUs _will_ puke when asked to copy and source == destination.
   if (this != &other)  
   {
       // usually member-by member copy goes here.
   }

   // returning a reference is standard for copy operations.
   // it allows for such syntaxes as:
   // coord a, b, c;
   //
   // a = b = c;
   //
   // or 
   // if ((a = b) == c) {}
   //
   // etc...
   //
   return *this;  
}

Note: this answer only refers to the question about comparing addresses and the need to return a reference. If your class requires memory allocation or copying any of the members may throw, you should check this post: [1]: What is the copy-and-swap idiom? as pointed out by Lightness Races in Orbit.

edited Feb 14 '18 at 02:18

answered Feb 14 '18 at 01:43

Michaël Roy

6,338
1
15
19

[That is not how we should be writing `operator=`, though](https://stackoverflow.com/a/3279550/560648). – Lightness Races in Orbit Feb 14 '18 at 02:06
That's debatable if coordinates are like x, y, z. Effective programming depends on context. Will add a note. – Michaël Roy Feb 14 '18 at 02:12
If your class is just coordinates like x, y, z then you have no need for an `operator=` in the first place. Context is absolutely crucial, you are right about that, but these idioms develop for a reason, and are taught by the experts for a reason. – Lightness Races in Orbit Feb 14 '18 at 02:12
.I am personally a fan of the rule of zero. – Michaël Roy Feb 14 '18 at 02:20
chat for one sec? I have an off-topic mystery that may interest you, if your username relates to your interests. – Michaël Roy Feb 14 '18 at 02:27
Let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/165101/discussion-between-michael-roy-and-lightness-races-in-orbit). – Michaël Roy Feb 14 '18 at 02:28

score 0 · Answer 2 · answered Feb 14 '18 at 01:53

0

this means a pointer reference to itself. Before we copy other obj, we should know whether the two objects are the same. If same, we don't need do anything.

answered Feb 14 '18 at 01:53

Howo

99
3

_"the same"_ Be careful with this ambiguous term. Equivalence and identity are important distinctions. – Lightness Races in Orbit Feb 14 '18 at 02:06

score 0 · Answer 3 · answered Feb 14 '18 at 02:36

Assuming a and b are of type coord, and a simple assignment a = b is performed, the return *this in the body of coord &coord::operator=(const coord &) returns a reference to a.

The effect of this is to permit chaining of assignments of coord objects. For example,

a = b = c;

is equivalent to (since assignment is right to left associative)

a = (b = c);

The expression b = c therefore is therefore turned by the compiler into a call of b.operator=(c), which returns a reference to b. Similarly the assignment of a is turned into a call of operator=(), so the above is equivalent to

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

which (assuming operator=() is correctly implemented to perform a member-wise assignment) assigns both a and b to c. The reference returned by a.operator=() is, in this case, ignored by the compiler.

The if (this == &other) test is an old technique to handle self-assignment (e.g. a = a) as a special case (e.g. by doing nothing). Such a thing is generally discouraged for various reasons, such as behaving differently if the coord type has a unary operator&(). As noted by "Lightness Races in Orbit" in a comment to another answer, it is generally considered preferable to use the copy and swap idiom instead - refer for example to What is the copy-and-swap idiom?.

I want to have a good understanding of the use of return *this in c++

3 Answers3