Initializing a struct to 0

c struct initialization

If I have a struct like this:

typedef struct
{
    unsigned char c1;
    unsigned char c2;
} myStruct;

What would be the easiest way to initialize this struct to 0? Would the following suffice?

myStruct _m1 = {0};

or Would I need to explicitly init each member to 0?

myStruct _m2 = {0,0};

Note: if the structure has padding bytes (due to alignment), then neither of these guarantee that they are initialized. It may be important when writing the structure to external storage, network or comparing with memcmp. In such cases one should use memset.

Community

The first is easiest(involves less typing), and it is guaranteed to work, all members will be set to 0^{[Ref 1]}.
The second is more readable.

The choice depends on user preference or the one which your coding standard mandates.

[Ref 1] Reference C99 Standard 6.7.8.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.

Good Read:
C and C++ : Partial initialization of automatic structure

Also, I am using = {}; However I am not sure if this is valid.

@FullDecent empty braces for initialization is a GNU extension.

@alias65536 The question is tagged C not C++.

I got an error: "missing braces around initializer [-Werror=missing-braces]" probably because of an member array :/

@Edenia. I disagree. I already know what foo = {0} means. If I saw foo = ZERO_FULL, I'd have to grep for the definition of ZERO_FULL.

Basile Starynkevitch

If the data is a static or global variable, it is zero-filled by default, so just declare it myStruct _m;

If the data is a local variable or a heap-allocated zone, clear it with memset like:

memset(&m, 0, sizeof(myStruct));

Current compilers (e.g. recent versions of gcc) optimize that quite well in practice. This works only if all zero values (include null pointers and floating point zero) are represented as all zero bits, which is true on all platforms I know about (but the C standard permits implementations where this is false; I know no such implementation).

You could perhaps code myStruct m = {}; or myStruct m = {0}; (even if the first member of myStruct is not a scalar).

My feeling is that using memset for local structures is the best, and it conveys better the fact that at runtime, something has to be done (while usually, global and static data can be understood as initialized at compile time, without any cost at runtime).

There's no guarantee that setting all bytes of the struct to 0 will be equivalent to initializing all struct members with 0 though. On many platforms this will be true, but not universally.

Can you share an example, Sander? Genuine curiosity. (Obviously, not universally true doesn't necessarily mean there's an easy-to-explain exception, but if there is...)

The C standard permits the null pointer (or a zero floating point number) to be represented in memory by something else than all zero bits. Very few and weird implementations are doing that (I cannot name any).

-1, you might find the initialization that the OP asks about ugly, but it is exactly what is forseen by the standard and that can be easily optimized by all compilers. Then, the form {} is not valid C but only available in C++.

@Steven : I can only think of obscure and/or old platforms. The C FAQ has a list of platforms that had a NULL pointer that wasn't all 0 bits : c-faq.com/null/machexamp.html. And then there's the possibility the platform is not using IEEE 754 to represent floating point values, but uses some other representation that doesn't have an all 0 bit 0.0 value - but admittedly I know of no such platform.

Cœur

See §6.7.9 Initialization:

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.

So, yes both of them work. Note that in C99 a new way of initialization, called designated initialization can be used too:

myStruct _m1 = {.c2 = 0, .c1 = 1};

Most notably this is already C89: open-std.org/JTC1/SC22/WG14/www/docs/n1124.pdf#page=139 (Important for specific signal processing targets)

But note that it works intuitively for {0} but not as clear if you for example do {1}. It's easy to think that it would set everything to 1, but it will set only the first to 1 and implicitly initialise the rest so you likely end up with 1,0.

DuDa

I also thought this would work but it's misleading:

myStruct _m1 = {0};

When I tried this:

myStruct _m1 = {0xff};

Only the 1st byte was set to 0xff, the remaining ones were set to 0. So I wouldn't get into the habit of using this.

The question explicitly asks about initializing the structure elements to 0, and also, the quickest way to do it. So, for initializing the elements with some other value, you must use the traditional method

Thank you for stating the obvious. It is still misleading because when someone looks up assignment, they might not want to set something to 0 but to something else, and they would see this method and might try to use it. I'm not sure if you understand where I'm coming from at all but I tried to explain it.

Initializing a struct to 0

Follow WeChat

Want to stay one step ahead of the latest teleworks?

相似问题

Platform

Support

Links

Contact US