Initialize/reset struct to zero/null

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;

You can use memset with the size of the struct:

struct x x_instance;
memset (&x_instance, 0, sizeof(x_instance));

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.

 struct x myX;
...
memset(&x, 0, sizeof(myX));

Better than all above is ever to use Standard C specification for struct initialization:

struct StructType structVar = {0};

Here are all bits zero (ever).

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.

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;

I believe you can just assign the empty set ({}) to your variable.

struct x instance;


for(i = 0; i < n; i++) {
instance = {};
/* Do Calculations */
}

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.

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.

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