Question about C array initialization

Question

I understand that the statement
char string[] = "chars";
initializes string[5] to 0 ('\000'). My question is does the statement
char *strings[] = { "string1", "string2", "string3" };
initialize strings[3] to (void *) 0, i.e. NULL? I can't find the answer to this question in the ansi standard. GCC seems to tack on a NULL pointer at the end (even with the -ansi and -pedantic-errors flags), which is really convenient for finding the boundary, but I'm not sure whether it's a GCC thing or an official C thing. I see where the standard talks about terminating char arrays initialized by a string literal with a null byte, but it doesn't talk about the analogous case with arrays of pointers.
Last edited by nbtrap (2012-06-25 03:18:20)

Answer 1

nbtrap wrote:
Not necessarily. A declaration like:
char arr[3] = "str";
doesn't get null-terminated.
It doesn't get null-terminated because you don't leave enough room in the array for the null character. "char arr[3]" can only contain 3 characters, the same way that "char arr[2] = "str" will only contain 2. The second example generates a warning whereas the first does not, but only because it is very common to work with non-null-terminated strings.
nbtrap wrote:
And besides, my point is that initializing strings[3] *would* make sense for the same reason that intializing
char foo[] = "bar";
with a terminating null byte *does* make sense.
I know that arrays of pointers are not the same. My questions assumes that much. The fact of the matter is, however, GCC terminates pointer arrays of unknown size with a null pointer, and my question is simply "is this an ansi C thing or a GCC thing?".
In fact, it seems that GCC terminates all arrays of unknown size that are explicitly initialized with the appropriate number of null bytes. For example:
struct tag { int i; char c; char *str; } tags[] = {
{ 1, 'a', "string1" },
{ 2, 'b', "string2" },
{ 3, 'c', "string3" }
initializes tags[3] to sizeof (struct tag) null bytes. Try it for yourself.
I get the following:
test.c
#include <stdio.h>
int
main(int argc, char * * argv)
int i;
char *strings[] = { "string1", NULL, "string3"};
for (i=0;i<5;i++)
printf("strings[%d]: %s\n", i, strings[i]);
return 0;
output
strings[0]: string1
strings[1]: (null)
strings[2]: string3
Segmentation fault
test2.c
#include <stdio.h>
#include <string.h>
int
main(int argc, char * * argv)
int i;
struct tag {int i; char c; char *str;};
struct tag null;
memset(&null, 0, sizeof(struct tag));
struct tag tags[] =
{ 1, 'a', "string1" },
// { 2, 'b', "string2" },
null,
{ 3, 'c', "string3" }
for (i=0;i<5;i++)
printf(
"tags[%d]: (%p) %1d %c %s\n",
i, tags + i, tags[i].i, tags[i].c, tags[i].str
return 0;
output
tags[0]: (0x7fffd2df4e80) 1 a string1
tags[1]: (0x7fffd2df4e90) 0 (null)
tags[2]: (0x7fffd2df4ea0) 3 c string3
tags[3]: (0x7fffd2df4eb0) 0 (null)
Segmentation fault
The above behavior appears to conflict.
Given that string constants in C are defined as null-terminated, i.e. "str" is equivalent to "{'s', 't', 'r', '\0'}", the assignment 'arr[] = "str"' explicitly includes a null terminator. The other examples above do not include such a terminator. Even if it would be convenient sometimes, the standard should adopt a minimally invasive approach. It's easy to add a NULL at the end of an array declaration, but impossible to remove an extra element from such a declaration.
This may be informative too:
test3.c
#include <stdio.h>
#include <string.h>
int
main(int argc, char * * argv)
char str[] = "test";
char *strings[] = {"string1", NULL, "string3"};
struct tag {int i; char c; char *str;};
struct tag null;
memset(&null, 0, sizeof(struct tag));
struct tag tags[] =
{ 1, 'a', "string1" },
// { 2, 'b', "string2" },
null,
{ 3, 'c', "string3" }
printf(
"str\n size: %lu\n length: %lu\n"
"strings\n size: %lu\n length: %lu\n"
"tags\n size: %lu\n length: %lu\n",
sizeof(str), sizeof(str)/sizeof(char),
sizeof(strings), sizeof(strings)/sizeof(char *),
sizeof(tags), sizeof(tags)/sizeof(struct tag)
return 0;
output
str
size: 5
length: 5
strings
size: 24
length: 3
tags
size: 48
length: 3
The string length (actual number of chars in array) is reported as 5 ('t', 'e', 's', 't', '\0'), which is expected. The array of strings and tags are both reported as 3, even though you can access a null value after the last initialized index of the tags array. If that null value was really supposed to be there, it should be accounted for using sizeof, just as the null character is in the string.
Maybe the ultimate null element of the tags array is some artefact of memory alignment.