> ## 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++ Null Pointer A null pointer in C++ is a pointer variable that explicitly points to no valid memory address or object. It represents an uninitialized, empty, or sentinel state within pointer semantics, ensuring that memory operations are not inadvertently performed on arbitrary or garbage memory addresses. Introduced in C++11, the `nullptr` keyword is the standard, type-safe method for representing a null pointer constant. It is a prvalue of type `std::nullptr_t`. ```cpp theme={"dark"} class MyClass {}; int* ptr = nullptr; // Pointer to an integer, initialized to null MyClass* obj = nullptr; // Pointer to a custom object, initialized to null ``` ## Type Safety and `std::nullptr_t` Unlike legacy null pointer constants, `nullptr` is not an integer. Its type, `std::nullptr_t` (defined in the `` header), is implicitly convertible to any raw pointer type or pointer-to-member type. However, it cannot be implicitly converted to integral types. This strict typing resolves function overloading ambiguities inherent in older C++ standards. ```cpp theme={"dark"} #include void allocate(int size); void allocate(int* memory_location); void resolve_overload() { allocate(nullptr); // Unambiguously calls allocate(int* memory_location) } ``` ## Legacy Null Pointer Constants (`0` and `NULL`) Prior to C++11, null pointers were initialized using the integer literal `0` or the `NULL` macro. In C++, `NULL` is typically defined as the integer `0` rather than `(void*)0` (as it is in C). This is because C++ enforces strict type checking and does not allow implicit conversions from `void*` to other specific pointer types. ```cpp theme={"dark"} #include int* legacyPtr1 = 0; // Valid, but lacks type safety int* legacyPtr2 = NULL; // Macro expanding to 0, prone to overload resolution errors ``` Using `0` or `NULL` is now considered an anti-pattern in modern C++ because the compiler treats them as integers first and pointers second, which breaks type safety during template deduction and function overload resolution. ## Memory Representation and Boolean Evaluation At the hardware level, a null pointer is typically represented by a bit pattern of all zeros (e.g., `0x0000000000000000` on a 64-bit architecture). However, the C++ standard abstracts this, only mandating that a null pointer evaluates to `false` in a boolean context and compares equal to any other null pointer of the same type. ```cpp theme={"dark"} void evaluate_null() { int* ptr = nullptr; if (!ptr) { // Evaluates to true; the pointer is null } if (ptr == nullptr) { // Explicit comparison, evaluates to true } } ``` ## Deallocation Semantics Calling the `delete` or `delete[]` operators on a null pointer is entirely safe and guaranteed by the C++ standard to perform no operation (a no-op). Because the memory management subsystem explicitly handles null pointers during deallocation, writing a conditional check before deleting a pointer is a recognized anti-pattern. ```cpp theme={"dark"} void deallocate_anti_pattern(int* ptr) { // Anti-pattern: Redundant null check if (ptr != nullptr) { delete ptr; } } void deallocate_idiomatic(int* ptr, int* array_ptr) { // Correct, idiomatic C++: delete safely ignores null pointers delete ptr; delete[] array_ptr; } ``` ## Dereferencing Mechanics Attempting to dereference a null pointer results in undefined behavior (UB). Because the pointer holds no valid memory address, the hardware's memory management unit (MMU) cannot map the address to physical memory. The operating system typically intercepts this illegal memory access, resulting in a segmentation fault (SIGSEGV) on POSIX systems or an Access Violation on Windows. ```cpp theme={"dark"} void dereference_pointer() { int* ptr = nullptr; // Valid C++ syntax, but causes Undefined Behavior (access violation) at runtime // int value = *ptr; } ```

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