sizeof operator

[JS]

I read in K&R page 204 that sizeof use on a char returns 1. But when I write
the following I get 4!

int main(void){
printf("%d\n",s izeof('g'));

}

Was it not supposed to return 1?

[Nils Weller]

In article <3a************ *@individual.ne t>, Nils Weller wrote:

In article <87************ @benpfaff.org>, Ben Pfaff wrote:

Nils Weller <[e-mail] > writes:

Because character constants were designed to be capable of carrying more
more than one character (and it follows, obviously, that a ``char'' is
not enough to carry more than one character - hence the need for a
larger data type.)

Okay--so, then, *why* were character constants designed to be
capable of carrying more than one character?

That I don't know. I'd guess that it was intended to automize bit
shifting for you. The value of a multi-char character constant is now
implementation-defined, but historically you really got all chars you
asked for:

'foo'

would turn into

'f' << (CHAR_BIT * 2) | 'o' << CHAR_BIT | 'o'

This may seem more plausible for values written in hexadecimal notation:

'\xff\x12'

would turn into

0xff << CHAR_BIT | 0x12

Actually it makes a lot more sense for values written in octal notation
since 0xff << CHAR_BIT | 0x12 can be represented as a simple 0xff12 as
well.
--
My real email address is ``nils<at>gnuli nux<dot>nl''

[Emmanuel Delahaye]

JS wrote on 23/03/05 :

I read in K&R page 204 that sizeof use on a char returns 1. But when I write
Correct.
the following I get 4!

int main(void){
printf("%d\n",s izeof('g'));

}

Was it not supposed to return 1?

No, because a character literal is not a char. It fits into a char. Big
difference.

Actually, a character literal is an int.

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

"Mal nommer les choses c'est ajouter du malheur au
monde." -- Albert Camus.

[Emmanuel Delahaye]

Mark Odell wrote on 23/03/05 :

char c;
printf("%d\n", (int)sizeof c);

Don't you mean:
printf("%u\n", sizeof c);

return 0;
}

Assuming <stdio.h> was included, the first version was correct. Yours
is not, because a size_t could be an unsigned long. You want :

printf("%u\n", (unsigned) sizeof c);

or (C99)

printf("%zu\n", sizeof c);

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

"C is a sharp tool"

[Emmanuel Delahaye]

Steven K. Mariner wrote on 23/03/05 :

char p[]="ABCDEFGHIJKLM NOPQRSTUVWXY*Za bcdefghijklmnop qrstuvwxyz.
\n",*q="kl BIcNBFr.NKEzjwC IxNJC";

Put that on a single line, and cut at the comma...

char p[]="ABCDEFGHIJKLM NOPQRSTUVWXY*Za bcdefghijklmnop qrstuvwxyz.\n"
,*q="kl BIcNBFr.NKEzjwC IxNJC";

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

"C is a sharp tool"

[Michael Mair]

Martin Ambuhl wrote:

Mark Odell wrote:

Alex Fraser wrote:

No, a character in single quotes, as in 'g', is a constant of type
signed
int in C (I think this is different in C++).

Try:

int main(void) {
char c;
printf("%d\n", (int)sizeof c);

Don't you mean:
printf("%u\n", sizeof c);

No, since there is no reason to think that a size_t is an unsigned int.
The "correct" specifier for an uncast size_t might be "%lu" or "%llu".

Addendum:
In C99, we have "%zu" specifically for size_t.
No more guesswork :-)
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Keith Thompson]

Nils Weller <[e-mail] > writes:

In article <d1**********@c hessie.cirr.com >, Christopher Benson-Manica wrote:

Ben Pfaff <bl*@cs.stanfor d.edu> spoke thus:

In C, character constants have type `int', so sizeof 'g' is equal
to sizeof(int).

(semi OT) Why did the authors of the standard make this arguably
non-intuitive stipulation?

Because you may be able to put more than one character into character
constants (but the actual number that fits into it is implementation-
defined any may be 1.)

putchar('foo');

[...]

I don't think that's the reason.

In C, especially in older versions such as K&R C, there are few if any
expressions of integer types shorter than int. Evaluating an object
of type char or short almost always causes an implicit conversion to
int. (I might be wrong about the "almost".) Making character
constants have type char would actually make things more complicated.

For example:

char c;
c = 'g';

If 'g' were of type char, the value would be implicitly converted to
type int before being converted back to type char and assigned to c.
With 'g' being of type int, there's only one implicit conversion, not
two. (Of course the compiler is likely to optimize the whole thing to
a single "store byte" instruction, if such an instruction exists.)

The only case I can think of where this visibly matters is applying
the sizeof operator to a character constant, something that is rarely
useful.

<OT>
In C++, character constants are of type char; this is because of some
considerations involving overloading and/or templates, which don't
apply in C.
</OT>

Incidentally, the OP's question could have been answered by citing
question 8.9 in the C FAQ.

--
Keith Thompson (The_Other_Keit h) 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.

[James McIninch]

<posted & mailed>

sizeof() returns the storage size of the argument specified. Since 'g' is an
integer constant, you get sizeof(int). On your platform... that's 4.

JS wrote:

I read in K&R page 204 that sizeof use on a char returns 1. But when I
write the following I get 4!

int main(void){
printf("%d\n",s izeof('g'));

}

Was it not supposed to return 1?

--
Remove '.nospam' from e-mail address to reply by e-mail

[Jack Klein]

On Wed, 23 Mar 2005 18:08:25 +0000 (UTC), Christopher Benson-Manica
<at***@nospam.c yberspace.org> wrote in comp.lang.c:

Ben Pfaff <bl*@cs.stanfor d.edu> spoke thus:

In C, character constants have type `int', so sizeof 'g' is equal
to sizeof(int).

(semi OT) Why did the authors of the standard make this arguably
non-intuitive stipulation?

Let's just assume ASCII for a moment, to simplify:

char c1 = 65;
char c2 = 'A';
What is the type of the initializer for c1? What is the type of the
initializer for c2? Why should they not be the same type? Either can
fit in a char.

....or even more succinctly:

char c1 = 0;
char c2 = '\0';

Note that all constant expressions of integral type are of type int or
higher rank. The rules for character literals are no different than
those for other integer literals. Unsuffixed integer literals that
have representable in an int are of type int, not of the smallest type
that can hold the value.

Consider that the only differences between 'A', 65, 0x41, and 081
exist syntactically in the way they are parsed at run time. They are
all one and exactly the same thing at run time, integer literals of
type int.

This is all very consistent with C's basic philosophy that there is
nothing special about characters, they are just integer types holding
numbers. As opposed to languages where one has to use special
functions (CHR$ and ASC come to mind from old interpreted BASIC
dialects) to handle the conversion between characters and their
numeric values.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Michael Mair]

Jack Klein wrote:

On Wed, 23 Mar 2005 18:08:25 +0000 (UTC), Christopher Benson-Manica
<at***@nospam.c yberspace.org> wrote in comp.lang.c:

Ben Pfaff <bl*@cs.stanfor d.edu> spoke thus:

In C, character constants have type `int', so sizeof 'g' is equal
to sizeof(int).
(semi OT) Why did the authors of the standard make this arguably
non-intuitive stipulation?

Let's just assume ASCII for a moment, to simplify:

char c1 = 65;
char c2 = 'A';
What is the type of the initializer for c1? What is the type of the
initializer for c2? Why should they not be the same type? Either can
fit in a char.

...or even more succinctly:

char c1 = 0;
char c2 = '\0';

Note that all constant expressions of integral type are of type int or
higher rank. The rules for character literals are no different than
those for other integer literals. Unsuffixed integer literals that
have representable in an int are of type int, not of the smallest type
that can hold the value.

Consider that the only differences between 'A', 65, 0x41, and 081
exist syntactically in the way they are parsed at run time. They are

ITYM: compile time (here, as opposed to run time below).
all one and exactly the same thing at run time, integer literals of
type int.

This is all very consistent with C's basic philosophy that there is
nothing special about characters, they are just integer types holding
numbers. As opposed to languages where one has to use special
functions (CHR$ and ASC come to mind from old interpreted BASIC
dialects) to handle the conversion between characters and their
numeric values.

--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Christopher Benson-Manica]

Jack Klein <ja*******@spam cop.net> spoke thus:

...or even more succinctly: char c1 = 0;
char c2 = '\0';

That was, indeed, very succinct. Thanks for a highly enlightening
article :)

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.