Raw Pointers, Dereferencing, and Typed Address Arithmetic

01Pointers as 64-Bit Memory Addresses

In modern 64-bit C++, a raw pointer is nothing more than an 8-byte unsigned integer value whose bits represent an address in the process's virtual memory space. Regardless of whether a pointer points to a 1-byte char, a 4-byte int, or a 1024-byte struct, sizeof(ptr) is universally 8 bytes on 64-bit architectures.

The address-of operator (&) extracts the memory location of an existing variable. The dereference operator (*) instructs the CPU to load or store the data residing at that memory address. Dereferencing an uninitialized pointer (wild pointer), a dangling pointer (pointing to freed memory), or a NULL/nullptr pointer results in undefined behavior (UB) and operating system segmentation faults.

Modern C++ deprecates the C-style NULL macro (which was merely an untyped 0) in favor of nullptr, a strongly typed keyword of type std::nullptr_t that prevents ambiguous overload resolutions between integers and pointers.

02Pointer Arithmetic and Type Scaling

Pointer arithmetic does not behave like standard scalar integer addition. When you add an integer offset n to a typed pointer T* p (e.g., p + 1), the memory address increases not by n bytes, but by n * sizeof(T) bytes!

For example, if int* p points to address 0x1000 (where sizeof(int) == 4): evaluating p + 1 advances the pointer to 0x1004. Evaluating p + 5 advances the pointer to 0x1000 + (5 * 4) = 0x1014. If double* dp points to 0x2000 (sizeof(double) == 8), evaluating dp + 2 advances to 0x2010.

This scaling rule ensures that pointer arithmetic seamlessly steps across contiguous elements in arrays. Subtracting two pointers (ptr2 - ptr1) yields an integer of type ptrdiff_t representing the exact count of elements between them.

03Void Pointers and Raw Byte Buffers

A void* pointer represents a generic memory address with no associated type information. Because the compiler does not know the size of the underlying data (sizeof(void) is invalid in standard C++), a void* cannot be directly dereferenced and arithmetic cannot be performed on it without casting.

Systems software—such as custom memory allocators, network serialization engines, and hardware drivers—uses void* or std::byte* to handle raw, untyped memory buffers. Converting between void* and concrete typed pointers is performed via static_cast or reinterpret_cast.

04Pointer Arithmetic Trace Table

Let us trace address jumps across different types starting from a base address of 0x1000:

Understanding pointer scaling is foundational for writing custom buffers, matrix strides, and fast memory copies.

+------------+-----------+--------------------+-------------------------+| Type T     | sizeof(T) | Expression (p = 0) | Resulting Byte Address  |+------------+-----------+--------------------+-------------------------+| char       | 1 byte    | p + 4              | 0x1000 + 4 = 0x1004     || short      | 2 bytes   | p + 4              | 0x1000 + 8 = 0x1008     || int        | 4 bytes   | p + 4              | 0x1000 + 16 = 0x1010    || double     | 8 bytes   | p + 4              | 0x1000 + 32 = 0x1020    || struct Vec3| 24 bytes  | p + 2              | 0x1000 + 48 = 0x1030    |+------------+-----------+--------------------+-------------------------+