tricky use of sizeof [explanation wanted]

[goacross]

i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

thanks

[goacross]

On Sep 13, 12:34 pm, [e-mail] wrote:

i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

thanks

I run the program in vc :)

[junky_fellow]

On Sep 13, 9:34 am, [e-mail] wrote:

i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

thanks

This is becuase,
sizeof('h')[p] will return the size of the expression ('h')[p] which
will always be 1 as the p is pointer to char.

[Zara]

On Wed, 12 Sep 2007 21:34:01 -0700, go******@gmail.com wrote:

>i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

Compare these two expressions:

char n=(sizeof('h'))[p]; (1)

char n=sizeof(('h')[p]); (2)

Your second expression is being interpreted as (2), and what you
wanted was (1)

The problem lies in sizeof be¡ing greedy when it refers to an object
and not to a type

Best regrads,

Zara

[Flash Gordon]

Zara wrote, On 13/09/07 07:00:

On Wed, 12 Sep 2007 21:34:01 -0700, go******@gmail.com wrote:

>i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

Compare these two expressions:

char n=(sizeof('h'))[p]; (1)

This is the same as
char n = (sizeof 'h')[p];
This will still not do what the OP expected in C although it will in
C++. This is because a character literal like 'h' has type int in C
(probably 4 on the OPs system, although it could be any other number)
whereas in C++ it would have type char.

char n=sizeof(('h')[p]); (2)

Your second expression is being interpreted as (2), and what you
wanted was (1)

The problem lies in sizeof be¡ing greedy when it refers to an object
and not to a type

Also note that sizeof is an operator, NOT a function. This is why you
can do "sizeof expression" rather than "sizeof(expression)" and is
probably also part of the OPs confusion.
--
Flash Gordon

[goacross]

On Sep 13, 2:00 pm, Zara <[e-mail]:

On Wed, 12 Sep 2007 21:34:01 -0700, [e-mail] wrote:

i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

Compare these two expressions:

char n=(sizeof('h'))[p]; (1)

char n=sizeof(('h')[p]); (2)

Your second expression is being interpreted as (2), and what you
wanted was (1)

The problem lies in sizeof be¡ing greedy when it refers to an object
and not to a type

Best regrads,

Zara

Thank you all.
It's clear now. :)

[Army1987]

On Wed, 12 Sep 2007 21:34:01 -0700, goacross wrote:

i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

sizeof('h') is sizeof(int). If it is four, 4+"abc" will point past
the end of the string, so dereferencing it, even implicitly with
[], will cause UB. If sizeof(int) is 4, even pointer arithmetic
itself will cause UB, even if you don't dereference. If
sizeof(int) < 4, n will be 'b', 'c', or 0.

--
Army1987 (Replace "NOSPAM" with "email")
If you're sending e-mail from a Windows machine, turn off Microsoft's
stupid “Smart Quotes� feature. This is so you'll avoid sprinkling garbage
characters through your mail. -- Eric S. Raymond and Rick Moen

[Barry Schwarz]

On Wed, 12 Sep 2007 21:34:01 -0700, go******@gmail.com wrote:

>i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

*(1+p) = *(p+1) = p[1] = 1[p].
Remove del for email

[Barry Schwarz]

On Fri, 14 Sep 2007 12:35:41 +0200, Army1987 <ar******@NOSPAM.it>
wrote:

>On Wed, 12 Sep 2007 21:34:01 -0700, goacross wrote:

>i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

sizeof('h') is sizeof(int). If it is four, 4+"abc" will point past
the end of the string, so dereferencing it, even implicitly with
[], will cause UB. If sizeof(int) is 4, even pointer arithmetic
itself will cause UB, even if you don't dereference. If
sizeof(int) < 4, n will be 'b', 'c', or 0.

Except for variable length arrays (not germane to this thread), sizeof
never evaluates its operand. Consequently, nothing gets dereferenced.
The operand is analyzed only to determine its type, not whether it
actually exists.
Remove del for email

[Army1987]

On Fri, 14 Sep 2007 14:18:21 -0700, Barry Schwarz wrote:

On Fri, 14 Sep 2007 12:35:41 +0200, Army1987 <ar******@NOSPAM.it>
wrote:

>>On Wed, 12 Sep 2007 21:34:01 -0700, goacross wrote:

>>2. char n=sizeof('h')[p]; // n=1;

sizeof('h') is sizeof(int). If it is four, 4+"abc" will point past
the end of the string, so dereferencing it, even implicitly with
[], will cause UB. If sizeof(int) is 4, even pointer arithmetic
itself will cause UB, even if you don't dereference. If
sizeof(int) < 4, n will be 'b', 'c', or 0.

Except for variable length arrays (not germane to this thread), sizeof
never evaluates its operand. Consequently, nothing gets dereferenced.
The operand is analyzed only to determine its type, not whether it
actually exists.

Yeah, damned syntax... sizeof('h')[p] means sizeof(('h')[p]), not
(sizeof('h'))[p] as I was thinking when I wrote that reply...
--
Army1987 (Replace "NOSPAM" with "email")
If you're sending e-mail from a Windows machine, turn off Microsoft's
stupid “Smart Quotes� feature. This is so you'll avoid sprinkling garbage
characters through your mail. -- Eric S. Raymond and Rick Moen

[Charlie Gordon]

"Barry Schwarz" <sc******@doezl.neta écrit dans le message de news:
md********************************@4ax.com...

On Fri, 14 Sep 2007 12:35:41 +0200, Army1987 <ar******@NOSPAM.it>
wrote:

>>On Wed, 12 Sep 2007 21:34:01 -0700, goacross wrote:

>>i found something tricky this morning.

char *p="abc";

1. char m=1[p];// m='b'

2. char n=sizeof('h')[p]; // n=1;

I guess the reason of 1is,

1+p=p+1; so the same as p[1];

but why the seemed same thing doesn't work on case 2?

sizeof('h') is sizeof(int). If it is four, 4+"abc" will point past
the end of the string, so dereferencing it, even implicitly with
[], will cause UB. If sizeof(int) is 4, even pointer arithmetic
itself will cause UB, even if you don't dereference. If
sizeof(int) < 4, n will be 'b', 'c', or 0.

No, you are not on the right track.

Except for variable length arrays (not germane to this thread), sizeof
never evaluates its operand. Consequently, nothing gets dereferenced.
The operand is analyzed only to determine its type, not whether it
actually exists.

sizeof does not evaluate its operand in variable length arrays either, the
evaluation is done at run-time to determine the size of the operand not
known at compile time, but that does not involve evaluating the operand.

The rest is true but unrelated to the previous post (erroneous) answer.

--
Chqrlie.