why do we have to return const reference from unary prefix operator overloading

Question

I have one doubt on prefix operator overloading .

my sample program:

class ABC {
    int i;
public:
    const ABC& operator++() { i=i+1; return *this;}
};

int main() {
    ABC ob ; //let value of i =5;
    ++ob;  // value of i will be 6
    return 0;
}

but I could do the same thing by overloading like below

void operator++() { i=i+1;}

this gives me same result when calling ++ob

APMK ++ob converted as ob.operator++().

My doubt is what happens to the return value. Does the compiler creates code like:

ob = ob.operator++();

Thanks in advance

You don't. But someone might do `++(++ob)` or similar. Or `ob2 = ++ob;` — user253751, Feb 24 '16 at 02:49
The prefix increment should typically return a non const lvalue reference. — NathanOliver, Feb 24 '16 at 03:01

score 1 · Answer 1 · answered Feb 24 '16 at 03:01

1

why do we have to return const reference from unary prefix operator overloading

You don't have to. Typically you return non-const reference, but you could make it return anything. You shouldn't, but you could. The built in pre-increment works how returning non-const reference works, so it makes the most sense to do that.

answered Feb 24 '16 at 03:01

Weak to Enuma Elish

4,622
3
24
36

thanks for the answer. but my query is different. let me explain again. when I do ob1=++ob, compiler converts as ob1=ob.operator++(). where my return lvalue is assigned to ob1. But in case of only "++ob" how the compiler handles the return value as the return value is not assigned to anyone – rajiba pradhan Feb 25 '16 at 01:46
@rajibapradhan The return value would be discarded. – Weak to Enuma Elish Feb 25 '16 at 01:55

score 0 · Accepted Answer · edited May 23 '17 at 12:23

The reason to return a reference to an object is to make the behavior the same as for integers (for built in types).

std::cout << ++i;
std::cout << i++;

If i is an integer this will work. This will only work in a class if you return a reference to the object (Assuming you have defined operator<< for your class).

class ABC {
    int i;
public:
    ABC(int x = 0) : i(x) {}
    const ABC& operator++()    { i=i+1; return *this;}
          ABC  operator++(int) { ABC result(*this);i=i+1; return result;}
    friend std::ostream& operator<<(std::ostream& out, ABC const& val)
    {
        return out << val.i;
    }
};

With this definition then your class will behave the same way that an integer will behave in the above situation. Which makes it very useful when using template as you can now do a drop in replacement for integer with your type.

Note normally I would return just a reference (not a const reference).

/*const*/ ABC& operator++()    { i=i+1; return *this;}
^^^^^^^^^

see: https://stackoverflow.com/a/3846374/14065

But C++ allows you do anything and you can return whatever is useful or has appropriate meaning for the situation. You should consider what is meaningful for your class and return a value that is appropriate. Remember the Principle of lease surprise

thanks for sharing this info "std::cout << ++i; std::cout << i++; If i is an integer this will work. This will only work in a class if you return a reference to the object (Assuming you have defined operator<< for your class)." — rajiba pradhan, Feb 25 '16 at 03:49

why do we have to return const reference from unary prefix operator overloading

2 Answers2