How to avoid NULL Pointer Dereference in C?

Let’s go over some fundamental ideas associated with any pointer once more before discussing the concept of a null pointer.

All programming language needs a pointer, which stores the memory location of another variable. You may provide the pointer to the memory space of a variable by applying the reference operator &. Alternatively, you can also use the Asterisk (*) operator. 

int var = 12;

Naming var is a variable with an integer type.

int ptr = &var;

The memory address of the variable var is stored in the pointer ptr in the previous example. The pointer points to a similar typeof data type, such as the int in this case.

Also Read: How to dereference a Void Pointer in C?

or int *ptr = &var;

The memory location is held by ptr while the value of var is held by *ptr.

Also Read: How to dereference a CHAR pointer in C?

A pointer is dereferenced to get the value of the variable that it points to by using the asterisk symbol (*).This is an indirect approach to get the value of the variable var.


Dereferencing the pointer, which results in the variable’s value of 12 being returned, is what happened.

Also Read: How Dangling Pointer in C affects your Programming?

What is a Null Pointer?

A pointer is referred to as being a null pointer at declaration if the NULL value is used to represent it rather than any other values. It is one of the numerous different sorts of pointers. The value null here denotes that the address space pointer is currently pointing to memory location 0.

Also Read: What is Double Pointer in C?

Syntax: int *ptr = NULL;

Making the reference initialized to zero.

Clause of the C11 standard,

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant. If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.

What does Null refer to?

According to objective standards, NULL advances to a null pointer constant that is specified in a number of header files, such as “stdio.h,” “stddef.h,” and “stdlib.h.”

For C compilers, the conventional interpretation of the NULL macro is (void *)0. However, the C specification also recognizes 0 as a null pointer constant. The preceding is also perfectly permissible in view of the current formal standard:

int *ptr = 0;

Or char *ptr = ‘\0’;

A null pointer constant can also be created by assigning a pointer 0.

The C code above incorporates the number 0, but because it is used in a context with pointers, it isn’t exactly the same as zero as an integer. This may be explained in part by the fact that one benefit of using NULL is that it clearly indicates in the programming that the coder is using a null pointer as opposed to an integer zero.

Any functional sequence, object, or process cannot be referenced by null pointers. The pointer is redundant as a result. A null pointer is distinct from other pointers. It is referred to as executing an erroneous pointer in the C standard.

It signifies that even though a pointer may lead to a memory location that might be retrieved without permission, it is still improper to use it. Examples of such erroneous pointers are dangling and uninitialized.

Applications of a Null Pointer

A function retrieves the pointer from memory and returns it as a function argument when a pointer variable does not point to a valid memory location. Before the pointers are dereferencing, it is utilized to manage pointer faults. When we don’t want to specify the actual memory location, we may also utilize the pointer variable to get it.

What if you Don’t Initialize a Pointer?

int *ptr;

The ptr pointer variable is declared in the aforementioned program, but it is not assigned any variable addresses.

In accordance with the stack memory model, local variables of a function are retained in the stack and are shown as trash if the variable is empty. The aforementioned program crashes with some unexpected results. We may conclude that keeping an uninitialized reference in a program could result in a significant computing crash as a result.


A compile-time error will be displayed as a result of dereferencing an invalid or uninitialized pointer since it does not reference a variable.

You can prevent this by utilizing the malloc() dynamic memory technique or initializing pointers with NULL.

Int *ptr;

Declare an integer pointer

ptr = (int*)malloc(sizeof(int));

Allocating memory address to the pointer variable

If malloc() is incapable of allocating any memory, a NULL pointer will be returned. This necessitates the inclusion of a condition.

If(ptr == NULL)

Checking the value of ptr.


printf(‘Memory is not allocated’);

printing the message if an address is not allocated.


printf(‘Memory is allocated’);

if memory is allocated, print this message.


If the pointer variable has a location allocated to it, the code above will show whether or not it does. It will, if appropriate, print the designated message.

What is a Null Pointer Dereferencing in C?

If a developer mistakenly assumes that a pointer making reference to NULL is pointing to a valid structure, this could occur. The application might have a segmentation fault or other indescribable behaviors as a result of dereference of the null pointer, which could cause a software crash.

The lack of automated tests for NULL locations in C and C++ causes programmers written in those languages to often dereference NULL pointers. Pointers must thus be used with prudence by programmers who utilize these languages.

Can you Dereference a Null Pointer?

A pointer dereference is interpreted as nonnull by the compiler if it is detected. For dereferenced references, the optimizer can elect to omit the null equality checks. It is inappropriate to dereference a null pointer for this reason.

What happens when you Dereference a Null Pointer in C?

Because a null pointer does not point to a valid value, trying to dereference one typically leads to a run-time error or an instant application crash.

How to Avoid Null Pointer Dereference in C?

To prevent the programmer from dereferencing a null pointer there are various methodologies. Find a suitable programming language that restricts them, such as Java, as an alternative. Another is never to discount pointers unless you are sure they are not NULL.

Not to mention, several operators provided by programming languages like C++ can be used to automatically check for NULL pointers prior to dereferencing them. Although they can’t completely remove it, these operations can assist to lower the chance of null pointer dereferences.

Since it can be challenging to debug null pointer dereference, which might occur in routines that seem to be OK, applications should be tested before being published. In real-time, null pointer dereferences may also be found with tools like Valgrind.

How to Fix Null Pointer Dereference in C?

Study the code once more in detail. Fix the dereferencing after locating its source. 


Null pointers are discussed in this article. A null pointer, often known as a null pointer constant, is a reserved value that signifies that the pointer does not refer to any valid elements or functions. It is necessary to compare a pointer to a null object or function unevenly with a pointer to another object or function. With the uninitialized pointer, it is not feasible to provide this degree of certainty.

The algorithm for the Null pointer is:


Establish an int-type pointer.

Give the pointer a NULL initial value.

Write the value out.


Be sure to read and share more articles if you enjoyed this one.

Greetings, My name is Rumi Sadaf. I work as both a content writer and a programmer. In essence, I explain what I know and aid others in understanding programming concepts. Happy Viewing.

Leave a Comment