结构零初始化方法

Question

Is

struct datainfo info = { 0 };

the same as

struct datainfo info;
memset(&info, 0, sizeof(info));

What's the difference and which is better ?

Answer 1

The first one is the best way by a country mile, as it guarantees that the struct members are initialised as they would be for static storage. It's also clearer.

There's no guarantee from a standards perspective that the two ways are equivalent, although a specific compiler may well optimise the first to the second, even if it ends up clobbering parts of memory discarded as padding .

(Note that in C++, the behaviour of the second way could well be undefined . Yes C is not C++ but a fair bit of C code does tend to end up being ported to C++.)

Answer 2

Practically, those two methods are very likely to produce the same result. Probably on account of first being compiled into a call to memset itself on today's common platforms.

From a language lawyer perspective, the first method will zero-initialize all the members of the of the structure, but there is nothing specified about the values any padding bytes may take (in the individual members, or the structure). While the the second method will zero out all the bytes. And to be even more precise, there is no guarantee that an all byte zero pattern is even an object's "zero" value.

Since (if one knows their target platform) the two are pretty much equivalent in every way that counts for the programmer, you choose the one that best suits your preferences.

Personally, I favor the initialization over the call to memset . Because it happens at the point of declaration, and not in another statement, not to mention the portability aspect. That makes it impossible to accidentally add code in between that makes the initialization not run (however unlikely that may be), or be faulty somehow. But some may say that memset is clearer, even to a programmer reading it later that is not aware of how {0} works. I can't entirely disregard their argument either.

Answer 3

As noted by others, the code is functionality equivalent. Using the x86-64 gcc 8.3 compiler

The code:

#include <string.h>
main()
{
    struct datainfo { int i; };
    struct datainfo info;

    memset(&info, 0, sizeof(info));
}

produces the assembly:

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-4]
        mov     edx, 4
        mov     esi, 0
        mov     rdi, rax
        call    memset
        mov     eax, 0
        leave
        ret

while the code:

main()
{
    struct datainfo { int i; };
    struct datainfo info = {0};
}

compiles to:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 0
        mov     eax, 0
        pop     rbp
        ret     

To my untrained eye, the two outputs are 11 instructions vs 6 instructions, so at least space is more efficient in the second implementation. But as noted by others, the zero initialization method is much more explicit in its intent.