Pointer Arithmetic Problem

[arnuld]

#include <stdio.h>

int main( void )
{
char arrc[] = { 'a', 'b', 'c', '\0' };
char* pc = arrc;
char** ppc = &pc;

printf("arrc = %s\n", arrc);
printf("------------------------\n");
printf("*pc = %5c\n", *pc);
printf("**ppc = %5c\n", **ppc);
printf("++*pc = %5c, *pc = %5c\n", ++*pc, *pc);
printf("(**ppc)++ = %5c, **ppc = %5c\n", (**ppc)++, **ppc);
return 0;
}
===================== OUTPUT ==========================
[arnuld@dune ztest]$ gcc -ansi -pedantic -Wall -Wextra ok.c
[arnuld@dune ztest]$ ./a.out
arrc = abc
------------------------
*pc = a
**ppc = a
++*pc = b, *pc = a
(**ppc)++ = b, **ppc = b
[arnuld@dune ztest]$
I am little confused at the output. after ++*pc , the *pc should print
'b', not 'a'. Same for **ppc, which is again printing the same element
even after having gone through a ++.

--
www.lispmachine.wordpress.com
my email is @ the above blog.
Gooogle Groups is Blocked. Reason: Excessive Spamming

[Joachim Schmitz]

arnuld wrote:

#include <stdio.h>

int main( void )
{
char arrc[] = { 'a', 'b', 'c', '\0' };
char* pc = arrc;
char** ppc = &pc;

printf("arrc = %s\n", arrc);
printf("------------------------\n");
printf("*pc = %5c\n", *pc);
printf("**ppc = %5c\n", **ppc);
printf("++*pc = %5c, *pc = %5c\n", ++*pc, *pc);
printf("(**ppc)++ = %5c, **ppc = %5c\n", (**ppc)++, **ppc);
return 0;
}
===================== OUTPUT ==========================
[arnuld@dune ztest]$ gcc -ansi -pedantic -Wall -Wextra ok.c
[arnuld@dune ztest]$ ./a.out
arrc = abc
------------------------
*pc = a
**ppc = a
++*pc = b, *pc = a
(**ppc)++ = b, **ppc = b
[arnuld@dune ztest]$
I am little confused at the output. after ++*pc , the *pc should print
'b', not 'a'. Same for **ppc, which is again printing the same element
even after having gone through a ++.

Undefined behavoir in the last printf and I think in the 2nd to last too.
You modify ppc and look at it again without a squence point in between.

Bye, Jojo

[jt]

On Oct 3, 2:16*pm, "Joachim Schmitz" <[e-mail]>
wrote:

arnuld wrote:

#include <stdio.h>

int main( void )
{
*char arrc[] = { 'a', 'b', 'c', '\0' };
*char* pc = arrc;
*char** ppc = &pc;

*printf("arrc = %s\n", arrc);
*printf("------------------------\n");
*printf("*pc * * * = %5c\n", *pc);
*printf("**ppc * * = %5c\n", **ppc);
*printf("++*pc * * = %5c, *pc * = %5c\n", ++*pc, *pc);
*printf("(**ppc)++ = %5c, **ppc = %5c\n", (**ppc)++, **ppc);

*return 0;
}

===================== OUTPUT ==========================
[arnuld@dune ztest]$ gcc -ansi -pedantic -Wall -Wextra ok.c
[arnuld@dune ztest]$ ./a.out
arrc = abc
------------------------
*pc * * * = * * a
**ppc * * = * * a
++*pc * * = * * b, *pc * = * * a
(**ppc)++ = * * b, **ppc = * * b
[arnuld@dune ztest]$

I am little confused at the output. after ++*pc , the *pc should print
'b', not 'a'. Same for **ppc, which is again printing the same element
even after having gone through a ++.

Undefined behavoir in the last printf and I think in the 2nd to last too.
You modify ppc and look at it again without a squence point in between.

Bye, Jojo

hii...
after any function call the argumants are pushed on to a stack(i.e.
starting from left)...
and then they evaluated as they are popped..
so here the first argument to be evaluated is <*pcnot <++*pc>
since <++*pcis pre incrementation <agets incremented to <bin the
same statement...
in the next printf()...
the same thing happens, but since it is post incrementation...you wont
see the effect in this statement....
try adding another statement...maybe..
printf("\n\n **ppc= %c\n",**ppc);
..
..
you'll know the change....
hope this clears your doubt..

[arnuld]

On Fri, 03 Oct 2008 17:31:23 -0700, Barry Schwarz wrote:

... SNIP...
Finally, the code invokes undefined behavior since between sequence
points *pc is modified but it is evaluated twice and for purposes
other than determining its new value.

What you mean by "for purposes other than determining its new value" ?
e.g. do you mean all I can do in single statement is to either print the
value of the variable or increment (or anything else like assigning th
vale to some array element) ?

--
www.lispmachine.wordpress.com
my email is @ the above blog.
Gooogle Groups is Blocked. Reason: Excessive Spamming

[Keith Thompson]

arnuld <su*****@invalid.addresswrites:

>On Fri, 03 Oct 2008 17:31:23 -0700, Barry Schwarz wrote:
... SNIP...
Finally, the code invokes undefined behavior since between sequence
points *pc is modified but it is evaluated twice and for purposes
other than determining its new value.

What you mean by "for purposes other than determining its new value" ?
e.g. do you mean all I can do in single statement is to either print the
value of the variable or increment (or anything else like assigning th
vale to some array element) ?

Here's what the standard says:

Between the previous and next sequence point an object shall have
its stored value modified at most once by the evaluation of an
expression. Furthermore, the prior value shall be read only to
determine the value to be stored.

A footnote says:

This paragraph renders undefined statement expressions such as
i = ++i + 1;
a[i++] = i;
while allowing
i = i + 1;
a[i] = i;

The point of the second part, "the prior value shall be read only to
determine the value to be stored" is that reading and writing the same
object is ok *if* the value that's read is used to compute the value
to be written, because that imposes an ordering. If the value that's
read isn't used to compute the value to be written, as in the right
hand side of "a[i++] = i;", then no such ordering is imposed, and
there's no single valid result. Rather than requiring a result that's
consistent with one of the valid orderings, the standard renders the
entire behavior undefined; this allows for more aggressive
optimization in some cases.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Richard Heathfield]

Nick Keighley said:

<snip>

As someone (Bohr?) said "you're not right, you're not even wrong."

Well, not quite those exact words, but you're thinking of Wolfgang Pauli
(1900-1958).

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[werwolf]

Thank yoy

[Barry Schwarz]

On Sat, 04 Oct 2008 00:55:54 -0700, Keith Thompson <ks***@mib.org>
wrote:

>arnuld <su*****@invalid.addresswrites:

>>On Fri, 03 Oct 2008 17:31:23 -0700, Barry Schwarz wrote:
... SNIP...
Finally, the code invokes undefined behavior since between sequence
points *pc is modified but it is evaluated twice and for purposes
other than determining its new value.

What you mean by "for purposes other than determining its new value" ?
e.g. do you mean all I can do in single statement is to either print the
value of the variable or increment (or anything else like assigning th
vale to some array element) ?

Here's what the standard says:

Between the previous and next sequence point an object shall have
its stored value modified at most once by the evaluation of an
expression. Furthermore, the prior value shall be read only to
determine the value to be stored.

A footnote says:

This paragraph renders undefined statement expressions such as
i = ++i + 1;
a[i++] = i;
while allowing
i = i + 1;
a[i] = i;

The point of the second part, "the prior value shall be read only to
determine the value to be stored" is that reading and writing the same
object is ok *if* the value that's read is used to compute the value
to be written, because that imposes an ordering. If the value that's
read isn't used to compute the value to be written, as in the right
hand side of "a[i++] = i;", then no such ordering is imposed, and
there's no single valid result. Rather than requiring a result that's
consistent with one of the valid orderings, the standard renders the
entire behavior undefined; this allows for more aggressive
optimization in some cases.

As a point of interest, the quoted section comes from 6.5-2 of n1256.
In n1336, the draft of the next standard (C09?), it has been
completely reworded:

"If a side effect on a scalar object is unsequenced relative to either
a different side effect on the same scalar object or a value
computation using the value of the same scalar object, the behavior is
undefined. If there are multiple allowable orderings of the
subexpressions of an expression, the behavior is undefined if such an
unsequenced side effect occurs in any of the orderings."

The footnote is unchanged.

The corresponding section of J.2 has been reworded in a similar
fashion.

--
Remove del for email

[arnuld]

On Sat, 04 Oct 2008 00:55:54 -0700, Keith Thompson wrote:

Here's what the standard says:

Between the previous and next sequence point an object shall have
its stored value modified at most once by the evaluation of an
expression. Furthermore, the prior value shall be read only to
determine the value to be stored.

This language feels like the language of High-Court notices to me. I still
don't understand the meaning of it. All I understand is this:
we can modify the value in a single expression, then we must not read
the vale either before or after the modification.
Does it mean that "one can expect a defined behavior, in one single expression, only if" :

1) he does ++*p and does not read its value before or after
this modification.

2) he does not modify at all but only read the value more than
1 time in a single expression.
Hence only these are defined behaviors:

printf("%d\n", ++*p); /* prints the incremented vale of *p */
printf("%d, %d, %d\n", *p, *p, *p);

A footnote says:

This paragraph renders undefined statement expressions such as
i = ++i + 1;
a[i++] = i;

both expressions are undefined. I don't see why standard used 2
expressions when one is enough.

while allowing
i = i + 1;
a[i] = i;

The point of the second part, "the prior value shall be read only to
determine the value to be stored"

but these are 2 different expressions.

is that reading and writing the same
object is ok *if* the value that's read is used to compute the value
to be written, because that imposes an ordering. If the value that's
read isn't used to compute the value to be written, as in the right
hand side of "a[i++] = i;", then no such ordering is imposed, and
there's no single valid result.

I got this one completely :)

--
www.lispmachine.wordpress.com
my email is @ the above blog.
Gooogle Groups is Blocked. Reason: Excessive Spamming

[Nick Keighley]

On 4 Oct, 13:21, Richard Heathfield <[e-mail]:

Nick Keighley said:

As someone (Bohr?) said "you're not right, you're not even wrong."

Well, not quite those exact words, but you're thinking of Wolfgang Pauli
(1900-1958).

so it could be said of my statement
'That's not right. It's not even wrong'

and it was indeed Pauli

thanks

--
Nick Keighley

[Keith Thompson]

arnuld <su*****@invalid.addresswrites:

>On Sat, 04 Oct 2008 00:55:54 -0700, Keith Thompson wrote:

>Here's what the standard says:

Between the previous and next sequence point an object shall have
its stored value modified at most once by the evaluation of an
expression. Furthermore, the prior value shall be read only to
determine the value to be stored.

This language feels like the language of High-Court notices to me. I still
don't understand the meaning of it. All I understand is this:
we can modify the value in a single expression, then we must not read
the vale either before or after the modification.

Um, not quite. You can certainly read and then modify the value of an
object with an expression; for example, "i = i + 1;" is ok.

Does it mean that "one can expect a defined behavior, in one single
expression, only if" :

1) he does ++*p and does not read its value before or after
this modification.

2) he does not modify at all but only read the value more than
1 time in a single expression.
Hence only these are defined behaviors:

printf("%d\n", ++*p); /* prints the incremented vale of *p */
printf("%d, %d, %d\n", *p, *p, *p);

I'm not sure I understand the question. Those certainly do have
well-defined behavior, but there are an infinite variety of other
expressions that also have well-defined behavior.

>A footnote says:

This paragraph renders undefined statement expressions such as
i = ++i + 1;
a[i++] = i;

both expressions are undefined. I don't see why standard used 2
expressions when one is enough.

Because they demonstrate undefined behavior for two different reasons.
The first modifies the object "i" twice. The second reads and
modifies "i", but it's undefined because it reads i for a purpose
other than computing the value to store in it.

> while allowing
i = i + 1;
a[i] = i;

>The point of the second part, "the prior value shall be read only to
determine the value to be stored"

but these are 2 different expressions.

Huh? Do you mean that "i = i + 1;" and "a[i] = i;" are two different
expressions? Yes, they are (actually two different expression
statements). What's your point?

>is that reading and writing the same
object is ok *if* the value that's read is used to compute the value
to be written, because that imposes an ordering. If the value that's
read isn't used to compute the value to be written, as in the right
hand side of "a[i++] = i;", then no such ordering is imposed, and
there's no single valid result.

I got this one completely :)

Um, ok. Does the smiley mean you didn't get it, or am I just missing
the joke?

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Richard Bos]

arnuld <su*****@invalid.addresswrote:

On Sat, 04 Oct 2008 00:55:54 -0700, Keith Thompson wrote:

Here's what the standard says:

Between the previous and next sequence point an object shall have
its stored value modified at most once by the evaluation of an
expression. Furthermore, the prior value shall be read only to
determine the value to be stored.

This language feels like the language of High-Court notices to me.

That may be because, like High Court judgements, they have to be exact,
lest someone notice the loopholes and starts abusing them.

I still don't understand the meaning of it. All I understand is this:

we can modify the value in a single expression, then we must not read
the vale either before or after the modification.

Until we hit the next sequence point. Yes.

Does it mean that "one can expect a defined behavior, in one single expression, only if" :

FSVO "expression", but...

1) he does ++*p and does not read its value before or after
this modification.

2) he does not modify at all but only read the value more than
1 time in a single expression.

....yes, and yes.

Hence only these are defined behaviors:

printf("%d\n", ++*p); /* prints the incremented vale of *p */
printf("%d, %d, %d\n", *p, *p, *p);

Yes. And similar ones, of course.

A footnote says:

This paragraph renders undefined statement expressions such as
i = ++i + 1;
a[i++] = i;

both expressions are undefined. I don't see why standard used 2
expressions when one is enough.

More examples, more clarity. (Up to a reasonable point, of course.)

Richard

[arnuld]

On Mon, 06 Oct 2008 00:42:42 -0700, Keith Thompson wrote:

>arnuld <su*****@invalid.addresswrites:

> we can modify the value in a single expression, then we must not read
the vale either before or after the modification.

Um, not quite. You can certainly read and then modify the value of an
object with an expression; for example, "i = i + 1;" is ok.

That I know, because there is stupidity revolving here like i = i++ + 1.

Huh? Do you mean that "i = i + 1;" and "a[i] = i;" are two different
expressions? Yes, they are (actually two different expression
statements). What's your point?

point is: If we put both of them in one expression, then we will stilll
have well-defined behavior, so why you used 2 expressions:

printf("values are: %d and %d\n", i = i + 1, a[i] = i);

its not UB.

Um, ok. Does the smiley mean you didn't get it, or am I just missing
the joke?

I was happy that I understood full of your paragraph when I don't
understand 50% of them on clc (because of pointer-business)

--
www.lispmachine.wordpress.com
my email is @ the above blog.

[Bart van Ingen Schenau]

On Oct 6, 9:53 am, arnuld <[e-mail]:

On Mon, 06 Oct 2008 00:42:42 -0700, Keith Thompson wrote:

Huh? Do you mean that "i = i + 1;" and "a[i] = i;" are two different
expressions? Yes, they are (actually two different expression
statements). What's your point?

point is: If we put both of them in one expression, then we will stilll
have well-defined behavior, so why you used 2 expressions:

printf("values are: %d and %d\n", i = i + 1, a[i] = i);

its not UB.

Actually, that printf call *does* cause UB.
In the second argument, you modify the variable i and
in the third argument, you access (read) the variable i for another
reason than to calculate the new value of i.
As there is no sequence point between the evaluation of the two
arguments, the behaviour is undefined.

Bart v Ingen Schenau

[Richard Tobin]

In article <87************@bsb.me.uk>,
Ben Bacarisse <be********@bsb.me.ukwrote:

>Yes it is. If you find the legalese hard, I find the following
useful: if you can find two (or more) valid orders of execution that
give different results then the code is UB. I am not sure that this
always works but it seems, in practise, to be pretty useful.

Not only is that a good rule of thumb, but it explains *why* it's
undefined behaviour: different compilers may choose different orders,
or perhaps even interleave execution of the expressions.

-- Richard
--
Please remember to mention me / in tapes you leave behind.

[Keith Thompson]

arnuld <su*****@invalid.addresswrites:

>On Mon, 06 Oct 2008 00:42:42 -0700, Keith Thompson wrote:

>>arnuld <su*****@invalid.addresswrites:

>> we can modify the value in a single expression, then we must not read
the vale either before or after the modification.

>Um, not quite. You can certainly read and then modify the value of an
object with an expression; for example, "i = i + 1;" is ok.

That I know, because there is stupidity revolving here like i = i++ + 1.

Good, but the rule as you stated it above implies that "i = i + 1;" is
undefined.

>Huh? Do you mean that "i = i + 1;" and "a[i] = i;" are two different
expressions? Yes, they are (actually two different expression
statements). What's your point?

point is: If we put both of them in one expression, then we will stilll
have well-defined behavior, so why you used 2 expressions:

printf("values are: %d and %d\n", i = i + 1, a[i] = i);

its not UB.

Yes, it is. But even if it weren't, using two examples is clearer
than shoving the examples together into a single more complicated
expression.

[...]

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Eric Sosman]

arnuld wrote:

[...]
point is: If we put both of them in one expression, then we will stilll
have well-defined behavior, so why you used 2 expressions:

printf("values are: %d and %d\n", i = i + 1, a[i] = i);

its not UB.

It *is* undefined behavior. Specifically, it both modifies `i'
(in `i = i + 1') and uses the value outside the modification itself
(in `a[i] = i') without an intervening sequence point. The commas
in the function argument list are not the comma operator, which
would introduce sequence points, but merely punctuation, which doesn't.

References: C99 6.5p2, FAQ 3.1 (and links to related questions).

--
Er*********@sun.com