return i++

[Patrick Kowalzick]

Dear all,

sorry, I always forget this thing:

Is this foo:

int foo(int i)
{
++i;
return i-1;
}

the same like this foo:

int foo(int i)
{
return i++;
}

? As I am alway scared using the ++ operators in compact forms, I'd better
ask......

Thanks,
Patrick

****************************

Reply form:

[ ] both foos are identical in the functionality and well defined
[ ] keep your fingers away from "return i++"
[ ] keep your fingers away from "return ++i"
[ ] do not know

Please mark the correct answers. More than one answer might be correct.

[Victor Bazarov]

Patrick Kowalzick wrote:

sorry, I always forget this thing:

Is this foo:

int foo(int i)
{
++i;
return i-1;
}

the same like this foo:

int foo(int i)
{
return i++;
}
Yes. And it really is the same as

int foo(int i)
{
return i;
}

? As I am alway scared using the ++ operators in compact forms, I'd better
ask......

Thanks,
Patrick

****************************

Reply form:

[ ] both foos are identical in the functionality and well defined
[ ] keep your fingers away from "return i++"
[ ] keep your fingers away from "return ++i"
[ ] do not know

Please mark the correct answers. More than one answer might be correct.

You better mark the first one and the last one. Both answers are correct.

V

[Patrick Kowalzick]

Dear Victor,

You better mark the first one and the last one. Both answers are correct.

[x] both foos are identical in the functionality and well defined
[ ] keep your fingers away from "return i++"
[ ] keep your fingers away from "return ++i"
[x] did not know

Thanks ;),
Patrick

[JKop]

int Blah()
{
int k = 5;

return ++k;
}
The above function returns 6.

--

The below function returns 5.

int Blah()
{
int k = 5;

return k++;
}

--

When you put ++ before the name: The object is incremented. The value of the
expression is the object's value *after* the increment.

When you putt ++ after the name: The value of the expression is the object's
value *before* the increment. The object is incremented.
Maybe the following will enlighten?:

class Number
{
private:

unsigned k;

public:

Number& operator++()
{
//This gets called when you do ++object
//Note that it returns by reference

k += 1;

return *this;
}

Number operator++(int)
{
//This gets called when you do object++
//Note that it returns by value

//First we create a temporary, making a copy of the current object
Number temp = *this;

//Now we proceed with the increment
k += 1;

//But... we return the old value, ie. before the increment
return temp;
}
};
-JKop

[JKop]

When you put ++ before the name: The object is incremented. The value
of the expression is the object's value *after* the increment.

When you putt ++ after the name: The value of the expression is the
object's value *before* the increment. The object is incremented.

Here's the simple way to remember it: Just read from left to right as
normal:
++object;

[increment], then [object];
object++;

[object], then [increment];
Hopefully you're not Arabic!
-JKop

[Patrick Kowalzick]

Dear JKop,

thanks a lot for your explanations. Sorry that I did not express me right,
but I know the thing about post- and pre-increment.

The only problem I have, is to remember in which cases I run into undefined
behaviour. So I'd better ask before ;). The compilers are not a good
indicator here, because some may work, and others not (undefined).

I was only *quite* sure that my code is fine, but not 100%.

Thanks,
Patrick

[Karl Heinz Buchegger]

Patrick Kowalzick wrote:

Dear JKop,

thanks a lot for your explanations. Sorry that I did not express me right,
but I know the thing about post- and pre-increment.

The only problem I have, is to remember in which cases I run into undefined
behaviour. So I'd better ask before ;).

In a nutshell:
* make sure the variable that gets incremented is not the same variable
assigned to.

i = i++; // <- That's a no, no

* don't increment the same variable more then once in a statement

j = i++ + i++; // no, no
foo( i++, i++ ); // no, no
cout << i++ << i++; // no, no

If you don't do any of the above you should be fairly safe
(Did I miss some other common mistakes?)

--
Karl Heinz Buchegger
kb******@gascad.at

[Ron Natalie]

JKop wrote:

When you put ++ before the name: The object is incremented. The value of the
expression is the object's value *after* the increment.

When you putt ++ after the name: The value of the expression is the object's
value *before* the increment. The object is incremented.

Actually, in both cases:
1. The object is incremented.
2. The value returned is either the original or
original value plus one.

You can't make any statement about WHEN the increment occurs.
Actually, I wouldn't have writen either ++k or k++.
Since I don't really care to change k, just get a value
one greater than it:

return k+1;
is MORE appropriate in my opinion.

[Victor Bazarov]

Karl Heinz Buchegger wrote:

Patrick Kowalzick wrote:

Dear JKop,

thanks a lot for your explanations. Sorry that I did not express me right,
but I know the thing about post- and pre-increment.

The only problem I have, is to remember in which cases I run into undefined
behaviour. So I'd better ask before ;).

In a nutshell:
* make sure the variable that gets incremented is not the same variable
assigned to.

i = i++; // <- That's a no, no

* don't increment the same variable more then once in a statement

j = i++ + i++; // no, no
foo( i++, i++ ); // no, no
cout << i++ << i++; // no, no

If you don't do any of the above you should be fairly safe
(Did I miss some other common mistakes?)

Actually, variables is a bit too loose a requirement. It has to be
'object'. It is possible to increment the same object using different
variables:

int i = 42;
int& j = i;
i = j++; // same object, different variables

or even functions:

extern int i;

int foo() {
return i++;
}

int bar() {
i = foo(); // extremely obscured -- same object, and you don't
// even see the increment
}

V

[Andrey Tarasevich]

Karl Heinz Buchegger wrote:

...
In a nutshell:
* make sure the variable that gets incremented is not the same variable
assigned to.

i = i++; // <- That's a no, no

* don't increment the same variable more then once in a statement

j = i++ + i++; // no, no
foo( i++, i++ ); // no, no
cout << i++ << i++; // no, no

If you don't do any of the above you should be fairly safe
(Did I miss some other common mistakes?)
...

You covered only the first part of the rule - multiple modifications
lead to UB. There's a second part as well - reading the old value for a
purpose other that calculating the new value leads to UB. For example

int i, j;
...
j = i++ + i; // no, no

Of course, it would also be useful to explain the difference between
built-in and user-defined operators (and when undefined behavior turns
into unspecified behavior) but I'm afraid we'll need a rather large
nutshell for all this.

--
Best regards,
Andrey Tarasevich

[Patrick Kowalzick]

Dear Victor, dear Karl Heinz,

In a nutshell:
* make sure the variable that gets incremented is not the same variable
assigned to.

i = i++; // <- That's a no, no

* don't increment the same variable more then once in a statement

j = i++ + i++; // no, no
foo( i++, i++ ); // no, no
cout << i++ << i++; // no, no

Actually, variables is a bit too loose a requirement. It has to be
'object'. It is possible to increment the same object using different
variables:

int i = 42;
int& j = i;
i = j++; // same object, different variables

or even functions:

extern int i;

int foo() {
return i++;
}

int bar() {
i = foo(); // extremely obscured -- same object, and you don't
// even see the increment
}

thanks. I try to burn it in my brain and will ask again in 6 month.

Regards,
Patrick

[Patrick Kowalzick]

Dear Ron,

Actually, I wouldn't have writen either ++k or k++.
Since I don't really care to change k, just get a value
one greater than it:

return k+1;
is MORE appropriate in my opinion.

Normaly I´d agree, but it is a counter :) and should definitly be
incremented.

Regards,
Patrick

[Andrey Tarasevich]

Victor Bazarov wrote:

...
or even functions:

extern int i;

int foo() {
return i++;
}

int bar() {
i = foo(); // extremely obscured -- same object, and you don't
// even see the increment
}
...

Although it is worth mentioning that this case is very different from
the previous ones and the behavior is perfectly defined and specified,
since the modifications of 'i' are separated from each other by at least
one sequence point.

--
Best regards,
Andrey Tarasevich

[Victor Bazarov]

Andrey Tarasevich wrote:

Victor Bazarov wrote:

...
or even functions:

extern int i;

int foo() {
return i++;
}

int bar() {
i = foo(); // extremely obscured -- same object, and you don't
// even see the increment
And I missed a return statement here...
}
...

Although it is worth mentioning that this case is very different from
the previous ones and the behavior is perfectly defined and specified,
since the modifications of 'i' are separated from each other by at least
one sequence point.

You're absolutely right, I must have been thinking of this:

------------------------ a.cc
extern int i;
void foo(int &j) {
j = i++;
}
------------------------ b.cc
void foo(int&);
extern int i;
void bar() {
foo(i);
}

which is essentially the same as the first one, only the reference and
the object are separated from each other by a module border, while still
referring to the same object.

V

[Howard]

"Patrick Kowalzick" <ko*******@gmx.net> wrote in message
news:vq****************@nntpserver.swip.net...

Dear Ron,

Actually, I wouldn't have writen either ++k or k++.
Since I don't really care to change k, just get a value
one greater than it:

return k+1;
is MORE appropriate in my opinion.

Normaly I4d agree, but it is a counter :) and should definitly be
incremented.

Regards,
Patrick

If your original function (pasted below) is the way you actually have it in
code, the your "counter" isn't getting incremented, because you pass i in by
value, then increment the local copy of it. If you meant to change the
value that was passed in, make sure you pass it by reference (or pointer):

int foo(int i)
{
return i++;
}

should be:

int foo(int& i)
{
return i++;
}

-Howard

[Ron Natalie]

Howard wrote:

int foo(int& i)
{
return i++;
}

-Howard

or is that --Howard.

[Howard]

"Ron Natalie" <ro*@sensor.com> wrote in message
news:41***********************@news.newshosting.co m...

Howard wrote:

int foo(int& i)
{
return i++;
}

-Howard

or is that --Howard.

good one! :-)

[Karl Heinz Buchegger]

DaKoadMunky wrote:

cout << i++ << i++; // no, no

I am thinking that this is unspecified behavior rather than undefined given
that the statement is really...

operator<<(operator<<(cout,i++)),i++);

The output is unspecified behavior but the modifications to i are separated by
sequence points and thus do not lead to undefined behavior.

Can anyone confirm or deny this?

Actually I once walked through all of this in the standard.
The point is:
There are 2 different forms of op<<
1) member functions of the stream
2) standalone functions

All the op<< for builtin types (int, char, long, etc...) are
member functions. Thus

cout << i++ << i++;

is equivalent to

cout.op<<( i++ ).op<<( i++ );

because i++ is of type int in both cases.

Hack I can't remember all the details, but they turned around how
function calls are handled. Which one is done first:
the evaluation of the function to call or the evaluation of the
arguments. Search google for an indepth analysis of that.

--
Karl Heinz Buchegger
kb******@gascad.at

[JKop]

int foo(int i)
{
return i++;
}

should be:

int foo(int& i)
{
return i++;
}

should be:

int foo(int& i)
{
return ++i;
}
and maybe return that by reference too...
-JKop

[Arijit]

The ++Patrick-- got me thinking. Is any of the following legal ?

int i;

(i++)++;
++(i++);
(++i)++;
++(++i);

What happens if I omit the parnethesis ?

My guess is (++i)++ and ++(++i) is legal, because ++i is l-value.

One more thing, where can I find a little detailed information on sequence
points ? All I seem to get is very sketchy.

-Arijit

[Andrey Tarasevich]

Arijit wrote:

The ++Patrick-- got me thinking. Is any of the following legal ?
What do you mean by "legal"? Well-formed? Behavior is defined?
int i;

(i++)++;
Ill-formed. Post-increment expects an lvalue.
++(i++);
Ill-formed. Pre-increment expects an lvalue.
(++i)++;
++(++i);
Both well-formed, but produce undefined behavior.
What happens if I omit the parnethesis ?
'(++i)++' without parenthesis is equivalent to '++(i++)'. Others won't
change at all.
My guess is (++i)++ and ++(++i) is legal, because ++i is l-value.

Both are well-formed, but broken, since they produce undefined behavior.

--
Best regards,
Andrey Tarasevich

[DaKoadMunky]

>One more thing, where can I find a little detailed information on sequence

points ? All I seem to get is very sketchy.

I found this helpful...

http://www.embedded.com/story/OEG20020625S0041

[Howard]

"JKop" <NU**@NULL.NULL> wrote in message
news:Ky*******************@news.indigo.ie...

int foo(int i)
{
return i++;
}

should be:

int foo(int& i)
{
return i++;
}

should be:

int foo(int& i)
{
return ++i;
}

Not according to the original post, which was asking if it was ok to
post-increment, expecting the returned value to be the value prior to the
increment. Your version would return the value AFTER the increment, which
isn't what was wanted.

and maybe return that by reference too...

No need to do that, I think. It's just an integer, and wouldn't save any
time or memory doing so, would it?
--Howard

[JKop]

Howard posted:

"JKop" <NU**@NULL.NULL> wrote in message
news:Ky*******************@news.indigo.ie...

int foo(int i)
{
return i++;
}

should be:

int foo(int& i)
{
return i++;
}

should be:

int foo(int& i)
{
return ++i;
}

Not according to the original post, which was asking if it was ok to
post-increment, expecting the returned value to be the value prior to
the increment. Your version would return the value AFTER the
increment, which isn't what was wanted.

and maybe return that by reference too...

No need to do that, I think. It's just an integer, and wouldn't save
any time or memory doing so, would it?
--Howard

You're right, my bad.
-JKop