NULL Pointer in C++

A NULL Pointer in C++ indicates the absence of a valid memory address in C++. It tells that the pointer is not pointing to any valid memory location In other words, it has the value “NULL” (or ‘nullptr’ since C++11). This is generally done at the time of variable declaration to check whether the pointer points to some valid memory address or not. It is also returned by several inbuilt functions as a failure response.

Trying to dereference a NULL pointer i.e. trying to access the memory it points to leads to some undefined behavior leading to the program crash.

Syntax of Null Pointer in C++

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; // by assigning the value 0

A null pointer is represented by the value 0 or by using the keyword NULL. With the new versions of C++ like C++11 and later, we can use “nullptr” to indicate a null pointer.

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 Pointer finds its applications in the following scenarios:

1. 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.
2. Default Values: Null pointers act as default or initial values for pointers when no valid address is assigned to the pointers.
3. Error Handling: They are useful in error conditions or to signify the absence of data that enables better handling of exceptional cases.
4. 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.
5. 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.

Example of NULL Pointer in C++

The below example demonstrates the dereferencing and assignment of a null pointer to another value.

C++

// C++ program to demonstrate the dereferencing and
// assignment of null pointer to another value.

#include <iostream>
using namespace std;

int main()
{
    int* ptr = nullptr;

    // Checking if the pointer is null before dereferencing
    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: In the example given above first the pointer is pointing to a null value. First, we check whether the pointer is pointing to a null value or not before dereferencing it to avoid any kind of runtime error. Then we assign the pointer a valid memory address and then check it before dereferencing it. As the pointer is not pointing to a null value, the else part is executed.

Disadvantages of NULL Pointers in C++

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.

Conclusion

It is important to understand null pointers in C++ to handle pointers safely and prevent unexpected runtime errors. They signify the absence of valid memory addresses and help in error handling and pointer initialization. Proper usage and precautions regarding null pointers are essential in writing error-free C++ code.