NULL Pointer in C++

Last Updated : 8 Jun, 2026

A NULL pointer in C++ represents a pointer that does not refer to any valid memory address.

  • It indicates that the pointer is intentionally set to point to nothing and holds the value NULL (or nullptr in C++11 and later).
  • It is commonly used during variable declaration to show that a pointer is not yet associated with any memory, and it is also returned by many built-in functions to indicate a failure condition.
  • Attempting to dereference a NULL pointer results in undefined behavior and may cause the program to crash.
C++
#include <iostream>
using namespace std;

int main(){
    int* ptr = nullptr;

    if (ptr == nullptr) {
        cout << "Pointer is currently null." << endl;
    }
    else {
        cout << "Pointer is not null." << endl;
    }

    // *ptr = 10; (to avoid runtime error)
    // Assigning a valid memory address to the pointer
    int value = 5;
    ptr = &value;
    
    // Checking if the pointer is null after assigning a
    // valid address
    if (ptr == nullptr) {
        cout << "Pointer is currently null." << endl;
    }
    else {
        cout << "Pointer is not null." << endl;
        cout << "Value at the memory location pointed to "
                "by the pointer: "
             << *ptr << endl;
    }

    return 0;
}

Output
Pointer is currently null.
Pointer is not null.
Value at the memory location pointed to by the pointer: 5

Explanation:

  • First, the pointer is set to a NULL value.
  • The program checks whether the pointer is NULL before dereferencing it to avoid runtime errors.
  • Then a valid memory address is assigned to the pointer.
  • The pointer is checked again before dereferencing.
  • Since the pointer is no longer NULL, the else part is executed.

Syntax

We can create a NULL pointer of any type by simply assigning the value NULL to the pointer as shown:

int* ptrName = NULL; // before C++11
int* ptrName = nullptr;
int* ptrName = 0; // using the null pointer constant 0

A null pointer can be initialized using the null pointer constants 0, NULL, or (since C++11) nullptr. In modern C++, nullptr is the preferred way to represent a null pointer because it is type-safe.

Checking NULL Pointer

We can check whether a pointer is a NULL pointer by using the equality comparison operator.

ptrName == NULL
or
ptrName == nullptr

The above expression will return true if the pointer is a NULL pointer. False otherwise.

Applications of Null Pointer in C++

Null pointers serve several important purposes in C++, from safe initialization of pointers to error handling and resource management.

  • Initialization: It is a good practice to Initialize pointers to a null value as it helps avoid undefined behavior by explicitly indicating they are not pointing to valid memory locations.
  • Default Values: Null pointers act as default or initial values for pointers when no valid address is assigned to the pointers.
  • Error Handling: They are useful in error conditions or to signify the absence of data that enables better handling of exceptional cases.
  • Resource Release: To release the resources, like the destructor of a class, or to set pointers to NULL after deletion we can use a null pointer to avoid accidentally using or accessing the released memory.
  • Sentinel Values: A null pointer can be used to indicate the end of a data structure or a list like in the linked list last node has a null pointer as the next field.

Issues with NULL

NULL pointer makes it possible to check for pointer errors but it also has its limitations:

  • Dereferencing a NULL pointer causes undefined behavior that may lead to runtime errors like segmentation faults.
  • We need to check explicitly for NULL pointers before dereferencing it to avoid undefined behavior.
Comment

Explore