Null Pointer Representation in C++: Evolution from 0, NULL to nullptr

Introduction and Historical Context

C++, as an extension of the C language, has undergone significant evolution in its null pointer representation. In early C++, NULL was defined as (void*)0, which meant it could only be assigned to void* pointers, limiting its utility. Consequently, developers commonly used the literal value 0 to represent null pointers, a practice widely accepted at the time.

Core Debate: 0 vs. NULL

According to Bjarne Stroustrup's perspective in the "C++ Style and Technique FAQ," in C++, NULL is defined as 0, so there is only an aesthetic difference between them. Stroustrup prefers to avoid macros and therefore recommends using 0. He notes that NULL can cause misunderstandings, leading people to incorrectly believe it differs from 0 or is not an integer type. Although improper definitions of NULL are less common in modern C++ code, historical issues still warrant attention.

From a practical coding perspective, using 0 as a null pointer allows for more concise conditional testing. For example:

if (p && !q) {
    do_something();
}

This approach relies on the implicit conversion of pointers in boolean contexts, where null pointers are treated as false. If using NULL, developers might need explicit comparisons: if (p != NULL && q == NULL), unless assuming NULL equals 0.

Arguments for Using NULL

Despite Stroustrup's recommendation for 0, other developers present arguments supporting NULL:

1. Intent Documentation: Using NULL clearly indicates the developer's intent to use a null pointer, rather than the integer value 0. This enhances code readability and maintainability.
2. Overload Issues: A common argument against NULL involves potential problems with function overloading:

void foo(int*);
void foo(int);

void bar() {
    foo(NULL);  // May call foo(int) instead of foo(int*)
}

However, proponents argue this is more a function design issue than a flaw in NULL itself.

C++11 and Modern Solution: nullptr

C++11 introduced the nullptr keyword and std::nullptr_t type, fundamentally addressing null pointer representation. nullptr is a true null pointer constant with a distinct pointer type, avoiding confusion with integers. Stroustrup explicitly states: "If you have to name the null pointer, call it nullptr."

For existing codebases, many implementations may redefine NULL as nullptr:

#define NULL nullptr

This allows code using NULL to automatically gain type safety improvements, while code using 0 requires manual updates.

Practical Recommendations and Code Examples

In modern C++ where RAII and exception handling are prevalent, raw pointer usage has decreased, but null pointers remain necessary. Here are some practical recommendations:

Legacy Code Maintenance: For legacy code, consistency is paramount. If a project has always used 0, continue doing so; if it uses NULL, maintain that practice.

New Project Development: In environments supporting C++11 and later, prioritize using nullptr. For example:

int* ptr = nullptr;
if (ptr == nullptr) {
    // Handle null pointer case
}

Type Safety Considerations: nullptr resolves overload resolution issues:

void process(int*);
void process(int);

int main() {
    process(nullptr);  // Clearly calls process(int*)
    process(0);       // Calls process(int)
    return 0;
}

Conclusion

Choosing between 0, NULL, and nullptr for null pointer representation involves considerations of historical compatibility, code clarity, and type safety. From a technological evolution perspective, nullptr represents the most advanced solution, offering optimal type safety and expressive clarity. For projects not yet adopting C++11, following Stroustrup's advice to use 0 may be the cleaner choice, while NULL offers advantages in intent expression. Ultimately, team consistency often outweighs personal preference, and establishing unified coding standards can significantly improve code quality.