I am trying to find documentation either confirming or contradicting the statement that
char test[5]="";
results in a buffer initialized to all null characters identical to
memset(test,'\0',sizeof(test));
but have not been able to find (or understand / decipher) anything. I am specifically looking for details in the old specification, C99 reference will work too. Thank you
This is not a complete answer to your question but serves to clear up misinformation in other answers.
In ANSI C89 the relevant Standard text was (section 3.5.7):
If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate.
An array of character type may be initialized by a character string literal, optionally enclosed in braces. Successive characters of the character string literal (including the terminating null character if there is room or if the array is of unknown size) initialize the members of the array.
It only specifies the initialization for array elements corresponding to the string literal. So the trailing array elements are not explicitly initialized and thus have indeterminate value.
There was also a paragraph:
If there are fewer initializers in a list than there are members of an aggregate, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
but that does not apply since we are not initializing from a list ("list" means a brace-enclosed list, not a string literal).
In C90 (which I'm not sure if I can legally link to), the sections were renumbered so that the section containing these paragraphs became 6.5.7. The wording of the latter paragraph was also changed:
If there are fewer initializers in a brace-enclosed list than there are members of an aggregate, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
In C90 TC1 (HTML, PDF), the above is unaltered.
However, in Defect Report 60, the crucial question was asked:
When an array of char (or wchar_t) is initialized with a string literal that contains fewer characters than the array, are the remaining elements of the array initialized?
Subclause 6.5.7 Initialization, page 72, only says (emphasis mine):
If there are fewer initializers in a brace-enclosed list than there are members of an aggregate, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
Correction
In subclause 6.5.7, page 72, the penultimate paragraph of Semantics (before Examples), add after the comma:
or fewer characters in a string literal or wide string literal used to initialize an array of known size, and elements of character or wchar_t type
It appears that the zero initialisation in the suggested fix must indeed have been the standard-writers intention, since in C90 TC2, we see that same crucial change made:
Page 72
In subclause 6.5.7, page 72, the penultimate paragraph of Semantics (before Examples), add after the comma:
or fewer characters in a string literal or wide string literal used to initialize an array of known size, and elements of character or wchar_t type
giving us:
If there are fewer initializers in a brace-enclosed list than there are members of an aggregate, or fewer characters in a string literal or wide string literal used to initialize an array of known size, and elements of character or wchar_t type the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
Note that TC1 is dated 1994, although it was published in 1995. TC2 is dated 1996. Perplexingly, DR60 is dated July 16 1993, and hence predates TC1. Perhaps work on TC1 was at too advanced a stage by that point to deal with new defect reports and a backlog had accumulated? In any case, TC2 was mostly just a set of corrections in response to defect reports, suggesting that the change was first seen there and not in C95, and that the zero-initialisation of characters after the null terminator was what the C89 standard writers had intended.
In ISO C99 (the original version, without the technical corrigenda), that paragraph was now renumbered to 6.7.8/21 and had changed again. The mentions of "wide string literal" and "elements of character or wchar_t type" were removed:
If there are fewer initializers in a brace-enclosed list than there are elements or members of an aggregate, or fewer characters in a string literal used to initialize an array of known size than there are elements in the array, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
Meaning the trailing array elements are initialized to null bytes .
(Note: The original C99 may be copyrighted material, so I can't post a link to it in the above. That is what it says, though. Here is a link to the last freely available working draft. There were two more drafts after that, but the WG14 website has taken them down. Nevertheless, that wording is in the N843 working draft, and is still present in the later C99 incorporating TC3.)
I have been unable to find any free copies of C95 (ISO/IEC 9899:1990/AMD1:1995). So I cannot answer as to exactly which point between C89 and C99 the "wide string literal" and "wchar_t" changes were made. Also, the subject is not mentioned in the C99 Rationale document.
Of course it is possible that the C99 behaviour was the intent of the C89 authors and the missing text was an oversight, but in the absence of any sort of documentation to that effect we can't draw any conclusion, and there may be compilers from that time that do not initialize the trailing elements.
Hopefully someone else out there who has those documents (or feels inclined to buy them from the ISO store!) can provide an accurate answer.
C99 and later guarantees that the remaining characters are initialized to zero. C89/C90/C95 does not make this guarantee and does not specify the values of the remaining characters. This was likely an unintentional oversight, and I speculate that most or all pre-C99 compilers would have zero-initialized the remaining characters anyway. If you're using a conforming C99 or later compiler, zero-initialization is guaranteed.
char test[5]="";
Due to a defect in the C89/C90 standard, this was only guaranteed to initialize test[0] to '\0'. The other elements of test were left unspecified.
The C95 amendment did not address this.
The C99 standard corrected the defect, requiring test to be initialized to all zeros.
Another example:
char foo[5] = "foo";
In C89/C90,C95, the language guaranteed foo[0]=='f', foo[1]=='o', foo[2]=='o', foo[3]=='\0', but said nothing about the value of foo[4]. In C99 and later, it's guaranteed to be initialized as if you had written:
char foo[5] = { 'f', 'o', 'o', '\0' };
which, in all editions of the C standard, guarantees foo[4]=='\0'.
The 1989 ANSI C standard and the 1990 ISO C standard are equivalent, differing only in non-normative introductory material and a renumbering of sections. The 1995 amendment updated the standard but did not affect array initialization.
The 1990 ISO C standard, section 6.5.7, says:
An array of character type may be initialized by a character string literal, optionally enclosed in braces. Successive characters of the character string literal (including the terminating null character if there is room or if the array is of unknown size) initialize the elements of the array.
and later in the same section:
If there are fewer initializers in a brace-enclosed list than there are members of an aggregate, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
It specified that trailing members are initialized to zero for a brace-enclosed list, but does not make the same statement for a string literal initializer. (I speculate that this was an unintentional oversight, and that most compilers would have zero-filled the remaining elements anyway since they already had to do so in some cases.)
Each edition of the C standard has a collection of defect reports associated with it:
C90 Defect Report #060, submitted in 1993 by P.J. Plauger and/or Larry Jones, raised this issue:
When an array of
char(orwchar_t) is initialized with a string literal that contains fewer characters than the array, are the remaining elements of the array initialized?
Subclause 6.5.7 Initialization, page 72, only says (emphasis mine):If there are fewer initializers in a brace-enclosed list than there are members of an aggregate, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
The response to this defect report resulted in the revised wording in the C99 standard, section 6.7.8 paragraph 21 (emphasis added):
If there are fewer initializers in a brace-enclosed list than there are elements or members of an aggregate, or fewer characters in a string literal used to initialize an array of known size than there are elements in the array, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
From the C Standard (6.7.9 Initialization)
10 If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate. If an object that has static or thread storage duration is not initialized explicitly, then:
— if it has pointer type, it is initialized to a null pointer;
— if it has arithmetic type, it is initialized to (positive or unsigned) zero;
...
and
21 If there are fewer initializers in a brace-enclosed list than there are elements or members of an aggregate, or fewer characters in a string literal used to initialize an array of known size than there are elements in the array, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
This means that in this declaration
char test[5] = "";
all five elements of the array are zero initialized. The first element is initialized explicitly by the terminating zero of the string literal and all other are initialized implicitly the same way as objects with the static storage duration.
At least it is valid starting from the C99 Standard.
Below there is a demonstrative program that shows different ways of initialization of character arrays with zeroes.
#include <stdio.h>
int main(void)
{
enum { N = 5 };
char s1[N] = "";
char s2[N] = { "" };
char s3[N] = { 0 };
char s4[N] = { [0] = 0 };
char s5[N] = { [N-1] = 0 };
char * s[] = { s1, s2, s3, s4, s5 };
for ( size_t i = 0; i < sizeof( s ) / sizeof( *s ); i++ )
{
for ( size_t j = 0; j < N; j++ )
{
printf( "%d", s[i][j] );
}
putchar( '\n' );
}
return 0;
}
The program output is
00000
00000
00000
00000
00000
From a code clarity point of view, if the purpose of the array is to hold strings, then
char test[5] = "";
initializes the array with a zero-length string, and the rest of the bytes shouldn't matter. If they do matter, then the array isn't really a string, and you should use
char test[5] = {0};
to clarify that.
