C/C++: How does int array[10]={0} work?

Question

I am wondering how does int array[10]={0} really work?

Does it go all the way through the entire array like this?

for(int i=0;i<10;i++) array[i]=0;

Or is it more efficient?

`Or is it more efficient?` That may depend on the compiler or even the CPU. — drescherjm, Sep 15 '17 at 13:22
Fully depends on a compiler. On the one I am using it is calling some internal `memclr` function, which is built around `memset`. — Eugene Sh., Sep 15 '17 at 13:22
Some compilers could just place initialized data into object code. So there will be no initializing code at all. — KonstantinL, Sep 15 '17 at 13:24
@KonstantinL It is impossible if it has an automatic storage class. — Eugene Sh., Sep 15 '17 at 13:24
Try https://godbolt.org/ to see the asm code for different compilers / CPUs. — drescherjm, Sep 15 '17 at 13:24
While everyone is right that this is compiler-dependent, I think the more important point is that as long as you're using a sane compiler it's probably going to be as efficient as possible (or very close to it). You would be insane to try to optimize this yourself if your compiler supports this syntax. — Max, Sep 15 '17 at 13:26
Reopend the question is the OP is not asking if `int array[10]={0}` makes all the elements 0 but how that process is actually implemented and how efficient it is. — NathanOliver, Sep 15 '17 at 13:37
This question had 5(!) heavily downvoted answers (4 of which are deleted now). Kinda abnormal, given the question is pretty simple to answer and the full answer can be easily derived from the comments. — Eugene Sh., Sep 15 '17 at 13:38

score 2 · Accepted Answer · answered Sep 15 '17 at 13:50

Depends on the scope of your variable.

Global scope - array will be placed in the .bss segment and zeroed before call to the main function. Is it faster? It is definitely different as zeroing takes place before the main start
Local scope - the {0} initialisation will be IMO faster as those internal routines are well optimised for the particular hardware. I have tested with gcc & VS and it is quicker - but of course there is no guarantee that your compiler will do it the same way. https://godbolt.org/g/JdTPHJ

score 2 · Answer 2 · answered Sep 15 '17 at 14:58

2

Using {0} is one of the most misleading things in C++.

int array[10]={n1, n2, n3};

This will fill the first three elements with the values in {}. The rest of the array will be initialized with the default value - 0 for int.

int array[10]={1}; // [1, 0, 0, 0...]

It's better to use

int array[10]={}; // [0, 0, 0, 0...]

answered Sep 15 '17 at 14:58

Sergei

3

How is this even answering the question? And empty initializer is not allowed in C https://stackoverflow.com/questions/17589533/is-an-empty-initializer-list-valid-c-code. How the heck it is receiving upvotes? – Eugene Sh. Sep 15 '17 at 16:40
@Eugene a good answer doesn't have to answer the question as long as it adds clarity. There is a wrong assumption in the question which I cleared up. – Sergei Sep 16 '17 at 22:09

2 Answers2