> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ std::nullptr_t `std::nullptr_t` is the fundamental data type of the null pointer literal `nullptr`. Defined in the `` header, it serves as a distinct, standalone type that represents a null pointer constant, resolving the type ambiguity historically associated with the `NULL` macro or the integer literal `0`. ```cpp theme={"dark"} #include // The standard library conceptually defines it as: // using nullptr_t = decltype(nullptr); ``` ## Technical Properties **Type Classification** `std::nullptr_t` is classified as a scalar and fundamental type. However, it is strictly neither a pointer type nor a pointer-to-member type. It is a unique type specifically designed to bridge the gap between integer literals and pointer semantics. **Memory, Size, and Alignment** Instances of `std::nullptr_t` occupy memory. The C++ standard guarantees that its size is identical to that of a standard `void*`. However, the standard does not guarantee that the alignment requirement of `std::nullptr_t` is identical to that of `void*`. ```cpp theme={"dark"} #include static_assert(sizeof(std::nullptr_t) == sizeof(void*)); // Note: alignof(std::nullptr_t) == alignof(void*) is NOT guaranteed ``` **Conversion Rules** The compiler enforces strict conversion rules for `std::nullptr_t` to ensure type safety: * **Pointers:** Implicitly convertible to any raw pointer type (`T*`) or pointer-to-member type (`T U::*`). The result is a null pointer value of the target type. * **Booleans:** Contextually convertible to `bool` (e.g., within conditional statements) and permitted via direct-initialization. The conversion always evaluates to `false`. Implicit conversion (copy-initialization) to `bool` is explicitly ill-formed to prevent unintended type coercions. * **Integers:** Ill-formed. `std::nullptr_t` cannot be implicitly converted to integral types (e.g., `int`, `size_t`). This prevents accidental pointer-to-integer arithmetic or narrowing conversions. ```cpp theme={"dark"} struct MyClass {}; std::nullptr_t null_val = nullptr; int* ptr = null_val; // Valid: Implicit conversion to T* void (MyClass::*m_ptr)() = null_val; // Valid: Implicit conversion to pointer-to-member bool b1{null_val}; // Valid: Direct-initialization (evaluates to false) if (null_val) {} // Valid: Contextual conversion to bool // bool b2 = null_val; // Error: Copy-initialization is ill-formed // int x = null_val; // Error: No conversion to integral types ``` ## Type Traits Integration The standard library provides specific type traits in the `` header to identify and evaluate `std::nullptr_t` at compile time. Because it is not a standard pointer, it fails `std::is_pointer` checks but passes its own dedicated trait. ```cpp theme={"dark"} #include #include static_assert(std::is_null_pointer_v); static_assert(std::is_scalar_v); static_assert(std::is_fundamental_v); // Note: It is NOT considered a pointer or an integer by the type system static_assert(!std::is_pointer_v); static_assert(!std::is_integral_v); ``` ## Equality and Comparison The C++ standard defines strict rules for comparing `std::nullptr_t` operands: * **Equality (`==`, `!=`):** Comparing two `std::nullptr_t` objects is well-formed and always evaluates as equal. Comparing a `std::nullptr_t` object with any valid pointer type is well-formed and evaluates whether the pointer is null. * **Three-Way Comparison (`<=>`) (C++20):** The standard provides a built-in operator `operator<=>(std::nullptr_t, std::nullptr_t)` which always yields `std::strong_ordering::equal`. * **Relational Comparison (`<`, `<=`, `>`, `>=`):** * **Between two `std::nullptr_t` objects:** Prior to C++20, relational comparisons between `std::nullptr_t` operands were ill-formed because `std::nullptr_t` is not an arithmetic, enumeration, or pointer type. C++20 made these comparisons well-formed for the first time by introducing the built-in `<=>` operator and resolving the relational operators via rewritten candidates (e.g., `nullptr < nullptr` becomes `(nullptr <=> nullptr) < 0`). Strict comparisons (`<`, `>`) evaluate to `false`, while non-strict comparisons (`<=`, `>=`) evaluate to `true`. * **Between `std::nullptr_t` and a pointer type:** **Ill-formed**. The standard explicitly prohibits ordering comparisons between pointers and null pointer constants, as null pointers do not possess a strict weak ordering relative to valid memory addresses.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More