Initializing an object to all zeroes

by

memset is practically never the right way to do it. And yes, there is a practical difference (see below).

In C++ not everything can be initialized with literal 0 (objects of enum types can’t be), which is why in C++ the common idiom is

some_struct s = {};

while in C the idiom is

some_struct s = { 0 };

Note, that in C the = { 0 } is what can be called the universal zero initializer. It can be used with objects of virtually any type, since the {}-enclosed initializers are allowed with scalar objects as well

int x = { 0 }; /* legal in C (and in C++) */

which makes the = { 0 } useful in generic type-independent C code (type-independent macros for example).

The drawback of = { 0 } initializer in C89/90 and C++ is that it can only be used as a part of declaration. (C99 fixed this problem by introducing compound literals. Similar functionality is coming to C++ as well.) For this reason you might see many programmers use memset in order to zero something out in the middle of C89/90 or C++ the code. Yet, I’d say that the proper way to do is still without memset but rather with something like

some_struct s;
...
{
  const some_struct ZERO = { 0 };  
  s = ZERO;
}
...

i.e. by introducing a “fictive” block in the middle of the code, even though it might not look too pretty at the first sight. Of course, in C++ there’s no need to introduce a block.

As for the practical difference… You might hear some people say that memset will produce the same results in practice, since in practice the physical all-zero bit pattern is what is used to represent zero values for all types. However, this is generally not true. An immediate example that would demonstrate the difference in a typical C++ implementation is a pointer-to-data-member type

struct S;
...

int S::*p = { 0 };
assert(p == NULL); // this assertion is guaranteed to hold

memset(&p, 0, sizeof p);
assert(p == NULL); // this assertion will normally fail

This happens because a typical implementation usually uses the all-one bit pattern (0xFFFF...) to represent the null pointer of this type. The above example demonstrates a real-life practical difference between a zeroing memset and a normal = { 0 } initializer.

More Related Contents:

  1. How do I compare chars (or strings) using void functions, also comparing chars that were taken from a struct array
  2. what does this error mean in general? and how I fix it in this case? [closed]
  3. Why isn’t sizeof for a struct equal to the sum of sizeof of each member?
  4. Difference between ‘struct’ and ‘typedef struct’ in C++?
  5. When should you use a class vs a struct in C++?
  6. Why does C++ disallow anonymous structs?
  7. When to use bit-fields in C?
  8. How to use a C++ string in a structure when malloc()-ing the same structure?
  9. How to compile C code with anonymous structs / unions?
  10. memset() or value initialization to zero out a struct?
  11. Structure of a C++ Object in Memory Vs a Struct
  12. Structure of Arrays vs Array of Structures
  13. using struct keyword in variable declaration in C++
  14. Struct initialization of the C/C++ programming language?
  15. union ‘punning’ structs w/ “common initial sequence”: Why does C (99+), but not C++, stipulate a ‘visible declaration of the union type’?
  16. How to read / write a struct in Binary Files?
  17. Casting double array to a struct of doubles
  18. What is the difference between using a struct with two fields and a pair?
  19. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  20. Get attribute by name
  21. c++ sort with structs
  22. Force C++ structure to pack tightly
  23. Mixing class and struct
  24. default visibility of C++ class/struct members
  25. how to assign multiple values into a struct at once?
  26. What is the meaning of `struct X typedef` vs. `typedef struct X`?
  27. What is the meaning of double curly braces initializing a C-struct?
  28. Purpose of struct, typedef struct, in C++
  29. No == operator found while comparing structs in C++
  30. Variable Sized Struct C++

Leave a Comment