initial value of int array in C

Question

When declaring an array in C like this:

int array[10];

What is the initial value of the integers?? I'm getting different results with different compilers and I want to know if it has something to do with the compiler, or the OS.

Answer 1

If the array is declared in a function, then the value is undefined. int x[10]; in a function means: take the ownership of 10-int-size area of memroy without doing any initialization. If the array is declared as a global one or as static in a function, then all elements are initialized to zero if they aren't initialized already.

Answer 2

A C variable declaration just tells the compiler to set aside and name an area of memory for you. The values in that memory are not changed from what they were.

Some compilers in unoptimized debug mode set values to zero. However, it has become more common to set the values to a known bad value so that the programmer does not unknowingly write code that depends on a zero being set.

In order to ask the compiler to set an array to zero for you, you can write it as:

int array[10] = {0};

Better yet is to set the array with the values it should have. That is more efficient and avoids writing into the array twice.

Answer 3

According to the C standard, 6.7.8 (note 10):

If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate.

So it depends on the compiler. With MSVC, debug builds will initialize automatic variables with 0xcc, whereas non-debug builds will not initialize those variables at all.

Answer 4

Text from http://www.cplusplus.com/doc/tutorial/arrays/

SUMMARY:

Initializing arrays. When declaring a regular array of local scope (within a function, for example), if we do not specify otherwise, its elements will not be initialized to any value by default, so their content will be undetermined until we store some value in them. The elements of global and static arrays, on the other hand, are automatically initialized with their default values, which for all fundamental types this means they are filled with zeros.

In both cases, local and global, when we declare an array, we have the possibility to assign initial values to each one of its elements by enclosing the values in braces { }. For example:

int billy [5] = { 16, 2, 77, 40, 12071 };

Answer 5

and why is it that way?

Why are function locals (auto storage class) not initialized when everything else is?

C is close to the hardware, that's its greatest strength & it's biggest danger. The reason auto storage class objects have random initial values is because they are allocated on the stack, and a design decision was made not to automatically clear these, partly because they would need to be cleared on every function call.

OTOH, the non-auto objects only have to be cleared once. Plus, the OS has to clear allocated pages for security reasons anyway. So the design decision here was to specify zero initialization. Why isn't security an issue with the stack, too? Actually it is cleared, at first. The junk you see is from earlier instances of your own program's call frames and the library code they called.

The end result is fast, memory-efficient code. All the advantages of assembly with none of the pain. Before dmr invented C, "HLL"s like Basic and entire OS kernels were really, literally, implemented as giant assembler programs. (With certain exceptions at places like IBM.)

Answer 6

As set by the standard, all global and function static variables automatically initialised to 0. Automatic variables are not initialised.

int a[10];  // global - all elements are initialised to 0

void foo(void) {
    int b[10];    // automatic storage - contain junk
    static int c[10]; // static - initialised to 0
}

However it is a good practice to always manually initialise function variable, regardless of its storage class. To set all array elements to 0 you just need to assign first array item to 0 - omitted elements will set to 0 automatically:

int b[10] = {0};

Answer 7

In most latest compilers(eg. gcc/vc++), partially initialized local array/structure members are default initialized to zero(int), NULL(char/char string), 0.000000(float/double).

Apart from local array/structure data as above, static(global/local) and global space members are also maintain the same property.

int a[5] = {0,1,2};
printf("%d %d %d\n",*a, *(a+2), *(a+4));

struct s1
{
int i1;
int i2;
int i3;
char c;
char str[5];
};

struct s1 s11 = {1};
    printf("%d %d %d %c %s\n",s11.i1,s11.i2, s11.i3, s11.c, s11.str);
    if(!s11.c)
        printf("s11.c is null\n");
    if(!*(s11.str))
        printf("s11.str is null\n");

In gcc/vc++, output should be:

0 2 0 1 0 0 0.000000 s11.c is null s11.str is null