sizeof( <string literal> )

[Don Starr]

When applied to a string literal, is the sizeof operator supposed to return the size of the string
(including nul), or the size of a pointer?

For example, assuming a char is 1 byte and a char * is 4 bytes, should the following yield 4, 5, of
something else? (And, if something else, what determines the result?)

char x[] = "abcd";
printf( "%d\n", sizeof( x ) );

-Don

[Artie Gold]

Don Starr wrote:

When applied to a string literal, is the sizeof operator supposed to return the size of the string
(including nul), or the size of a pointer?
Smells like homework.

For example, assuming a char is 1 byte and a char * is 4 bytes, should the following yield 4, 5, of
something else? (And, if something else, what determines the result?)
Yup. Really smells like homework.

char x[] = "abcd";
printf( "%d\n", sizeof( x ) );

Well, what do you think?
[hint: you're not taking the `sizeof' of a string literal here, but,
rather, an array of `char']

HTH,
--ag

--
Artie Gold -- Austin, Texas

[Eric Sosman]

Don Starr wrote:

When applied to a string literal, is the sizeof operator supposed to return the size of the string
(including nul), or the size of a pointer?

For example, assuming a char is 1 byte and a char * is 4 bytes, should the following yield 4, 5, of
something else? (And, if something else, what determines the result?)

char x[] = "abcd";
printf( "%d\n", sizeof( x ) );

You'll get 5. (Actually you might get undefined behavior
because the `sizeof' operator yields a result of type `size_t',
and "%d" isn't necessarily the right format specifier. I've
used machines on which the above would print 0!)

Why 5? Because a string literal generates an array of
characters. When you apply the `sizeof' operator to an array
(any array), you get the number of bytes in the array. This
is one of the very few cases where an array reference does
*not* turn into a pointer to the zero'th element; the `sizeof'
operator applies to the array as a whole.

See also Questions 6.4 and 6.8 -- in fact, read all of
Section 6 -- in the comp.lang.c Frequently Asked Questions
(FAQ) list

http://www.eskimo.com/~scs/C-faq/top.html

--
Er*********@sun .com

[Ben Pfaff]

Don Starr <no****@nospam. net> writes:

When applied to a string literal, is the sizeof operator
supposed to return the size of the string (including nul), or
the size of a pointer?
The sizeof operator yields the size of its operand's type. If
its operand has a pointer type, then it yields the size of the
pointer type. If its operand has an array type, then it yields
the number of bytes in the array. There is no special case for a
string.
For example, assuming a char is 1 byte
A char is always 1 byte.
and a char * is 4 bytes, should the following yield 4, 5, of
something else? (And, if something else, what determines the
result?)

char x[] = "abcd";
printf( "%d\n", sizeof( x ) );

You need to cast the result of sizeof to int here, because sizeof
yields a result of type size_t, which is an unsigned type.

With that correction, this will always print 5, because the array
has five elements of type char.
--
int main(void){char p[]="ABCDEFGHIJKLM NOPQRSTUVWXYZab cdefghijklmnopq rstuvwxyz.\
\n",*q="kl BIcNBFr.NKEzjwC IxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+= strchr(p,*q++)-p;if(i>=(int)si zeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[Artie Gold]

Don Starr wrote:

On Tue, 29 Jul 2003 20:43:11 GMT, Artie Gold <ar*******@aust in.rr.com> wrote:

Don Starr wrote:

When applied to a string literal, is the sizeof operator supposed to return the size of the string
(including nul), or the size of a pointer?
Smells like homework.

No, not homework. Haven't had any of that for about 17 years. It's an attempt to settle a dispute
regarding the output of one compiler vs. several others.

My mistake. No offense meant. ;-)

Well, what do you think?
[hint: you're not taking the `sizeof' of a string literal here, but,
rather, an array of `char']

*I* think 5, and so do all (3) of the compilers I've tried.

Then we're all in agreement!

--ag

--
Artie Gold -- Austin, Texas

[Don Starr]

On Tue, 29 Jul 2003 20:28:19 GMT, Don Starr <no****@nospam. net> wrote:

char x[] = "abcd";
printf( "%d\n", sizeof( x ) );

After reading the various responses, I realize that I goofed in my example. _Of course_ I'm asking
for the size of an array of char.

I should have posted originally:
#define _x "abcd"
size_t y = sizeof( _x );

I then should've asked about the resulting value of <y>.

I presume that the answer is still 5, as the string literal is treated here as a nul-terminated
array of char?

-Don

[Simon Biber]

"Don Starr" <no****@nospam. net> wrote:

I presume that the answer is still 5, as the string
literal is treated here as a nul-terminated array of
char?

Yes. A string literal is defined as a null-terminated,
non-modifyable but non-const array of char.

--
Simon.

[madhukar_bm]

Eric Sosman <Er*********@su n.com> wrote in message news:<3F******* ********@sun.co m>...

Don Starr wrote:
This is one of the very few cases where an array reference does
*not* turn into a pointer to the zero'th element; the `sizeof'
operator applies to the array as a whole.

Can you please let me know the other cases where the array reference
does not turn into a pointer

[Dan Pop]

In <3f************ **********@news .optusnet.com.a u> "Simon Biber" <sb****@optusho me.com.au> writes:

"Don Starr" <no****@nospam. net> wrote:

I presume that the answer is still 5, as the string
literal is treated here as a nul-terminated array of
char?

Yes. A string literal is defined as a null-terminated,
non-modifyable but non-const array of char.

Nope, it ain't. A string literal is a purely syntactical construct. The
way it is translated depends on the context where it is used. Compare:

char a[] = "abcd";
char b[4] = "abcd";

The same string literal initialises a and b differently. Furthermore,
there is nothing preventing these arrays from being declared as arrays of
const char.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Dan Pop]

In <a8************ **************@ posting.google. com> ma********@yaho o.com (madhukar_bm) writes:

Eric Sosman <Er*********@su n.com> wrote in message news:<3F******* ********@sun.co m>...

Don Starr wrote:

This is one of the very few cases where an array reference does
*not* turn into a pointer to the zero'th element; the `sizeof'
operator applies to the array as a whole.

Can you please let me know the other cases where the array reference
does not turn into a pointer

Except when it is the operand of the sizeof operator or the unary &
operator, or is a character string literal used to initialize an array
of character type, or is a wide string literal used to initialize an
array with element type compatible with wchar_t, an lvalue that has
type ``array of type '' is converted to an expression that has type
``pointer to type '' that points to the initial member of the array
object and is not an lvalue.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de