Best practice for postfix ++ operator return type

**whiteflags** · 10-23-2010

Well considering what Subsonics wrote

Yes, but my understanding was that for chaining in general to work, you was required to return a reference. So, if my ++ operator did not return one it would affect other operators as well

And considering the related code, your post was only tangentially related to why Subsonics approach would not work.

Breaking down again how this works:
cout << d++ << c;
cout.operator<<(cout, d.operator++(int)).operator<<(cout, c);

Probably not how it really folds out, but that's not the point.

There is no situation where operator++ handles the chaining because cout -- an entirely different object -- is what is being "passed down" from operator to operator. So an in-depth explanation of chaining workings seemed off-topic to me. I hope that with my earlier post it became clear what d's role was in the chaining process, and how increment was really no part of it at all. So in this case, operator++(int) returning a reference or a value is neither here nor there. With this, I hope absolutely everyone understands.

**Subsonics** · 10-24-2010

Ehm, so you are saying that this would work equally well.

Code:

        void A::operator++(int){
                b++;
                updateA(b);
        }

As far as cout is concerned?

Anyway, I'll look to see if I can post something from operator<< as well. I just have to figure out what exactly to post, there are four class files affected, I think.

**anon** · 10-24-2010

Ehm, so you are saying that this would work equally well.

No, because you want to output the returned value which this function doesn't have.

The chaining is achieved by operator<< returning a reference to the left-hand stream, it has nothing to do with the values on the right side of the operator.

**Elysia** · 10-24-2010

More accurately, the chaining is achieved by the return value of the function, whatever that might be.

**Subsonics** · 10-24-2010

Originally Posted by anon

No, because you want to output the returned value which this function doesn't have.

Yes, and that was exactly my point. And a reply to this:

"There is no situation where operator++ handles the chaining because cout -- an entirely different object -- is what is being "passed down" from operator to operator. "

**whiteflags** · 10-24-2010

>>Yes, and that was exactly my point.
Anon did not say what you thought though.

>>Ehm, so you are saying that this would work equally well. As far as cout is concerned?
No.

This is a typical implementation:

Code:

type operator++(int) // postfix increment
{
   type val = impl;
   update(impl);
   return val;
}

The function now returns the value that you wanted to print, and updates it --

cout << d;
++d;

-- working just like the version without side-effects that uses prefix increment instead of postfix. So as far as cout is concerned, it prints the returned value of postfix increment. It is not chaining stream operations. That was all there was to notice in the example.

A correct implementation of postfix increment might fix your other operators that are actually being chained. If it doesn't, then there is some other, compounding problem, and I don't know yet.

**User Name:** · 10-24-2010

I don't really want to read all this, but the way you allow chaining with other operators is by returning a reference(&). So just take your declaration and add an ampersand to it's return type, like so...

Code:

type &operator++(int) // postfix increment
{
   type val = impl;
   update(impl);
   return val;
}

**Elysia** · 10-24-2010

You should read everything if you're going to enter the discussion.
You do not actually need to return a reference to chain. You need an appropriate return type.

Code:

#include <iostream>

class myobj
{
public:
	myobj operator ++ (int) { myobj tmp(*this); ++myint; return tmp; }
	int myint;
};

int main()
{
	int a, b, c;
	myobj d;
	d.myint = 1;
	a = b = c = (d++).myint;
	std::cout << a << b << c << d.myint << std::endl;
	((d++)++)++;
}

**Subsonics** · 10-24-2010

Originally Posted by User Name:

I don't really want to read all this, but the way you allow chaining with other operators is by returning a reference(&). So just take your declaration and add an ampersand to it's return type, like so...

Code:

type &operator++(int) // postfix increment
{
   type val = impl;
   update(impl);
   return val;
}

The problem with that though is that it's returning a reference to a local variable.

**Subsonics** · 10-24-2010