You need some way to mark AnotherStruct stData empty.

• First check (or double-check) the documentation and comments related to AnotherStruct, possibly ask those who made it if they are available, to find out if there is an official way to do what you want.

• Perhaps that struct has a pointer, and if it is null pointer, the struct is empty. Or perhaps there is an integer field where 0 or -1 or something can mean empty. Or even a boolean field to mark it empty.

• If there aren't any of the above, perhaps you can add such a field, or such an interpretation of some field.

• If above fails, add a boolean field to MyData to tell if stData is empty.

• You can also interpret some values (like, empty string? Full of 0xFF byte?) of data1 and/or data2 meaning empty stData.

• If you can't modify or reinterpret contents of either struct, then you could put empty and non-empty items in different containers (array, list, whatever you have). If MyData items are allocated from heap one-by-one, then this is essentially same as having a free list.

• Variation of above, if you have empty and non-empty items all mixed up in one container, then you could have another container with pointers or indexes to the the non-empty items (or to the empty items, or whatever fits your need). This has the extra complication, that you need to keep two containers in sync, which may or may not be trivial.

Better option is to pass the user count to the function, so you don't need to iterate over the max length. Otherwise yes, you would need to check for null.

You probably meant

if (foo)
    foo->value++;

Also your comment "obviously null pointer error" is not so obvious to me.

ptr points to an array if you increment it, ptr start pointing to a memory out size array that is not null. You can do something like:

ptr = arr;
while (ptr <  (arr +  sizeof(arr)/sizeof(arr[0])) ){
   ptr++;
}

Note: this technique will nnot work for dynamic arrays.

To learn what is this formula about read: Weird behavior when printing array in C?

Really depends on what you are trying to achieve.

If you allocate your struct like this:

Order* OrderReqXml = malloc(...);

then, you should indeed check for the pointer being != NULL before assigning values to your struct. A good way would be:

Order* OrderReqXml = malloc(...);
if (OrderReqXml != NULL) {
  // fill data
} else { /* error handling */ }

If you obtain the pointer from somewhere else, e.g. from a static structure in memory and you want to check whether the struct has been populated or not, you need to check the single struct elements:

bool structIsNotFilled(Order* o) {
  return ((o->fIntOrderNumber == 0) &&
          (o->dLocationCode == 0) &&
          (o->dQzUser == 0) &&
          (o->dSuperUserId == 0))
}

The question then is however, if you wanted to trust this struct in memory to be initialized with zeros. (You must not trust memory allocated with malloc() to be initialized to zero.)

In your code, the initialization

Outer_t outer_instance = {
   {NULL},
   {
    0,
    1,
    2,
    3,
    table_defined_somewhere_else,
   }
};

is invalid. You are trying to assign NULL to Outer_t.tableA which is of non-pointer type Inner_t. NULL can only be assigned to pointers.

Most C compilers define NULL as 0 or ((void*)0). Depending on your compiler, this syntax may be allowed but will be expanded to 0, effectively setting all fields in the first Inner_t structure to zero. In any case, this code will not do what I think you believe it will.

Your notion of tableA being undefined or non-existent is wrong. As your structures are currently defined, declaring an object of type Outer_t will automatically create two Inner_t objects as structure members (and those Inner_t structures will automatically create the objects they are composed of, etc). If outer_instance exists, then outer_instance.tableA and outer_instance.tableB are guaranteed to exist. They cannot be "undefined" (they are defined when you defined the Outer_t data type) or "NULL" (has no meaning except for pointers). A structure which has members defined is never "empty".

Now, it is a valid concern whether or not tableA or tableB have been initialized. There is no universally-appropriate way to do this. One method is to fill the entire structure with some pre-defined value when it is declared, and to check for the presence of that value as a sign that the structure has not been initialized. This assumes, however, that there is a value that you should never see as valid data within that structure; many times, such a value does not exist.

If you want to build your code in such a way that the members of Outer_t may or may not exist, then you should use pointers (such as Inner_t* tableA) as members of Outer_t instead of structures. That way, you can NULL the pointer to indicate a non-existent table. However, you would not be able to declare the contents of the inner structs at the same time as the outer struct in the manner which you currently do.

Edit: Looking at your updated code, it appears that you are getting that particular error because you are trying to assign an object of type Items_t to a field of type Items_t*. Use &items_instance here and your error should go away (provided that items_instance is defined before outer_instance, and all elements of items_instance can be determined at compile time).

Just make sure you initialise the pointer to NULL:

text* t = NULL;

then later you can malloc on demand, e.g.:

if (t == NULL)
{
    t = malloc(sizeof *t);
    // NB: check for error here - malloc can fail!
}
t->head = foo;

Arrays in C cannot be "empty". They are never empty. If you declared an array of 10 elements you will always have an array of 10 elements. There's no way to say whether some element has been modified or not unless you yourself come up with some way to manually "mark" elements that you modify. For example, you can choose some reserved element value, which will designate an "empty" element.

In your case you declare an array of 10 pointers

node* array[10];

If you supply an initializer

node* array[10] = { 0 };

your array elements will have the initial value of null. You can use that value as a mark of an "empty" element.

You may only compare a pointer to NULL. An Adjustment itself will never be NULL.