struct x {
char a[10];
char b[20];
int i;
char *c;
char *d[10];
};
I am filling this struct and then using the values. On the next iteration, I want to reset all the fields to 0 or null before I start reusing it.
How can I do that? Can I use memset or I have to go through all the members and then do it individually?
Define a const static instance of the struct with the initial values and then simply assign this value to your variable whenever you want to reset it.
For example:
static const struct x EmptyStruct;
Here I am relying on static initialization to set my initial values, but you could use a struct initializer if you want different initial values.
Then, each time round the loop you can write:
myStructVariable = EmptyStruct;
memset makes me feel dirty. I prefer to let the compiler worry about memory layout wherever possible. Strictly speaking such use of memset is non-portable but in practice I'd be astounded if you ever compiled your code anywhere that mattered. So, you can likely use memset safely if you prefer it. –
Venery EmptyStruct as static const? –
Sulphurize memset won't be much help to zero them. –
Mcfall The way to do such a thing when you have modern C (C99) is to use a compound literal.
a = (const struct x){ 0 };
This is somewhat similar to David's solution, only that you don't have to worry to declare an the empty structure or whether to declare it static. If you use the const as I did, the compiler is free to allocate the compound literal statically in read-only storage if appropriate.
struct x { int prop[3]; }; struct x a = (const struct x){ 0 }; while the startic const struct x EMPTY_STUCT method does not. –
Horbal { 0 } as the default initializer. Switch that warning off, it is spurious false alarm. –
Cramp *ptr = (typeof(*ptr)){}; –
Togoland Better than all above is ever to use Standard C specification for struct initialization:
struct StructType structVar = {0};
Here are all bits zero (ever).
{} in C++. The gcc devs seem unsure whether C++ is supposed to support {0} and I'm not familiar with that part of the standard myself. –
Interlocutress {0} or {}. Not sure if the C & C++ standards are clear and in sync on this issue, but apparently, compilers are not. –
Sewer struct StructType structVar = malloc (sizeof(StructType)); structVar ={0} –
Jin x = malloc(sizeof(x)); memset(&x, 0, sizeof(x)); –
Hereon In C, it is a common idiom to zero out the memory for a struct using memset:
struct x myStruct;
memset(&myStruct, 0, sizeof(myStruct));
Technically speaking, I don't believe that this is portable because it assumes that the NULL pointer on a machine is represented by the integer value 0, but it's used widely because on most machines this is the case.
If you move from C to C++, be careful not to use this technique on every object. C++ only makes this legal on objects with no member functions and no inheritance.
If you have a C99 compliant compiler, you can use
mystruct = (struct x){0};
otherwise you should do what David Heffernan wrote, i.e. declare:
struct x empty = {0};
And in the loop:
mystruct = empty;
You can use memset with the size of the struct:
struct x x_instance;
memset (&x_instance, 0, sizeof(x_instance));
memset is an option, but when using it, you have to make sure that the memory written to is exactly the same size as the third parameter, that's why it's better to refer to the size of the actual object, not the size of the type you know it currently is. IOW memset (&x_instance, 0, sizeof(x_instance)); is a much better choice. BTW: the (void*) cast is superfluous in C++ too. –
Nephogram I believe you can just assign the empty set ({}) to your variable.
struct x instance;
for(i = 0; i < n; i++) {
instance = {};
/* Do Calculations */
}
I asked a compiler engineer at work about which option is better (memset vs {0}). Instead of giving my an opinion he pointed me to Compiler Explorer. It's interesting to see how all three options compile out:
https://godbolt.org/z/bPfKeG9Yh
Here's a preview of the code:
// Type your code here, or load an example.
#include "string.h"
struct MyStruct {
int age;
int sin;
char *name;
int cats;
char something[64];
};
const struct MyStruct empty_struct = {0};
int test() {
struct MyStruct blah = {0};
memset(&blah, 0, sizeof(blah));
blah = empty_struct;
blah.age = 99;
blah.sin = 123456789;
}
The compiler makes different decisions on how to zero memory depending on the member types of the struct. Try commenting out something for example or choosing a non-x86 target.
struct x myX;
...
memset(&x, 0, sizeof(myX));
Memset with NULL is dangerous function.
For C++ better by this way for most simple data structures >>
template<class T>
void Null_MyType(T &obj)
{
constexpr T o_null = T{};
obj = o_null;
}
Take a surprise from gnu11!
typedef struct {
uint8_t messType;
uint8_t ax; //axis
uint32_t position;
uint32_t velocity;
}TgotoData;
TgotoData tmpData = { 0 };
nothing is zero.
© 2022 - 2024 — McMap. All rights reserved.
memsetif I only want to reset everything to0?? – Sulphurize