{0} vs {}

[440gtx]

I frequently interface with API's that require one to "clear out" a
POD structure (some people choose memset or equivalent for this), then
fill in a set of relevant fields based on the type of function call
the struct is being used for. Would method (a) or (b) below be more
appropriate and will there be a difference technically speaking,
keeping in mind this is POD? I also included a third method (c)
wondering if it is good practice or not for cases where the structure
begins with a field that needs initialized with the size of the
structure:

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

....fill in a few fields...

api_func(&a); // or b or c

So anyway which would you use (a, b, c), if any, and why?

 

[asterisc]

(e-mail address removed) a scris:

I frequently interface with API's that require one to "clear out" a
POD structure (some people choose memset or equivalent for this), then
fill in a set of relevant fields based on the type of function call
the struct is being used for. Would method (a) or (b) below be more
appropriate and will there be a difference technically speaking,
keeping in mind this is POD? I also included a third method (c)
wondering if it is good practice or not for cases where the structure
begins with a field that needs initialized with the size of the
structure:

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

...fill in a few fields...

api_func(&a); // or b or c

So anyway which would you use (a, b, c), if any, and why?

If we are talking about an array: int a[xx] then the a. method is the
prefered. That way, all the elements will be initialized with 0, where
in b. there is undefined value.

 

[Sylvester Hesp]

asterisc wrote :

(e-mail address removed) a scris:

I frequently interface with API's that require one to "clear out" a
POD structure (some people choose memset or equivalent for this), then
fill in a set of relevant fields based on the type of function call
the struct is being used for. Would method (a) or (b) below be more
appropriate and will there be a difference technically speaking,
keeping in mind this is POD? I also included a third method (c)
wondering if it is good practice or not for cases where the structure
begins with a field that needs initialized with the size of the
structure:

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

...fill in a few fields...

api_func(&a); // or b or c

So anyway which would you use (a, b, c), if any, and why?

If we are talking about an array: int a[xx] then the a. method is the
prefered. That way, all the elements will be initialized with 0, where
in b. there is undefined value.

Nonsense, 8.5.1/7:
If there are fewer initializers in the list than there are members in
the aggregate, then each member not explicitly initialized shall be
value-initialized

- Sylvester

 

[Victor Bazarov]

asterisc wrote :

(e-mail address removed) a scris:

I frequently interface with API's that require one to "clear out" a
POD structure (some people choose memset or equivalent for this),
then fill in a set of relevant fields based on the type of function
call the struct is being used for. Would method (a) or (b) below be
more appropriate and will there be a difference technically
speaking, keeping in mind this is POD? I also included a third
method (c) wondering if it is good practice or not for cases where
the structure begins with a field that needs initialized with the
size of the structure:

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

...fill in a few fields...

api_func(&a); // or b or c

So anyway which would you use (a, b, c), if any, and why?

If we are talking about an array: int a[xx] then the a. method is the
prefered. That way, all the elements will be initialized with 0,
where in b. there is undefined value.

Nonsense, 8.5.1/7:
If there are fewer initializers in the list than there are members in
the aggregate, then each member not explicitly initialized shall be
value-initialized

My habit of supplying the zero for value-initialising aggregates has
two roots: one was the bug in a well-knon compiler that couldn't get
the empty curly braces right, the other was style - I want the reader
to know that it's the zero that gets put there (at least for POD it
is).

V

 

[Sylvester Hesp]

Victor Bazarov wrote :

asterisc wrote :

(e-mail address removed) a scris:
I frequently interface with API's that require one to "clear out" a
POD structure (some people choose memset or equivalent for this),
then fill in a set of relevant fields based on the type of function
call the struct is being used for. Would method (a) or (b) below be
more appropriate and will there be a difference technically
speaking, keeping in mind this is POD? I also included a third
method (c) wondering if it is good practice or not for cases where
the structure begins with a field that needs initialized with the
size of the structure:

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

...fill in a few fields...

api_func(&a); // or b or c

So anyway which would you use (a, b, c), if any, and why?

If we are talking about an array: int a[xx] then the a. method is the
prefered. That way, all the elements will be initialized with 0,
where in b. there is undefined value.

Nonsense, 8.5.1/7:
If there are fewer initializers in the list than there are members in
the aggregate, then each member not explicitly initialized shall be
value-initialized

My habit of supplying the zero for value-initialising aggregates has
two roots: one was the bug in a well-knon compiler that couldn't get
the empty curly braces right

VC++ 6.0, IIRC? Anyone still using that crappy compiler should be shot
. Seriously though, that is a fair point.

the other was style - I want the reader to know that it's the zero that gets
put there (at least for POD it is).

This is debatable. Just as with empty parantheses in member
initializations, empty braces could just as well be interpreted as
value-initialization. Personally, I make the distinction on whether the
initializer is specified or not - if you do not want the aggregate to
be initialized, you should omit the initializer anyway, so if it's
there, it means initialize with zeroes (for POD members that is),
whether it's empty or contains a single zero.

- Sylvester

 

[Roland Pibinger]

I frequently interface with API's that require one to "clear out" a
POD structure

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

How about:
API_STRUC d = API_STRUC();

 

[Clark Cox]

(e-mail address removed) a scris:

I frequently interface with API's that require one to "clear out" a
POD structure (some people choose memset or equivalent for this), then
fill in a set of relevant fields based on the type of function call
the struct is being used for. Would method (a) or (b) below be more
appropriate and will there be a difference technically speaking,
keeping in mind this is POD? I also included a third method (c)
wondering if it is good practice or not for cases where the structure
begins with a field that needs initialized with the size of the
structure:

API_STRUC a = {0};
API_STRUC b = {};
API_STRUC c = {sizeof c};

...fill in a few fields...

api_func(&a); // or b or c

So anyway which would you use (a, b, c), if any, and why?

If we are talking about an array: int a[xx] then the a. method is the
prefered. That way, all the elements will be initialized with 0, where
in b. there is undefined value.

That is simply not true. a and b are equivalent.

 

[Old Wolf]

How about:
API_STRUC d = API_STRUC();

Wasn't it only added in C++03 that this syntax
causes zero-initialization in PODs? I wouldn't
like to rely on a compiler to get that right.