How to check whether a struct's member is NULL in C? - c

Question

I got a problem with checking whether a member of a struct is null or not. For example:
typedef struct {
int value;
} A;
int main() {
A *foo = malloc(sizeof(A));
foo->value++; // obviously, null pointer error
}
Then I attempted to check whether value is NULL or not by:
if (foo->value != NULL) {
foo->value++;
}
But the error occured: comparison between pointer and integer.
What should I do? Note that set it to 0 is not an option in my circumstance.

Answer 1

You probably meant
if (foo)
foo->value++;
Also your comment "obviously null pointer error" is not so obvious to me.

Answer 2

foo->value++; // obviously, null pointer error
Not so obvious to me why this is an error. value is an int, not an int *, so how can it ever be a NULL pointer?
I think you meant to perform the following check
A *foo = malloc(sizeof(A));
if( foo != NULL ) {
foo->value++; // increment value
} else {
// allocation failed, do something about it
}
When you malloc a structure enough memory is allocated to contain all members of that structure; you do not have allocate memory for every single member.
Note that the contents of the structure itself are uninitialized after the malloc call. To set the members to a deterministic state you can do any one of the following:
foo->value = 0; Similarly initialize all other members
memset( foo, 0, sizeof(*foo) ); This sets all bits within the structure to zeros
A *foo = calloc( 1, sizeof(A) ); calloc automatically zero initializes the allocated memory

Answer 3

An int isn't a pointer. It can't be NULL (or at least that value is indistinguishable from zero).

Answer 4

That's an int, not a pointer, so it doesn't make much sense to compare it to NULL. If you want to be able to do that, then you need to declare it in the struct as an int*. Otherwise just make sure you initialize it to 0 when you create the struct.
To expand on the above, it's important to be aware that when you malloc() that struct, the space for that int is ALREADY IN the space provided by the malloc(). The struct literally contains the int, not just a pointer to it.

Answer 5

The int type is not a pointer so it can not be a NULL pointer. When you create a struct enough room is allocated for your values but you still need to initialize its contents, otherwise they will be set to what was previously in the allocated space, and sometimes this best done using another function.
A *createA()
{
A *a = malloc(sizeof(A));
//TODO: make sure a is no null
a->value = 0;
return a;
}
Calling createA will now always return a struct with the int value set to 0.

Answer 6

As others have pointed out, int is not a pointer type and cannot be NULL. However, I believe what you were trying to get at by the 'obviously, null pointer error' remark was that memory obtained from malloc is not initialized, so foo->value++ won't necessarily leave you with 1. To fix this you can either use calloc or memset:
calloc:
int main() {
A *foo = calloc(1, sizeof(A)); // returns 0'd memory
foo->value++;
}
memset:
int main() {
A *foo = malloc(sizeof(A));
memset(foo, 0, sizeof(*foo)); // sets the contents of the struct to 0
foo->value++;
}
You can also manually 0 the fields, which works fine, but you leave yourself open to forgetting to zero new fields you add to the struct later.