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

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).