Null Pointer in C

Syntax of Null Pointer in C

Here are the following syntaxes of the Null pointer are given below.

Syntax-1

data_type *ptr=NULL;

Examples

int *ptr=NULL;
float *ptr=NULL;
char *ptr=NULL;

Syntax-2

data_type *ptr=(data_type*)NULL;

Examples

int *ptr=(int*)NULL;
float *ptr=(float*)NULL;
char *ptr=(char*)NULL;

Syntax-3

data_type *ptr=(data_type*)0;

Examples

int *ptr=(int*)0;
float *ptr=(float*)0;
char *ptr=(char*)0;

Applications of Null Pointer in C

• Initialization: Use null pointers to initialize pointers when no valid memory address is available.
• Error Handling: Employ null pointers to indicate errors, especially in functions returning pointers, such as memory allocation functions.
• Termination Conditions: Utilize null pointers as termination conditions in recursive algorithms or linked list traversal.
• Dynamic Memory Allocation: Check for null pointers after dynamic memory allocation functions like malloc() or calloc() to handle memory allocation failures gracefully.
• Default Pointers: Assign null pointers as default values in function parameters to signify no specified memory address.
• Sentinel Values: Employ null pointers as sentinel values in data structures like trees or graphs to represent the absence of a node or edge.
• Function Pointers: Utilize null function pointers to indicate uninitialized or unused function pointers.
• Resource Release: Use null pointers to avoid releasing resources like file handles or database connections multiple times in error handling scenarios.

Example of Null Pointer in C

Here is a program to illustrate the Null pointer in the C program.

• C

C

#include<stdio.h>
int main()
{
   int *ptr=NULL;
   printf("The value of ptr is: %d\n",ptr);
   return 0;
}

You can also try this code with Online C Compiler

Run Code

Output 

The value of ptr is: 0

The above C program shows that a NULL value initializes the pointer variable ptr.

More examples of null pointer in C:

1. Error Handling Example:

FILE *filePtr = fopen("nonexistent_file.txt", "r");
if (filePtr == NULL) {
    printf("Error opening file!"); // Handle error when fopen() returns NULL
}

Here, fopen() attempts to open a file named "nonexistent_file.txt" in read mode. If the file does not exist or cannot be opened for any reason, fopen() returns a NULL pointer, which is checked and used for error handling.

2. Dynamic Memory Allocation Example:

int *arr = (int *)malloc(5 * sizeof(int)); // Dynamically allocate memory
if (arr == NULL) {
    printf("Memory allocation failed!"); // Handle error when malloc() returns NULL
}

In this case, malloc() is used to allocate memory for an array of 5 integers. If the memory allocation fails for any reason (e.g., insufficient memory), malloc() returns a NULL pointer, which is checked and used for error handling.

How Does Null Pointer Work in C?

In C, a null pointer represents a pointer that does not point to any memory address. It signifies absence of a valid location, commonly used for initialization, error handling, and termination conditions in algorithms. Null pointers simplify memory management, aiding in identifying uninitialized or deallocated memory access. They enhance program robustness by enabling explicit detection and handling of invalid memory operations, contributing to code reliability and stability.

What are the Uses of NULL Pointer in C?

Here are some applications of the Null pointer is given below.

1. To Avoid Crashing a Program
2. For Freeing(deallocating) Memory

1. To Avoid Crashing a Program

Whenever we declare a pointer in our program, the pointer points to some random location in the memory. And when we try to retrieve the information at that location, we get some garbage values. If you use this garbage value in the program or pass it to any function, your program may crash. To avoid the program crash problem, we can use a Null pointer.

Here is a program to illustrate the above concept.

• C

C

#include<stdio.h>
void fun(int *ptr)
{
    if(ptr==NULL)
    {
        return; 
    }
    else
    {
        // function code
    }
}
void main()
{
    int *ptr=NULL;
    fun(ptr);
}

You can also try this code with Online C Compiler

Run Code

In the above program, we are passing a pointer to the fun() function. In the fun() function, we check whether the input pointer is NULL or not.

If the value of the pointer ptr is not NULL, execute the body of the fun() function.

You can also read about the dynamic arrays in c, And Tribonacci Series

2. For Freeing(deallocating) Memory

Suppose we have a pointer that points to some memory location where some data is stored. But we do not need that data anymore, so we want to delete that data and free the memory. In this case, we delete that data and free the memory. But even after freeing the data, the pointer still points to the same memory location. This pointer is called a dangling pointer. To avoid this dangling pointer, we can set the pointer to NULL.

Here is a program to illustrate the above concept.

• C

C

#include <stdio.h>
void check(int *ptr)
{
     if(ptr==NULL)  
    {  
        printf("Memory is not allocated\n");  
    }  
    else  
    {  
        printf("Memory is allocated\n");  
    } 
}
int main()  
{  
    int *ptr=NULL;  
    ptr=(int*)malloc(4*sizeof(int));
    check(ptr);
    free(ptr);
    check(ptr);
    ptr=NULL;
    check(ptr);
    return 0;  
}

You can also try this code with Online C Compiler

Run Code

Output

Memory is allocated
Memory is allocated
Memory is not allocated

In the above program, we use the library function, i.e., malloc(), to allocate the memory. We check whether the memory is allocated or not by check() function. As we see in the output, the pointer still points to the same memory location even after freeing the data. To avoid this, we set the pointer ptr to NULL.

You can practice by yourself with the help of an Online compiler.

Best Practices for NULL Pointer Usage

• Initialization: Always initialize pointers to NULL when declared.
• Error Handling: Use NULL pointers to check for errors in functions returning pointers, like memory allocation functions.
• Conditional Checks: Verify pointers against NULL before dereferencing to prevent segmentation faults.
• Dynamic Memory Allocation: Check for NULL after allocating memory dynamically to handle allocation failures gracefully.
• Clearing Pointers: Assign NULL after freeing memory to avoid dangling pointers and potential access violations.

Frequently Asked Questions

When is a Null pointer used in C?

Some uses of the null pointer are:

• To initialize a pointer variable.
• To avoid crashing down the program.
• To perform error handling.

Is 0 a null pointer in C?

No, in C, 0 is not explicitly defined as a null pointer. However, it is commonly used interchangeably with NULL, the null pointer constant, due to its equivalent representation in many contexts, though technically distinct.

What is the difference between a NULL and a Void Pointer?

The main difference between a Null pointer and a Void pointer is that a Null pointer is a NULL value assigned to any pointer type(data type), whereas a void pointer is a data type.

Conclusion

In the C programming language, A Null pointer is a pointer that is a variable with the value assigned as zero or having an address pointing to nothing. So we use the keyword NULL to assign a variable to be a Null pointer in C. It is a predefined macro. In this blog, we have extensively discussed the  Null pointer. 

Recommended reading: 

Data Structure