Is memset(&mystruct, 0, sizeof mystruct) same as mystruct = { 0 };?

by

is memset(&mystruct, 0, sizeof mystruct) same as mystruct = { 0 }; ?

No.

memset(&mystruct, 0, sizeof mystruct) ;

… will tell the compiler to call a function that we expect will set during execution the data in mystruct to zero.

mystruct = { 0 };

… will set tell the compiler set by itself the data to zero, which means it will:

  • if possible, set the data in mystruct to zero at compilation (e.g. for static variables, as tristopia and Oli Charlesworth remarked in the comments)
  • or if not (e.g. auto variables), to generate the assembly code that will set the data to zero when the variable is initialized (which is better than calling a function to do that).

Note that perhaps the compiler could optimize the memset into a compile-time instruction (like replacing the first version with the second version), but I wouldn’t rely on that as memset is a function from the runtime library, not some language intrinsic (I’m not a compiler writer/language lawyer, though).

Coming from C++, my own viewpoint is that the more you can do at compilation and the more the compiler knows at compile time, before the execution even starts, the better: It enables the compiler to possibly optimize the code and/or generate warning/errors.

In the current case, using the mystruct = { 0 }; notation to initialize a struct is always safer than using the memset because it is very very easy write the wrong thing in C with a memset without the compiler complaining.

The following examples show that it is easy for the code to do something different than it appears to do:

// only the 1st byte will be set to 0
memset(&mystruct, 0, sizeof(char)) ;          

// will probably overrun the data, possibly corrupting
// the data around it, and you hope, crashing the process.
memset(&mystruct, 0, sizeof(myLARGEstruct)) ; 

// will NOT set the data to 257. Instead it will truncate the
// integer and set each byte to 1
memset(&mystruct, 257, sizeof(mystruct)) ;    

// will set each byte to the value of sizeof(mystruct) modulo 256
memset(&mystruct, sizeof(mystruct), 0) ;      

// will work. Always.
mystruct = { 0 } ;

More Related Contents:

  1. "." or "->" C struct accessor [duplicate]
  2. free() not working correctly with struct
  3. C expected expression before struct error
  4. Reading and analyzing rooms from text file
  5. Struct memory layout in C
  6. Difference between a Structure and a Union
  7. How do you compare structs for equality in C?
  8. How do I check if a variable is of a certain type (compare two types) in C?
  9. Assign one struct to another in C
  10. The initialization of static variables in C
  11. Initialize/reset struct to zero/null
  12. Casting one struct pointer to another – C
  13. Why doesn’t GCC optimize structs?
  14. How to initialize const in a struct in C (with malloc)
  15. C Typedef and Struct Question
  16. Writing a ‘generic’ struct-print method in C
  17. Trouble Understanding MPI_Type_create_struct
  18. How does a C-style struct with a bitfield get represented in a Rust #[repr(C)] struct?
  19. Can we have a struct element of type Variable length array? [duplicate]
  20. Empty structure in C
  21. forward declaration of a struct in C?
  22. Why does C have a distinction between -> and .?
  23. Is there any way to loop through a struct with elements of different types in C?
  24. Access struct members as if they are a single array?
  25. Flexible array member not getting copied when I make a shallow copy of a struct
  26. size of struct in C [duplicate]
  27. Does GCC’s __attribute__((__packed__)) retain the original ordering?
  28. Char array in a struct – incompatible assignment? [duplicate]
  29. Get list of C structure members
  30. Why does my function not modify the value of variable in a struct in C?

Leave a Comment