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

[Dik T. Winter]

In article <oE************ *******@news.in digo.ieFrederic k Gotham <fg*******@SPAM .comwrites:

Richard Tobin posted:

unary-expression:
[...]
unary-operator cast expression
sizeof unary-expression
sizeof ( type-name )

....

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

Richard skipped something. In addition to what he mentioned, it can
also be a "postfix-expression", and going further down the syntax we find that
(1) a postfix-expression can be a "primary-expression",
(2) a primary-expression can be:
identifier
constant
string-literal
( expression )

int main(void)
{
sizeof(5+4);
return 0;
}

It compiles just fine with gcc.

It should.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Antti-Juhani Kaijanaho]

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

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

Operator precedence does not specify evaluation order; it is only used
to disambiguate ambiguous expressions. (Of course, in standard C, there
are no ambiguous expressions:)

[Frederick Gotham]

sj*******@yahoo .com posted:

This post might be enlightening:
http://groups.google.com/group/comp....ec23?dmode=sou
rce

An absolute masterpiece of a post! I quite like:

| This, incidentally, is also why parentheses are
| not required around "b = c" in:
|
| result = (a ? b = c : d);
Still though, the following expression:

sizeof(double)-5

has an ambiguous parse, and so operator precedence should come into play --
which would lead me to believe that there is a cast involved.

--

Frederick Gotham

[Richard Tobin]

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

>Still though, the following expression:

sizeof(double)-5

has an ambiguous parse

It does not have an ambiguous parse according to the grammar in the
standard, because (double)-5 is not a unary expression and therefore
cannot be the argument to the argument to the sizeof operator.

-- Richard

[Old Wolf]

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?

Maybe you could address your concerns to whoever wrote
this "operator table" that you keep going on about.

The C standard does not define an "operator table" or "precedence ".

[Chris Dollin]

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?

Someone who reads the C grammar.

All I said was that gcc didn't compile it. gcc isn't C.

Even if gcc accepted the expression "batman @prescribes valium"
and compiled code to teleport tribbles to Gotham city, it wouldn't
cause the C grammar to suddenly accept as an expression the text
you've been quoting.

--
Chris "falling further in" Dollin
"We did not have time to find out everything we wanted to know."
- James Blish, /A Clash of Cymbals/

[xdevel]

Robert Gamble ha scritto:

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

I read it, simply, from K&R and other C/C++ books