sizeof(x)

[Ioannis Vranos]

In C99 it is mentioned:

"The sizeof operator yields the size (in bytes) of its operand, which
may be an expression or the parenthesized name of a type.".
If I am not wrong, this implies that

int x;

size_t y= sizeof(x);
is not valid.
and only the following is valid:
int x;

size_t y= sizeof x;
However I am puzzled, and thought the first was also valid in
C90/C95(/C++03).

[Keith Thompson]

Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrites:

Ian Collins wrote:

>Ioannis Vranos wrote:

>>Ioannis Vranos wrote:
I first saw that only sizeof x is valid at the pdf hosted at
http://cprog.tomsweb.net.

More specifically the above writes:

"sizeof Returns size of operand in bytes; two forms:
1) sizeof(type)
2) sizeof expression"

Did you read what Harald said: "(x) is a perfectly valid expression"?

... right. However sizeofx doesn't compile and if (x) was considered an
expression it should be sizeof (x), and sizeof(x) shouldn't compile.

C code is split into tokens before those tokens are parsed. (The
process actually involves "preprocess or tokens", which are later
converted to "tokens", but that doesn't matter in this case.)

``sizeof'' is a keyword; like all keywords, it has the form of an
identifier. ``('' and ``)'' are punctuators. Two adjacent
identifiers, keywords, or numeric constants must be separated by
whitespace (a comment counts as whitespace). A keyword and a
punctuator don't need any whitespace to separate them.

``sizeofx'' is just a single identifier that has nothing to do with
the ``sizeof'' keyword. It compiles just fine if you happen to have
declared it:

int sizeofx = 42;
sizeofx;

``sizeof x'' is two tokens, ``sizeof'' and ``x''. If ``x'' is an
expression (actually a unary-expression; see the grammar), then that's
a legal expression.

``sizeof(x)'' is four tokens, ``sizeof'', ``('', ``x'', and ``)''. If
``x'' is a type-name, then that's a valid expression. If ``x'' is an
expression, then ``(x)'' is also a valid expression, and the whole
thing is also a valid expression.

--
Keith Thompson (The_Other_Keit h) <ks***@mib.or g>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Kaz Kylheku]

On Mar 30, 1:11*pm, Ioannis Vranos <ivra...@nospam .no.spamfreemai l.gr>
wrote:

expression it should be sizeof (x), and sizeof(x) shouldn't compile.

Good grief!

Do you realize that children that were in junior highschool back when
you first started being a goof here now have CS degrees and software
jobs?

You need to disable your anti-learning filter, or at least reduce the
coefficients in its confusion matrix a little bit.

[Richard Tobin]

In article <fs***********@ ulysses.noc.ntu a.gr>,
Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrote:

>Then I checked the C99 standard and it mentions what is shown above.
Clearly C99 doesn't mention parenthesized expression.

A parenthesized expression is an expression, (that's a fact about C
grammar, not the English language). sizeof(x) is no more a problem
than a[(x)].

-- Richard
--
:wq