Precedence of sizeof

[Frederick Gotham]

sizeof has the same precedence as a cast, and they both bind from right to
left. The following won't compile for me with gcc:

int main(void)
{
sizeof(double)5 ;

return 0;
}

Has it got something to do with "globbing"?

--

Frederick Gotham

[Frederick Gotham]

Antti-Juhani Kaijanaho posted:

Frederick Gotham <fg*******@SPAM .comkirjoitti 06.10.2006:

>sizeof has the same precedence as a cast

No it doesn't.

Please indicate where you obtain that information, because my own operator
table indicates that they indeed have equal precedence.

--

Frederick Gotham

[lovecreatesbea...]

On Oct 6, 9:56 pm, Frederick Gotham <fgotha...@SPAM .comwrote:

Cong Wang posted:

"sizeof ((double)5)" works well.Yes, I realise that. My question pertains to operator precedence and

associativity -- specifically, why:

sizeof(double)5

is interpretted by gcc as:

(sizeof(double) )5

rather than:

sizeof((double) 5)

The operand '5' has no operators on both of its left and right sides. I
think the associativity does not apply here.

[Frederick Gotham]

Robert Gamble posted:

On Oct 6, 9:39 am, Frederick Gotham <fgotha...@SPAM .comwrote:

>sizeof has the same precedence as a cast

No, the sizeof operator has a higher precedence than the cast operator.

>and they both bind from right to
left. The following won't compile for me with gcc:

int main(void)
{
sizeof(double)5 ;

return 0;
}

As it shouldn't because it doesn't make any sense.

It makes perfect sense. The literal, 5, is cast to a double, and the result
is supplied as an operand to sizeof.

Your expression is evaluated as: (sizeof(double) ) 5; which is a syntax
error and is why it doesn't compile.

I know that. My question is why it isn't interpreted as:

sizeof((double) 5)

My operator precedence table would have me to believe that it should.

--

Frederick Gotham

[Frederick Gotham]

lovecreatesbea. [e-mail] posted:

> sizeof(double)5

is interpretted by gcc as:

(sizeof(double) )5

rather than:

sizeof((double) 5)

The operand '5' has no operators on both of its left and right sides.

5 is the operand of the cast.

The result of the cast is the operand of sizeof.

--

Frederick Gotham

[xdevel]

Robert Gamble ha scritto:

No, the sizeof operator has a higher precedence than the cast operator.

No, sizeof and cast have the same precedence in fact they are on
the same row:
! ~ ++ -- + - * & (type) sizeof
but they bind from right to left

and they both bind from right to
left. The following won't compile for me with gcc:

int main(void)
{
sizeof(double)5 ;

return 0;
}

As it shouldn't because it doesn't make any sense.

Has it got something to do with "globbing"?

I have no idea what you mean by "globbing" in this context, your
expression is evaluated as:
(sizeof(double) ) 5;
which is a syntax error and is why it doesn't compile.

Robert Gamble

[lovecreatesbea...]

On Oct 6, 10:26 pm, Frederick Gotham <fgotha...@SPAM .comwrote:

lovecreatesbea. [e-mail] posted:

sizeof(double)5

is interpretted by gcc as:

(sizeof(double) )5

rather than:

sizeof((double) 5)

The operand '5' has no operators on both of its left and right sides.5 is the operand of the cast.

The result of the cast is the operand of sizeof.

I meant the '5' in your original example: sizeof(double)5 ;

[Chris Dollin]

Frederick Gotham wrote:

lovecreatesbea. [e-mail] posted:

>> sizeof(double)5

is interpretted by gcc as:

(sizeof(double) )5

rather than:

sizeof((double) 5)

The operand '5' has no operators on both of its left and right sides.

5 is the operand of the cast.

The result of the cast is the operand of sizeof.

Since the text doesn't parse, you can't say "5 is the operand of the cast"
or "The result of the cast is the operand of sizeof" and be talking
about C grammar.

--
Chris "english this isn't" Dollin
Meaning precedes definition.

[Richard Tobin]

In article <oE************ *******@news.in digo.ie>,
Frederick Gotham <fg*******@SPAM .comwrote:

>"(double)5" is not a unary expression, so only "sizeof ( type-name )"
is possible, and that of course doesn't work because of the "5"
afterwards.

>So is a unary expression something simple like a literal or the name of an
object?

I'm sure you can read the grammar as well as I can. But essentially:

A unary-expression is a postfix-expression optionally preceded by
++, --, &, *, +, =, ~, !, or sizeof, or is sizeof ( type-name ).

A postfix-expression is a primary-expression optionally followed by
a subscript, and argument list, ., ->, ++, or --.

A primary-expression is an identifier, a constant, a string-literal,
or a parenthesized expression.

>Does that mean that the following should be bogus:

sizeof(5+4);

No, (5+4) is a primary-expression which is a postfix-expression which is
a unary-expression.

-- Richard

[Rod Pemberton]

"Frederick Gotham" <fg*******@SPAM .comwrote in message
news:cH******** ***********@new s.indigo.ie...

Robert Gamble posted:

On Oct 6, 9:39 am, Frederick Gotham <fgotha...@SPAM .comwrote:

sizeof has the same precedence as a cast

No, the sizeof operator has a higher precedence than the cast operator.

and they both bind from right to
left. The following won't compile for me with gcc:

int main(void)
{
sizeof(double)5 ;

return 0;
}

As it shouldn't because it doesn't make any sense.

It makes perfect sense. The literal, 5, is cast to a double, and the

result

is supplied as an operand to sizeof.

Your expression is evaluated as: (sizeof(double) ) 5; which is a syntax
error and is why it doesn't compile.

I know that. My question is why it isn't interpreted as:

sizeof((double) 5)

My operator precedence table would have me to believe that it should.

I'm not sure how they calculate the precedence level from the grammar, but
"C: A Reference Manual" by Samuel Harbison and Guy Steele, Jr. 3rd. edition,
page 167, lists 17 precedence levels. They list unary operators:
sizeof,~,!,-,+,&,* as level 15 and unary casts as level 14 (i.e., cast has
lower precedence). Both are right associative. I know they corrected at
least one error in table at a later date. Whose precedence table are you
using?
Rod Pemberton

[Robert Gamble]

Frederick Gotham wrote:

Robert Gamble posted:

On Oct 6, 9:39 am, Frederick Gotham <fgotha...@SPAM .comwrote:

sizeof has the same precedence as a cast

No, the sizeof operator has a higher precedence than the cast operator.

and they both bind from right to
left. The following won't compile for me with gcc:

int main(void)
{
sizeof(double)5 ;

return 0;
}

As it shouldn't because it doesn't make any sense.

It makes perfect sense.

To you it does, that's the problem.

The literal, 5, is cast to a double, and the result
is supplied as an operand to sizeof.

I have already explained to you that this is not the case since the
sizeof operator has a higher precedence than a cast, repeating your
assertion will do little to change the facts.

Your expression is evaluated as: (sizeof(double) ) 5; which is a syntax
error and is why it doesn't compile.

I know that. My question is why it isn't interpreted as:

sizeof((double) 5)

And I have clearly explained why.

My operator precedence table would have me to believe that it should.

Either you or your operator table needs to be tweaked.

Robert Gamble