sizeof without parenthesis

[Howard Bryce]

I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument? Is this admissible within the standard? Can it in general be
done with one argument functions? Why would one want to do it anyway,
other than showing that one knows and to save two characters?

[Richard Heathfield]

Howard Bryce said:

I have come across code containing things like

sizeof int

which won't compile. The operand of sizeof is either an expression or a
parenthesised type.

How come that one can invoke sizeof without any parentheses surrounding
its argument?

It's not an argument, because sizeof is not a function. It's an operator,
taking an operand.

Is this admissible within the standard?

Yes, of course.

Can it in general be done with one argument functions?

No, but sizeof is not a function.

Why would one want to do it anyway,
other than showing that one knows and to save two characters?

(Why (would (one (want (to (add (spurious (parentheses)))))))?)

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[Michael Mair]

Howard Bryce wrote:

I have come across code containing things like

sizeof int

This is almost certainly not true.
You may have come across things like
sizeof myVar

How come that one can invoke sizeof without any parentheses surrounding
its argument? Is this admissible within the standard? Can it in general be
done with one argument functions? Why would one want to do it anyway,
other than showing that one knows and to save two characters?

sizeof is an operator, not a function.
Its argument either is a type name in parentheses or some expression.
Example:

The prefered way to use malloc() in comp.lang.c is
T *p;
....
p = malloc(sizeof *p);
if (p == NULL) {
/* your error handling here */
}
or
p = malloc(number * sizeof *p);
rather than
p = malloc(sizeof (T));
or
p = malloc(number * sizeof (T));
because changing the type of p (and *p, respectively) necessitates
no adaption of the argument of malloc().

Some people are afraid that unparenthesised sizeof operands may
bite them or are afraid that they get the "precedence" wrong, thus
they always write "sizeof (something)".
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Keith Thompson]

Howard Bryce <Hb****@yahoo.comwrites:

I have come across code containing things like

sizeof int

That particular form is illegal.

How come that one can invoke sizeof without any parentheses surrounding
its argument? Is this admissible within the standard? Can it in general be
done with one argument functions? Why would one want to do it anyway,
other than showing that one knows and to save two characters?

"sizeof" is not a function, it's a built-in unary operator, like "&"
or "*". It just happens to be the only operator whose symbol is a
keyword rather than a punctuation mark.

The syntax is:

sizeof unary-expression
sizeof ( type-name )

For example, you can write "sizeof 42"; 42 is an expression, and
"sizeof 42" yields the size of that expression's type (int).

You can also write "sizeof(42)" if you like. In this case, the
parentheses aren't related to the sizeof operator; you're merely
applying "sizeof" to a parenthesized expression. It's exactly the
same thing as "-42" vs. "-(42)".

Unlike other operators, sizeof can also be applied to a parenthesized
type name, as in "sizeof(int)". "sizeof int", without the
parentheses, is a syntax error. The parentheses in "sizeof(int)" are
not syntactically related to the parentheses in a function call (or to
the parentheses in a cast operation); they're merely part of the
syntax of the sizeof operator.

(Function calls always require parentheses.)

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Ancient_Hacker]

Howard Bryce wrote:

I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument?

Well, I guess K & R ran out of ascii characters. Every dang printing
character except for backquote and at sign had already been used for
something or nother, usually as a unary or binary operator.

You see, "sizeof( foo )" may LOOK like a function call, but it's not.
Mainly because "sizeof'" has to be determined at compile time.
Otherwise it cvouldnt be used in many contexts where the compiler
requires a constant or expression that can be completely evaluated at
compile-time. So "sizeof" is a lot more like ampersand, or tilde, or
unary minus--, it does something to the thing following it. In
particular, it returns the "size" of whatever follows.

If just one little neuron had fired, maybe K & R would have made
at-sign the "sizeof unary operator and a whole lot of discusions on
this N.G. would have never materialized-- an alternate and not at all
horrific divergent reality. Lets see: i = @Array; Hmmm, not any
whole lot uglier than any other C construct. And nobody hardly would
be asking "What the heck is with this sizeof thingy anyway?".

[Walter Roberson]

In article <11**********************@e3g2000cwe.googlegroups. com>,
Ancient_Hacker <gr**@comcast.netwrote:

>Howard Bryce wrote:

>How come that one can invoke sizeof without any parentheses surrounding
its argument?

>Well, I guess K & R ran out of ascii characters. Every dang printing
character except for backquote and at sign had already been used for
something or nother, usually as a unary or binary operator.

You missed dollar sign. Possibly it wasn't used because some closely
related standards use that position as the "national currency symbol"
(such as pounds stirling).

I do not have any hypothesis about backquote -- none that wouldn't
also involve {|} .

>If just one little neuron had fired, maybe K & R would have made
at-sign the "sizeof unary operator and a whole lot of discusions on
this N.G. would have never materialized-- an alternate and not at all
horrific divergent reality. Lets see: i = @Array; Hmmm, not any
whole lot uglier than any other C construct. And nobody hardly would
be asking "What the heck is with this sizeof thingy anyway?".

Did the use of @ as a rubout character (teletype) happen to proceed
the development of C?
--
"It is important to remember that when it comes to law, computers
never make copies, only human beings make copies. Computers are given
commands, not permission. Only people can be given permission."
-- Brad Templeton

[Michael Mair]

Ancient_Hacker wrote:

Howard Bryce wrote:

>>I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument?

Well, I guess K & R ran out of ascii characters. Every dang printing
character except for backquote and at sign had already been used for
something or nother, usually as a unary or binary operator.

$ comes to mind...

You see, "sizeof( foo )" may LOOK like a function call, but it's not.
Mainly because "sizeof'" has to be determined at compile time.
Otherwise it cvouldnt be used in many contexts where the compiler
requires a constant or expression that can be completely evaluated at
compile-time. So "sizeof" is a lot more like ampersand, or tilde, or
unary minus--, it does something to the thing following it. In
particular, it returns the "size" of whatever follows.

If just one little neuron had fired, maybe K & R would have made
at-sign the "sizeof unary operator and a whole lot of discusions on
this N.G. would have never materialized-- an alternate and not at all
horrific divergent reality. Lets see: i = @Array;

Looks like Perl ;-)

Hmmm, not any
whole lot uglier than any other C construct. And nobody hardly would
be asking "What the heck is with this sizeof thingy anyway?".

True. And they might have done a lot of other things differently
which also would have made life easier for us.
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Ancient_Hacker]

Walter Roberson wrote:

Did the use of @ as a rubout character (teletype) happen to proceed
the development of C?

Precede, and no I don't think so.

The @ as line erase I first saw in Unix. Having a rubout character on
a shift key seems particularly inelegant, although some older terminals
(GE Terminet>??) may have had a lower case atsign near the return key.

--
"It is important to remember that when it comes to law, computers
never make copies, only human beings make copies. Computers are given
commands, not permission. Only people can be given permission."
-- Brad Templeton

[Keith Thompson]

Michael Mair <Mi**********@invalid.invalidwrites:

Ancient_Hacker wrote:

>Howard Bryce wrote:

>>>I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument?

Well, I guess K & R ran out of ascii characters. Every dang
printing
character except for backquote and at sign had already been used for
something or nother, usually as a unary or binary operator.

$ comes to mind...

[...]

At the time, I think a lot of non-US keyboards didn't have the '$'
character. (Of course, they later ran into problems with other
characters that weren't universally available, thus trigraphs.)

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Richard Tobin]

In article <OO********************@bt.com>,
Richard Heathfield <in*****@invalid.invalidwrote:

>Why would one want to do it anyway,
other than showing that one knows and to save two characters?

>(Why (would (one (want (to (add (spurious (parentheses)))))))?)

Well, you could ask mathematicians, who sometimes write f x and
sometimes write f(x). Presumably they'd tell you that they write
whatever seems clearest at the time.

-- Richard

[Jordan Abel]

On 2006-10-02 16:29:53 -0400, ro******@ibd.nrc-cnrc.gc.ca (Walter
Roberson) said:

Did the use of @ as a rubout character (teletype) happen to proceed
the development of C?

from what i've heard, it's originally a multics thing, so yeah, but the
same applies to #. Which some of the same "closely related standards"
that lack dollar sign sometimes use for something else - like a pound
sign. It's really hard to justify excluding _any_ of those characters,
in the historical context, while allowing { | } \ [ ] ^ _ ~ but maybe
it's an ebcdic thing.

[Keith Thompson]

"Ancient_Hacker" <gr**@comcast.netwrites:

Howard Bryce wrote:

>I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument?

Well, I guess K & R ran out of ascii characters. Every dang printing
character except for backquote and at sign had already been used for
something or nother, usually as a unary or binary operator.

You see, "sizeof( foo )" may LOOK like a function call, but it's not.
Mainly because "sizeof'" has to be determined at compile time.
Otherwise it cvouldnt be used in many contexts where the compiler
requires a constant or expression that can be completely evaluated at
compile-time. So "sizeof" is a lot more like ampersand, or tilde, or
unary minus--, it does something to the thing following it. In
particular, it returns the "size" of whatever follows.

If just one little neuron had fired, maybe K & R would have made
at-sign the "sizeof unary operator and a whole lot of discusions on
this N.G. would have never materialized-- an alternate and not at all
horrific divergent reality. Lets see: i = @Array; Hmmm, not any
whole lot uglier than any other C construct. And nobody hardly would
be asking "What the heck is with this sizeof thingy anyway?".

You're assuming that operator names *should* always be punctuation
marks. That's a valid opinion, but not one that I share. There's
nothing wrong with using punctuation marks for some operators, and
keywords for others. (For example, some other languages use "div",
"mod", and/or "rem" for integer division.)

What sometimes causes confusion in C is that "sizeof" is the *only*
operator represented by a keyword. I certainly wouldn't suggest that
"+" and "-" shouldn't be used for addition and subtraction, but
perhaps if a few other operators were represented as keywords,
"sizeof" wouldn't cause so much confusion.

But once you understand that "sizeof" is an operator, and that you
have to understand the specific rules for its use, it's really not all
that complicated.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[jmcgill]

Howard Bryce wrote:

I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument?

sizeof is not a function, it is an operator. It is somewhat important
to understand the distinction.

Is this admissible within the standard? Can it in general be
done with one argument functions?

sizeof is not a one-argument function, it is a unary operator.

Why would one want to do it anyway,
other than showing that one knows and to save two characters?

It helps distinguish the fact that sizeof is not a function, it is an
operator.

When sizeof is used with a type name, the parentheses are required.

It is not incorrect to use parentheses in any use of sizeof, because it
introduces no ambiguity, but it is not required to use parentheses with
a variable or expression.

[T.M. Sommers]

Walter Roberson wrote:

>
Did the use of @ as a rubout character (teletype) happen to proceed
the development of C?

It certainly wasn't used on regular teletypes. When using
5-level Baudot/Murray code, rubout was all marks, or
letters-shift. I think it was all marks when using 8-level code,
too, and I think the ASR-33 had a special rubout key, but I could
be wrong.

--
Thomas M. Sommers -- tm*@nj.net -- AB2SB

[Paul Connolly]

(Why (would (one (want (to (add (spurious (parentheses)))))))?)
perhaps they might be lisp programmers?
(after years of jokes like this the newer functional programming languages
(like ml) don't even have brackets around the arguments to a function - they
don't even have commas to delimit arguments).

[Joe Wright]

Howard Bryce wrote:

I have come across code containing things like

sizeof int

How come that one can invoke sizeof without any parentheses surrounding
its argument? Is this admissible within the standard? Can it in general be
done with one argument functions? Why would one want to do it anyway,
other than showing that one knows and to save two characters?

<rant>
How come you need to crowd this valuable space with questions to which
you should already know the answer. Your C reference will tell you what
sizeof is all about and how you can use it.

If you want to know WHY it's that way, you're in the wrong group. Maybe
comp.std.c or something.
</rant>

The sizeof operator is a compiler primitive and not particularly smart.
Its default operand is the name of an object. Types may be more
complicated than simple names and so we give the compiler a clue with
parentheses that its argument is a (user defined?) type.

#include <stdio.h>

typedef struct stru {
int a;
int b;
int c;
} stru;

size_t size;
int i;
stru s;

int main(void) {
size = sizeof s;
printf("Size is %lu bytes.\n", size);
size = sizeof (stru);
printf("Size is %lu bytes.\n", size);
size = sizeof i;
printf("Size is %lu bytes.\n", size);
size = sizeof (int);
printf("Size is %lu bytes.\n", size);
return 0;
}

From the style side, note that sizeof is an operator, not a function.

size = sizeof(int); /* Ugly as sin */

size = sizeof (int); /* Beauty */

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[Christopher Layne]

Joe Wright wrote:

From the style side, note that sizeof is an operator, not a function.

size = sizeof(int); */* Ugly as sin */

size = sizeof (int); /* Beauty */

Oh please. One is not more uglier than the other. It's a frickin' space for
christ's sake.

[Keith Thompson]

Joe Wright <jo********@comcast.netwrites:
[...]

<rant>
How come you need to crowd this valuable space with questions to which
you should already know the answer. Your C reference will tell you
what sizeof is all about and how you can use it.

If you want to know WHY it's that way, you're in the wrong
group. Maybe comp.std.c or something.
</rant>

The sizeof operator is a compiler primitive and not particularly
smart. Its default operand is the name of an object. Types may be more
complicated than simple names and so we give the compiler a clue with
parentheses that its argument is a (user defined?) type.

There is no "default operand" for the sizeof operator. If you write
"sizeof" with no operand it's a syntax error; the compiler won't fill
one in for you.

The operand of sizeof can be (nearly) any expression or a
parenthesized type name; specifically, the grammar is:

sizeof unary-expression
sizeof ( type-name )

with the following constraints:

The sizeof operator shall not be applied to an expression that has
function type or an incomplete type, to the parenthesized name of
such a type, or to an expression that designates a bit-field
member.

In particular, it needn't be the name of an object; "sizeof 42" is
legal, and yields the same result as "sizeof (int)".

[...]

From the style side, note that sizeof is an operator, not a function.

size = sizeof(int); /* Ugly as sin */

size = sizeof (int); /* Beauty */

I hadn't thought about this before, but I like it. In the past, I've
tended to write "sizeof(int)", but I agree that "sizeof (int)" is
better. It's not a function call, so it shouldn't look like one.
Thanks!

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Richard Heathfield]

Keith Thompson said:

Joe Wright <jo********@comcast.netwrites:

>>
From the style side, note that sizeof is an operator, not a function.

size = sizeof(int); /* Ugly as sin */

size = sizeof (int); /* Beauty */

I hadn't thought about this before, but I like it. In the past, I've
tended to write "sizeof(int)", but I agree that "sizeof (int)" is
better. It's not a function call, so it shouldn't look like one.

You kill me, Keith, you really do. I responded along precisely those lines.
Go get your /own/ set of reactions, you plagiarist!

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[CBFalconer]

Richard Heathfield wrote:

Keith Thompson said:

>Joe Wright <jo********@comcast.netwrites:

>>>
From the style side, note that sizeof is an operator, not a
function.

size = sizeof(int); /* Ugly as sin */

size = sizeof (int); /* Beauty */

I hadn't thought about this before, but I like it. In the past,
I've tended to write "sizeof(int)", but I agree that "sizeof (int)"
is better. It's not a function call, so it shouldn't look like one.

You kill me, Keith, you really do. I responded along precisely
those lines. Go get your /own/ set of reactions, you plagiarist!

Does this mean you've finally kicked the habit of writing if, for,
while etc. as if they were functions?

--
Some informative links:
<news:news.announce.newusers
<http://www.geocities.com/nnqweb/>
<http://www.catb.org/~esr/faqs/smart-questions.html>
<http://www.caliburn.nl/topposting.html>
<http://www.netmeister.org/news/learn2quote.html>
<http://cfaj.freeshell.org/google/>

[Richard Heathfield]

CBFalconer said:

Richard Heathfield wrote:

>Keith Thompson said:

>>Joe Wright <jo********@comcast.netwrites:

From the style side, note that sizeof is an operator, not a
function.

size = sizeof(int); /* Ugly as sin */

size = sizeof (int); /* Beauty */

I hadn't thought about this before, but I like it. In the past,
I've tended to write "sizeof(int)", but I agree that "sizeof (int)"
is better. It's not a function call, so it shouldn't look like one.

You kill me, Keith, you really do. I responded along precisely
those lines. Go get your /own/ set of reactions, you plagiarist!

Does this mean you've finally kicked the habit of writing if, for,
while etc. as if they were functions?

I'm a bit washed out at the moment. Flu, or something pretty close to it. So
I will quietly contemplate your question until I fall asleep. :-)

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[Richard Tobin]

In article <ln************@nuthaus.mib.org>,
Keith Thompson <ks***@mib.orgwrote:

>I hadn't thought about this before, but I like it. In the past, I've
tended to write "sizeof(int)", but I agree that "sizeof (int)" is
better. It's not a function call, so it shouldn't look like one.

I don't see the logic of your last sentence.

The difference between a unary operator and a single-argument function
is just a matter of syntax. The grammar for unary operator
application allows it to look like a function call, so why shouldn't
it?

"if" statements are not "while" statements, but can look the same
except for the keyword. Should we adopt some syntactic convention
to make them look different?

-- Richard

[Christopher Benson-Manica]

Christopher Layne <cl****@com.anodizedwrote:

size = sizeof(int); ?/* Ugly as sin */

size = sizeof (int); /* Beauty */

Oh please. One is not more uglier than the other. It's a frickin' space for
christ's sake.

#include <stdio.h>
int main(void){const char*s="Hello,world!\n";printf(s);return 0;}

No problem, right? Those missing things are just spaces.

--
C. Benson Manica | I *should* know what I'm talking about - if I
cbmanica(at)gmail.com | don't, I need to know. Flames welcome.

[jmcgill]

Christopher Benson-Manica wrote:

No problem, right? Those missing things are just spaces.

a+++b;

[Christopher Layne]

Christopher Benson-Manica wrote:

#include <stdio.h>
int main(void){const char*s="Hello,world!\n";printf(s);return 0;}

No problem, right? Those missing things are just spaces.

Yes. Let's expand it to extremes now. (rolls eyes)

[Keith Thompson]

ri*****@cogsci.ed.ac.uk (Richard Tobin) writes:

In article <ln************@nuthaus.mib.org>,
Keith Thompson <ks***@mib.orgwrote:

>>I hadn't thought about this before, but I like it. In the past, I've
tended to write "sizeof(int)", but I agree that "sizeof (int)" is
better. It's not a function call, so it shouldn't look like one.

I don't see the logic of your last sentence.

It's a matter of style, which means we will never resolve the issue.

The difference between a unary operator and a single-argument function
is just a matter of syntax. The grammar for unary operator
application allows it to look like a function call, so why shouldn't
it?

For the same reason that I prefer
return 42;
over
return(42);

I usually put spaces around operators. "sizeof" is just another
operator (even though it's the only one represented by a keyword
rather than by a delimiter), so why should it be any different?

On the other hand, I just realized that I usually *don't* put a space
after a unary operator (-x, &obj, *ptr), which weakens the argument a
bit.

"if" statements are not "while" statements, but can look the same
except for the keyword. Should we adopt some syntactic convention
to make them look different?

Absolutely. I suggest distinguishing between them by using different
keywords. 8-)}

There are several constructs in C that *can* look like function calls
at first glance, and I like to use layout tricks to make them look
different. I avoid extraneous parentheses on return statements, I
leave a space after "if" and "while", I use upper case for macros, and
so forth. Avoiding parentheses in "sizeof obj", and adding a space in
"sizeof (type)" are the same kind of thing.

Having said that, it's not a big deal. I have no problem reading
"sizeof(int)" rather than "sizeof (int)" in someone else's code
(because I *know* sizeof is an operator), but I'll probably start
using "sizeof (int)" in my own code (unless I forget).

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Ancient_Hacker]

Richard Tobin wrote:

The grammar for unary operator
application allows it to look like a function call, so why shouldn't
it?

Well sometimes visual consistency is misleading. You have to weight
the ease of reading versus hiding what's really happening. As you
probably know, there are drawbacks to having macro calls look just like
function calls-- one should be much more wary of macro calls than
fucntion calls, but their identical appeaqnce hides their differences.
Something similar might be happening with sizeof and return maskerading
as functions. This NG gets plenty of inquries about why sizeof can
take a type, when nothing else can. Mayhaps there would be less of
this kind of confusion if sizeof didnt look like a function call. Just
MHO.

[Richard Tobin]

In article <ln************@nuthaus.mib.org>,
Keith Thompson <ks***@mib.orgwrote:

>"if" statements are not "while" statements, but can look the same
except for the keyword. Should we adopt some syntactic convention
to make them look different?

>Absolutely. I suggest distinguishing between them by using different
keywords. 8-)}

Likewise, I suggest distinguishing between the sizeof operator and
functions by using the "sizeof" operator name :-)

-- Richard

[Dave Thompson]

On Tue, 03 Oct 2006 02:28:41 -0400, "T.M. Sommers" <tm*@nj.netwrote:

Walter Roberson wrote:

Did the use of @ as a rubout character (teletype) happen to proceed
the development of C?

It certainly wasn't used on regular teletypes. When using
5-level Baudot/Murray code, rubout was all marks, or
letters-shift. I think it was all marks when using 8-level code,
too, and I think the ASR-33 had a special rubout key, but I could
be wrong.

As already said, @ for line erase and # for character delete were used
in software for terminals including Teletypes, first in MULTICS and
then in Unix. Yes, 'rubout' in ASCII was 0x7F (0xFF in even parity)
and had a separate key for it on model 33 for certain and I believe
all other 8-level machines. Some computers (OSes) used rubout as
character delete (at least optionally) particularly DEC ones like
RT-11 and RSX-11*; but this was inconsistent with its use on plain
(e.g. cable) Teletype paper tape, where rubout was used to delete the
character overpunched not the preceding one.

- David.Thompson1 at worldnet.att.net