how does array[100] = {0} set the entire array to 0?

Question

How does the compiler fill values in char array[100] = {0};? What's the magic behind it?

I wanted to know how internally compiler initializes.

Thanks in advances. Looking more such sorts of tricks.

Answer 1

Implementation is up to compiler developers.

If your question is "what will happen with such declaration" - compiler will set first array element to the value you've provided (0) and all others will be set to zero because it is a default value for omitted array elements.

Answer 2

It's not magic.

The behavior of this code in C is described in section 6.7.8.21 of the C specification (online draft of C spec): for the elements that don't have a specified value, the compiler initializes pointers to NULL and arithmetic types to zero (and recursively applies this to aggregates).

The behavior of this code in C++ is described in section 8.5.1.7 of the C++ specification (online draft of C++ spec): the compiler default-initializes the elements that don't have a specified value.

Also, note that in C++ (but not C), you can use an empty initializer list, causing the compiler to default-initialize all of the elements of the array:

char array[100] = {};

As for what sort of code the compiler might generate when you do this, take a look at this question: Strange assembly from array 0-initialization

Answer 3

Also note that some compilers (Pelles C,...) will translate

char array[10000] = {0};

into 10000 zero's in your executable.

Answer 4

If your compiler is GCC you can also use following syntax:

int array[256] = {[0 ... 255] = 0};

Please look at

http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html#Designated-Inits

Answer 5

It depends where you put this initialisation.

If the array is static as in

char array[100] = {0};

int main(void)
{
...
}

then it is the compiler that reserves the 100 0 bytes in the data segement of the program. In this case you could have omitted the initialiser.

If your array is auto, then it is another story.

int foo(void)
{
char array[100] = {0};
...
}

In this case at every call of the function foo you will have a hidden memset.

The code above is equivalent to

int foo(void)
{ 
char array[100];

memset(100, 0, sizeof array);
....
}

and if you omit the initialiser your array will contain random data (the data of the stack).

If your local array is declared static like in

int foo(void)
{ 
static char array[100] = {0};
...
}

then it is technically the same case as the first one.

Answer 6

Note that if it's global or static it will (probably) be in the .bss segment

Answer 7

Please see http://stackoverflow.com/questions/453432/difference-in-initalizing-and-zeroing-an-array-in-c-c/455137#455137 and http://stackoverflow.com/questions/531477/strange-assembly-from-array-0-initialization