Return value of operator++

Question

I have the following code that is broken. I can fix it by modifying certain line in code (see the comment). What is the cause of the problem?

#include <iostream>
using namespace std;

class Number{
public:
    int n;
    Number(int a):n(a){}

    //when I change the following to
    //friend Number& operator++(Number& source, int i)
    //then it compiles fine and correct value is printed
    friend Number operator++(Number& source, int i){
        ++source.n;
        return source;
    }
};

int main() {

    Number x(5);
    x++++; //error: no 'operator++(int)' declared for postfix '++' [-fpermissive]
    cout<<x.n;

    return 0;
}

Why does this surprise you? Think of the semantics of postfix `operator++`, what you are returning, what you are trying to do and to whom you're trying to do it to. — Nik Bougalis, Jul 30 '13 at 18:47
@triclosan it is not necessary here, but assuming he has a private member and wants a global function as opposed to member overload? — im so confused, Jul 30 '13 at 19:09
@triclosan Because operator++ is unary and if it was a member function, it would have just one argument (the int). I believe this version with two arguments is not a member function (even though it is defined inside the class) and therefore the friend is needed. — Slazer, Jul 30 '13 at 19:17

score 16 · Accepted Answer · answered Jul 30 '13 at 18:46

16

You attempt to apply the second ++ to the temporary object returned by the first invocation. However, the operand must be passed by reference, and you can't bind a temporary to a non-constant lvalue reference.

You probably don't want to "fix" this, since there's little reason to modify a temporary value like that. However, you should return a copy of the value before incrementing it, to give the expected post-increment behaviour.

The prefix operator should return a reference, which can be happily bound to another reference so that ++++x; should work as expected.

answered Jul 30 '13 at 18:46

Mike Seymour

249,747
28
448
644

The problem is that the postfix increment *can't* return by reference because it will return the already-incremented value! – Mark B Jul 30 '13 at 18:47
@MarkB: So it can't; I wasn't reading the code properly. – Mike Seymour Jul 30 '13 at 18:48
Why is he making `operator++` a `friend` to begin with? – Nik Bougalis Jul 30 '13 at 18:50
@NikBougalis: Because, when you're not writing a toy class as a demonstration, you'd probably want the data members to be private. Although it could be a member, if you prefer. – Mike Seymour Jul 30 '13 at 18:52
@MikeSeymour why would you want a `++` operator as a non-member friend? I see no reason. – Nik Bougalis Jul 30 '13 at 18:53
2

@NikBougalis: One good reason to make it a non-member is so you'll get an error rather than unexpected results if you write `x++++;`, as demonstrated by the question. – Mike Seymour Jul 30 '13 at 18:55

score 8 · Answer 2 · 2013-07-30T20:13:17.910

8

You are incrementing the return value of the inner operator++ by writing x++ ++. That means that the code won't compile if the return value of that operator is not something that can be modified.

So if you declare it to return Number instead of Number &, then it can't be modified (the return value of a function is a temporary and not an lvalue unless it's a reference, hence the outer operator++, which takes it by (non-const) reference, can't bind it to an object returned by value).

edited Jul 30 '13 at 20:13

answered Jul 30 '13 at 18:46

You can modify temporaries/rvalues of class types just fine. The problem is that you can't chain the operators if you return by value because the operator takes the first argument by non-const reference. – jrok Jul 30 '13 at 19:38
@jrok (I actually suspected something like that but I wasn't sure.) So, would this be correct if I added "hence the outer `operator++`, which takes it by (non-const) reference, can't bind it to an object returned by value"? – Jul 30 '13 at 20:03
That'd be fine, me thinks. – jrok Jul 30 '13 at 20:08
1

Now, prepare for some horror: **[ref-qualified member functions work in clang](http://coliru.stacked-crooked.com/view?id=f47668cc0c7e3c7614903f1f2421d131-16ccd8065d089fe1982fc39c3a92e82f)!** (of course there is no use case, but still :/) PS: Did you get my [invite](http://chat.stackoverflow.com/rooms/34803/lets-talk)? – sehe Aug 04 '13 at 22:44
@sehe Oh, holy... No, I didn't get it yet, heading over to the link :) – Aug 05 '13 at 03:14

score 3 · Answer 3 · answered Jul 30 '13 at 18:53

What you are trying to do is very unusual. Post-increment usually returns an rvalue representing the object before the increment (as opposed to pre-increment, which first increments the object and then returns that object itself, as an lvalue). You are basically trying to make post-increment behave the same way as pre-increment, for inexplicable reasons.

Normally, you would do something like this:

class Number {
  int n;
public:
  // Pre-increment
  Number& operator++() {
    ++n;
    return *this;
  }
  Number operator++(int) {
    Number temp = *this;  // capture old value
    ++(*this);
    return temp;
  }
};

With this definition, x++++ doesn't compile - but it also doesn't compile when x is an int: it doesn't really make much sense.

Anyway, the reason it doesn't work for you is as follows. x++++ is interpreted as

operator++(operator++(x, 0), 0)

The inner operator++ call returns a temporary Number object. The outer operator++() expects a parameter of type Number& - but a non-const reference can't bind to a temporary. When you change the declaration so that operator++ returns Number& - an lvalue - then this return value can be happily passed to the outer operator++ call.

I think given your code, `x++++` actually will compile, since `x.operator++(0).operator++(0)` is well-formed. You could fix this by declaring member `Number operator++(int) &` (but only rather recent gcc/clang versions support that, and AFAIK no Microsoft compilers do). — aschepler, Jul 30 '13 at 20:26
@Igor Tandetnik aschepler is right - it does compile. Anyway I get the point, thanks. — Slazer, Jul 30 '13 at 22:06

score 0 · Answer 4 · answered Jul 30 '13 at 18:57

Let's start out by observing that you can't chain postincrement operators like this for int either!

Then before I get t o the problem let me suggest to just not write unintuitive code like this. Someone will have to read your program a year from now and you want to make that as easy to grok as possible.

Consider that x++++ is really something like operator++(operator++(x, int), int) So now what's happening is that the first operator++ returns by value (which results in an unnamed temporary being returned). This unnamed temporary cannot be bound to the non-const reference parameter to the second (outer) call and the method lookup fails.

Finally note that your implementation doesn't actually implement postfix increment: It implements prefix increment. You should either remove the int parameter (which signals postfix) or fix the implementation to return the unmodified value.

Return value of operator++

4 Answers4