Why return by reference?

Question

I'm reading through "SAMS Teach Yourself C++ in 21 days" and I came across an example that I can't seem to understand:

#include<iostream>

using namespace std;

class Counter
{
  public:
    Counter() {itsVal=0;}
    const Counter& operator++ ();
    int GetItsVal() {return itsVal;}
  private:
    int itsVal;
};

const Counter& Counter::operator++()
{
  ++itsVal;
  return *this;
}

int main()
{
  Counter i;
  Counter a = ++i;
  cout << "a: " << a.GetItsVal() << " i: " << i.GetItsVal() << endl;
  ++a;
  cout << "a: " << a.GetItsVal() << " i: " << i.GetItsVal() << endl;
}

Why is there an "&" in the declaration of the ++ operator? I understood this to mean that the return type of the ++ operator was a reference, but it doesn't appear to be a reference to i (since incrementing a does not increment i). I've noticed the code returns the same result if I remove both "&", but maybe it's not as efficient.

@phresnel it's like writing `std::cout << "Hello World"` and saying "I now know C++". — OMGtechy, Apr 07 '14 at 12:18
" but it doesn't appear to be a reference to i ". It is referencing i. Think of it as `i.Increment()`. Where are you incrementing `a`? — Lews Therin, Apr 07 '14 at 12:19
@phresnel: True, the title is misleading. The book is over 800 pages so I highly doubt I can finish it in 21 days, and I also doubt that I will know C++ by the end. But it's a start :) — random_forest_fanatic, Apr 07 '14 at 12:30
@LewsTherin: After I print a and i the first time, I increment a. I then print the values again and see that a has increased by 1 but i has not changed. — random_forest_fanatic, Apr 07 '14 at 12:34
@phresnel: You are wrong: http://25.media.tumblr.com/tumblr_kz4i78InVw1qa501lo1_500.png — PlasmaHH, Apr 07 '14 at 12:38
@rockclimber112358: In general by a lot of experts, that book is deemed "bad" to "harmful"; not only but also because of its title. — PlasmaHH, Apr 07 '14 at 12:40
@rockclimber: You might want to read this question about [`using namespace std;`](http://stackoverflow.com/questions/1265039/using-std-namespace) — Deduplicator, Apr 07 '14 at 13:13
@PlasmaHH: Why is this book deemed "bad" to "harmful"? I've already spent a good deal of time reading through it and don't want to be wasting my time. — random_forest_fanatic, Apr 07 '14 at 13:52

score 6 · Accepted Answer · answered Apr 07 '14 at 12:36

In C++, when you create a reference, it's a proxy for the original object:

int i = 0;
int& a = i;

++i;
std::cout << i << " " << a << "\n"; // prints '1 1'

++a;
std::cout << i << " " << a << "\n"; // prints '2 2'

Now, in your case:

operator++ returns a reference to the current object
Counter a = ++i; creates a new object (no & after Counter) initialized as a copy of the reference to i

If you wish a to refer to i, you need to change its declaration:

Counter& a = ++i;
       ^

This will fail to compile thought because the return value of Counter::operator++ is Counter const&: you need to remove the const here which is non-idiomatic for operator++ and thus:

Counter& Counter::operator++() { ++itsVal; return *this; }

score 2 · Answer 2 · edited Apr 07 '14 at 13:03

2

Many functions have commonly observed patterns for their return values and general behavior, allowing you to easily and naturally use them.

Pre-increment and Pre-decrement operators always return a reference to the object after performing their task for chaining:

Counter& Counter::operator++()
Counter& Counter::operator--()

While Post-increment and Post-decrement operators either do not return any value, or a temporary containing the old value for easily copied value-types:

Counter Counter::operator++(int)
Counter Counter::operator--(int)

Or

void Counter::operator++(int)
void Counter::operator--(int)

It looks like in your example someone didn't follow common practice.

edited Apr 07 '14 at 13:03

jrok

54,456
9
109
141

answered Apr 07 '14 at 12:59

Deduplicator

44,692
7
66
118

1

I think you've got descriptions for post/pre wrong, don't you? – jrok Apr 07 '14 at 13:04
@jrok: Never can rememeber which to call post and which pre. Everything else should be right, now you added some -- signs. – Deduplicator Apr 07 '14 at 13:05
Post- versions have got an `int` "postfix" in the signature, that's how I memorized it. – jrok Apr 07 '14 at 13:07
@Deduplicator Prefix increment operator declaration is similar to simple unary plus operator: `X& operator++();` vs `X operator+();`. And in the code: `a = ++b;` vs `a = +b;` (operator is placed before operand, *pre-*). Postfix one is (not too, in fact, but...) similar to binary plus operator: `X operator++(int);` vs `X operator+(int);` (a possible variant for some classes). And in the code: `a = b++;` vs `a = b + 1;` (operator is placed after [first] operand, *post-*). Maybe it can help to remember. – Constructor Apr 07 '14 at 13:34

score 0 · Answer 3 · answered Apr 07 '14 at 12:21

0

To make you understand this easily, consider assignment operator overloading.

Counter& operator = (const Counter& RHS);

Counter a(10), b(20), c, d;

Now,

c = d = a is possible. When you return something as reference, that overloaded call can be used as R-Value.

answered Apr 07 '14 at 12:21

Sivaraman

438
2
9

So, if I understand correctly, returning a reference would allow me to use the returned value to change the value referred to, right? But, that's not what's happening in this example, is it? – random_forest_fanatic Apr 07 '14 at 12:32

score 0 · Answer 4 · edited Apr 07 '14 at 12:42

Consider this:

void someFunction(const Counter& c);
void someFunction(Counter& c);

...

{
  Counter myCount = makeACounter();
  while(myCount.stillCounting()) {
    someFunction(++myCounter);
  }
}

someFunction() takes a reference so the last thing you want to do it make a copy of myCounter since that's potentially inefficient. Further, if someFunction's non-const variant is chosen (it will be in this case), passing a copy would be logically wrong since someFunction may legally modify the state of its argument and you'd expect to see that change in myCounter when the function returns.

Because of the above situation (and others), operator++ should return a non-const reference to *this (you just modified *this, so it can't be const can it?)

thus the method signature should be: Counter& operator++ ();

Simple: Markdown syntax is supported and encouraged here, Stack Overflow does the coloring of code regions. You may want to `edit` your answer in order to see my changes. — Sebastian Mach, Apr 07 '14 at 12:58

Why return by reference?

4 Answers4