Create an initialiser function that takes all the fields as arguments (as if it were an object constructor) and use it instead of setting the fields one by one.

Of course, that won t prevent anybody to keep it doing the wrong way, but if you maintain the discipline of using that function, it will be much more difficult to leave some field uninitialised without noticing. And if you change the fields of the structure (and the function accordingly), the compiler will complain about the mismatching arguments wherever you forgot to update.

You can go a little bit further (but not much more with just plain C) doing some tricks with the preprocessor and the includes to enforce the data encapsulation, but it s somewhat cumbersome. Any book on OOP with C will help you with that issue, but I don t know if the gain is worth the effort.

Is valgrind available on your system? If you run your program through it, it will automatically detect the use of any uninitialized variables. It can also catch quite a few other problems (such as using memory that s already been free d). This won t then become a permanent feature of your program, but it s very nice for debugging.

I would combine this with the asserts mentioned earlier and increased compiler warnings. That s about all you can do—the problem is there s no difference between initialized and uninitialized memory. To the machine, they are all just values.

Use assertions (from assert.h) to check the prerequisites needed by your function. It is up to you to define what is a valid or invalid value for a field of the structure.

example:

assert( NULL != object);
assert( NULL != object->name);

Add another member to the structure to indicate if the rest of the members are filled (and initialize it to "false"). Then just check that new member.

struct whatever {
  int datagood;
  /* more members; */
};

struct whatever bar;
bar.datagood = 0;

foo(&bar); /* foo() will see datagood == 0 */

/* bar.a = 42; */
/* bar.b = 24; */
bar.datagood = 1;

foo(&bar); /* foo() will see datagood == 1 */

I do not think there is a solution in C itself. As others suggested, you may use valgrind, but it is another story. I always memset() the struct:

memset(&object, 0, sizeof(struct mystruct));

or

struct mystruct *p = calloc(1, sizeof(struct mystruct));

Then you can check the members against 0. I believe this is a good habit.

By static analysis. Parasoft C++test has BD-PB-NOTINIT (Avoid usage of not initialized data) flowanalysis rule for that.

Your best bet is to write a function that validates the contents of the struct manually and returns a True/False (however you define it), this way you can easily use the method wherever you utilize this struct.

This is usually solved by careful programming, but if you have to be sure, here s an overkill idea:

• Add a checksum/crc field.
• Add an update function of members that also modifies the checksum field.
• Upon using, use another function to compare the checksum of the fields with that of the checksum field.