Initializing all members (of the same, basic, data type) of a struct to one given value

Question

Let's say I have a struct made of several fields, all of the same basic data type.

For example:

struct myStruct {
    float a;
    float b;
    float c;
    float d;
    float e;
    float f;
}

Is there a smart approach to initialize or set all members to a given value, e.g. -1, or 0xDEADBEEF, in a way that is flexible to changes in the number of fields and in the field names?

Rationale:
Initializing all fields to an invalid state, and make sure all fields are initialized if later on I add new fields.

Note:
If there is a solution that would only work for integer types, I am anyway interested.

This is a different question from array initialization and zero-initialization of a struct, as here I am asking about initializing a struct, with fields all of the same basic data type, to a custom value.

This question, which doesn't concern arrays inside a struct, is also not answered at Initialize values of array in a struct. It's also not treated in structs in C with initial values, as I am asking about the case in which all data field have the same, basic, data type

Answer 1

One way to address this problem is using the X Macro concept link1, link 2.

The list of struct members would be

#define LIST_OF_STRUCT_MEMBERS \
    X(a) \
    X(b) \
    X(c)

Then one would declare the struct as:

#define X(name) int name;
struct myStruct {
     LIST_OF_STRUCT_MEMBERS
}
#undef X

Where int could be replaced by any basic data type.

One could then create a const variable initialized to the default value:

#define X(name) -1,
const struct myStruct myStruct_DEFAULT_VALUE = { LIST_OF_STRUCT_MEMBERS };
#undef X

Translated by the preprocessor into:

const struct myStruct myStruct_DEFAULT_VALUE = {-1, -1, -1,};

This can be copied every time a new variable has to be initialized.

The method can easily be verified defining in the same way a print function:

#define X(name) printf("%s = %d\n", #name, in->name);
void printAllMembers(struct myStruct* in) {
     LIST_OF_STRUCT_MEMBERS
}    
#undef X

(The printAllMembers function might need some modification when the underlying basic data type is changed).

Verified here.

---

This concept can generalize to a struct with fields of different data types if we include the data type in LIST_OF_STRUCT_MEMBERS, e.g.:

#define LIST_OF_STRUCT_MEMBERS \
    X(int, a) \
    X(float, b) \
    X(double, c)

#define X(type, name) type name;
struct myStruct {
     LIST_OF_STRUCT_MEMBERS
};
#undef X

#define X(type, name) -1,
const struct myStruct myStruct_DEFAULT_VALUE = { LIST_OF_STRUCT_MEMBERS };
#undef X

#define intFormatting "%d"
#define floatFormatting "%f"
#define doubleFormatting "%f"

#define X(type, name) printf(#name " = " type ## Formatting "\n", in->name);
void printMyStruct (struct myStruct* in) {
     LIST_OF_STRUCT_MEMBERS
}
#undef X

Tested here.

Answer 2

There is no way to initialize the members of a struct to a given value, other than zero, independent of the number of fields of the struct.

However, you could develop a module that gives a new instance of the struct to the user code. The module now can initialize the members to any value you want and any change to the struct, in this respect, is limited to the module. For example:

// mystruct.h
struct MYSTRUCT {
    ...
} t_mystruct;
t_mystruct *newMyStruct(void);

// any module.c
#include "mystruct.h"

t_mystruct *newMyStruct(void)
{
    t_mystruct *newstruct;
    if ((newstruct= malloc(sizeof(t_mystruct)))==0) return 0;
    newstruct->member1= -1;
    newstruct->...
    return newstruct;
}

Answer 3

Is there a smart way to initialize or set all members to a given value, e.g. -1, or 0xDEADBEEF, independently from the number of fields and from the field names?

No, there isn't, unless the value to which you want to initialize the fields is zero / NULL. In that case you can use an initializer such as { 0 }:

struct myStruct s = { 0 };

That says to initialize the first field to 0; since C does not permit partial initialization of aggregates, the other fields get the same value that they would get by default if they has static duration, which is also 0 / NULL (for scalars; the default initialization applies recursively to members that are themselves aggregates).

You can, however, provide a structure-specific initializer macro, or a global const object of the structure type that can be used to initialize the structure. If you maintain this together with the structure declaration then there is little risk of them falling out of sync. Moreover, you can initialize the members via designated initializers to avoid problems arising from the order of the members being altered. For example,

struct myStruct {
    float a;
    float b;
    float c;
};

#define MYSTRUCT_INITIALIZER { .a = 1.0, .b = 1.0, .c = 1.0 }

// ...

struct mystruct s = MYSTRUCT_INITIALIZER;

Note, too, that such an approach is more general than you asked for with respect to how you can initialize members (they don't have to all have the same type or all receive the same value).