> ## 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 is a special pointer value guaranteed not to point to any valid object or function in memory. It serves as a sentinel value at the language level, representing an uninitialized or intentionally empty memory address state. In C, a null pointer is created by assigning a **null pointer constant** to a pointer variable. The C standard defines a null pointer constant as any integer constant expression with the value `0`, or such an expression cast to type `void *`. Valid source code representations include `0`, `0L`, `0x00`, `'\0'`, `(1 - 1)`, or the standard macro `NULL`. ```c theme={"dark"} #include /* The NULL macro is provided by stddef.h and other standard headers. Internally, it is typically defined by the implementation as: #define NULL ((void *)0) or simply: #define NULL 0 */ int *int_ptr = NULL; /* Initialized using the standard macro */ char *char_ptr = 0; /* Implicit conversion from the integer 0 */ double *dbl_ptr = (1 - 1); /* Evaluates to 0, valid null pointer constant */ ``` ## The C23 `nullptr` Keyword To resolve type ambiguity and safety issues associated with the traditional `NULL` macro (which may evaluate to an integer type rather than a pointer), the C23 standard introduced the `nullptr` keyword and the `nullptr_t` type. `nullptr` is a dedicated null pointer constant of type `nullptr_t` that implicitly converts to any pointer type but does not implicitly convert to integer types (except `bool`). ```c theme={"dark"} #include int *ptr = nullptr; /* C23 standard: strictly typed null pointer */ nullptr_t np = nullptr; /* Base type of the nullptr constant */ ``` ## Technical Characteristics **Memory Representation** While a null pointer is represented in source code by an integer constant expression evaluating to zero (or `nullptr`), the underlying hardware bit-pattern is implementation-defined. The compiler translates the null pointer constant into the architecture's specific null memory address. Although almost universally represented by all zero bits at the hardware level, the C standard does not strictly mandate this. **Type Equivalence and Comparison** A null pointer of one type is guaranteed to compare equal to a null pointer of any other type. When a null pointer constant is assigned to or compared with a pointer of a specific type, it is implicitly converted to a null pointer of that target type. A null pointer is also guaranteed to compare unequal to any pointer to a valid object or function. ```c theme={"dark"} int *ptr_a = NULL; void *ptr_b = NULL; /* Valid comparison: Evaluates to true without explicit casting */ if (ptr_a == ptr_b) { /* Both are null pointers */ } /* Boolean evaluation: A null pointer evaluates to false (0) */ if (!ptr_a) { /* Executes because ptr_a is null */ } ``` **Variadic Functions and `NULL`** Passing the traditional `NULL` macro to a variadic function (such as `printf` or `execl`) without an explicit cast invokes **Undefined Behavior**. Because `NULL` can be defined simply as the integer `0`, the compiler may push an integer onto the call stack instead of a pointer. If the variadic function expects a pointer, this type mismatch corrupts the stack or reads invalid data. ```c theme={"dark"} #include /* UNDEFINED BEHAVIOR: NULL may be passed as a 32-bit int, but %p expects a pointer (potentially 64-bit) */ printf("Pointer: %p\n", NULL); /* CORRECT: Explicit cast ensures a pointer type is passed */ printf("Pointer: %p\n", (void *)NULL); /* CORRECT (C23): nullptr inherently passes as a pointer type */ printf("Pointer: %p\n", nullptr); ``` **Dereferencing and Undefined Behavior** Because a null pointer does not resolve to a valid memory location, attempting to dereference it (accessing or modifying the value it points to) invokes **Undefined Behavior (UB)**. ```c theme={"dark"} int *ptr = NULL; int val = *ptr; /* UNDEFINED BEHAVIOR: Attempting to read from a null address */ *ptr = 10; /* UNDEFINED BEHAVIOR: Attempting to write to a null address */ ``` On modern operating systems with virtual memory management, dereferencing a null pointer typically results in a hardware exception, such as a Segmentation Fault (SIGSEGV). This occurs because the zero page of virtual memory is intentionally left unmapped by the OS to trap these exact memory access violations. **Pointer Arithmetic** Performing pointer arithmetic on a null pointer is strictly undefined behavior in C. ```c theme={"dark"} int *ptr = NULL; ptr++; /* UNDEFINED BEHAVIOR: Arithmetic on a null pointer */ ``` The C standard dictates that pointer arithmetic is only valid when the pointer points to an element of an array object (or one past the last element). Since a null pointer points to no object, any arithmetic operation violates this constraint.
Tired of Poor C Skills? Fix That With Deep Grasping! Learn More