Initializing a struct to 0

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};

The first is easiest(*involves less typing*), and it is guaranteed to work, all members will be set to `0`<sup>[Ref 1]</sup>.
The second is more readable.

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

<sup>[Ref 1]</sup> **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:**

[To see links please register here]

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};

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).

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.