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

[Fred Kleinschmidt]

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

>
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

Consider this:
sizeof(double)-5

There is a syntactic ambiguity in this type of expression. It could be
interpreted as three unary operators: negation, the cast (double)
and 'sizeof', successively applied to the value 5:
sizeof( (double)(-5) )
or it could be interpreted as a binaary subtraction whose
operands are sizeof(double) and 5:
(sizeof (double)) - 5

This ambiguous case is resolved quite arbitrarily by declaring that the
latter interpretation shall be used.

Now replace the minus with a plus:
sizeof(double)+ 5
By the same logic, this is interpreted as (sizeof(double) ) + 5

The same logic is used to have
sizeof(double)5 interpreted as (sizeof(double) )5
which is a syntax error.

This type of thing is why many people like to
include parentheses around the operand of sizeof regardless of
whether that operand is a type name or a data object. It makes it
clear what the intent of the expression really is.
--
Fred L. Kleinschmidt
Boeing Associate Technical Fellow
Technical Architect, Software Reuse Project

[Richard Tobin]

In article <eg**********@m ain.corriga.net >,
Rod Pemberton <do*********@bi tfoad.cmmwrote:

>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.

Presumably it just corresponds to the hierarchy of 17 productions from
"expression " down to "postfix-expression".

I always found it a little strange to talk about predence levels for
unary operators. For binary operators and unary operators on opposite
sides, precedence tells you which operator binds most tightly. But
for unary operators on the same side, it just tells you which
combinations are legal.

-- Richard

[Robert Gamble]

Frederick Gotham wrote:

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.

It's clearly spelled out in the Standard, section 6.5 for C99, section
3.3 for ANSI C89.

Robert Gamble

[Antti-Juhani Kaijanaho]

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

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.

Where in the standard is that precedence table? My copies do not have
it. Instead, it defines the grammar as follows:

6.5.3:
unary-expression:
postfix-expression
++ unary-expression
-- unary-expression
unary-operator cast-expression
sizeof unary-expression
sizeof ( type-name )

unary-operator: one of
& * + - ~ !

6.5.4:
cast-expression:
unary-expression
( type-name ) cast-expression

It is quite clear from these grammar excerpts that casts and sizeof do not
have the same precedence; sizeof binds more tightly.

To use a cast expression in the sizeof operand, it needs to be put in
parentheses.

[Antti-Juhani Kaijanaho]

xdevel <xd********@yah oo.comkirjoitti 06.10.2006:
sizeof and cast have the same precedence in fact they are on

the same row:
! ~ ++ -- + - * & (type) sizeof
but they bind from right to left

C&V please.

[Robert Gamble]

xdevel wrote:

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

In the same row of what? Your precedence table? You do realize that
it is the Standard that dictates the precedence of operators, not
whatever table you are looking at don't you?

Robert Gamble

[Frederick Gotham]

Chris Dollin posted:

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.

Who knows if it doesn't parse? All I said was that gcc didn't compile it. gcc
isn't C.

--

Frederick Gotham

[Frederick Gotham]

Fred Kleinschmidt posted:

Consider this:
sizeof(double)-5

There is a syntactic ambiguity in this type of expression. It could be
interpreted as three unary operators: negation, the cast (double)
and 'sizeof', successively applied to the value 5:
sizeof( (double)(-5) )
or it could be interpreted as a binaary subtraction whose
operands are sizeof(double) and 5:
(sizeof (double)) - 5

Shouldn't an operator table clarify this though, indicating what's evaluated
in what order?

--

Frederick Gotham

[Harald van Dijk]

Frederick Gotham wrote:

Chris Dollin posted:

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.

Who knows if it doesn't parse? All I said was that gcc didn't compile it. gcc
isn't C.

It doesn't parse using the grammar given by the C standard. The C
standard defines C.

[sjdevnull]

Frederick Gotham wrote:

Fred Kleinschmidt posted:

Consider this:
sizeof(double)-5

There is a syntactic ambiguity in this type of expression. It could be
interpreted as three unary operators: negation, the cast (double)
and 'sizeof', successively applied to the value 5:
sizeof( (double)(-5) )
or it could be interpreted as a binaary subtraction whose
operands are sizeof(double) and 5:
(sizeof (double)) - 5

Shouldn't an operator table clarify this though, indicating what's evaluated
in what order?

I don't know what you mean by "operator table", but the grammar does
clarify this.

This post might be enlightening:
http://groups.google.com/group/comp....3?dmode=source

I found this particularly helpful:

"K&R (either edition), and most sensible humans, use an "operator
precedence" grammar to describe expressions in C. The C standards (C89
and C99 both) instead use a fully factored grammar, in which the
problems solved by "operator precedence and associativity" never even
arise."