nullptr

nullptr is the null pointer literal in C++11 and later. It is a keyword that denotes a null pointer value and is the preferred way to represent “no object” for pointer types. The type of the nullptr literal is std::nullptr_t, a distinct type defined by the language, and the value is the sole instance of that type.

Semantics and usage: nullptr is implicitly convertible to any pointer type and to any pointer-to-member type, enabling safe assignment and comparison without ambiguity. It is not meant to be used as an integer; there is no implicit conversion from std::nullptr_t to integral or arithmetic types. Because its type is distinct, overload resolution can distinguish between pointer overloads and non-pointer overloads, reducing common errors that arise when using 0 or the NULL macro.

Differences from older null representations: Prior to C++11, programmers commonly used 0 or the NULL macro to represent null pointers. These could lead to surprising behavior in overload resolution and template code, since 0 is an integer and NULL might be defined as an integer or a macro expanding to 0. nullptr removes these ambiguities by providing a type-safe, unambiguous null pointer literal.

Standard definitions and availability: nullptr is a core language feature and is available in the C++ standard library via the type std::nullptr_t, defined in header <cstddef>. It is a compile-time constant expression and remains valid across modern C++ implementations.

Example:

int* p = nullptr;

if (p == nullptr) { /* ... */ }

void f(int*);

void f(int);

f(nullptr); // selects f(int*) over f(int)

Overall, nullptr improves safety and clarity in pointer-related code, and is now widely adopted as the standard way to represent a null pointer in C++.