Memory Units and Addresses

Computer systems organize RAM into discrete memory cells, each capable of storing one byte (8 bits) of data. Every cell receives a unique numerical identifier—much like apartment numbers in a building—that enables the CPU to locate and access specific data locations efficiently. In C programming terminology, these identifiers carry three interchangeable names: memory address, pointer, or simply address. When you declare a variable, the compiler allocates a specific memory region to hold its value, and the address operator (&) retrieves the starting location of that allocated space.

Address Operator and Pointer Variables

The address operator (&) yields the memory location of a variable as a numeric value. Consider that addresses appear in hexadecimal format, such as 0x7ffd8a3b4c2a. Since addresses represent meaningful data that programs frequently reference, C provides dedicated storage constructs called pointer variables. A pointer variable stores memory addresses, allowing programs to reference and manipulate data indirectly through their locations rather than their values directly.

#include <stdio.h>

int main()
{
    int value = 42;
    int* addressPtr = &value;
    return 0;
}

This example demonstrates how the address operator retrieves the memory location of value, which the pointer variable addressPtr subsequently stores. The asterisk (*) adjacent to int indicates that addressPtr represents a pointer storing integer addresses rather than an integer value itself.

Dereference Operator and Indirect Access

The dereference operator (*) enables access to the actual data stored at the memory location a pointer references. When applied to a pointer variable, this operator retrieves or modifies the value residing at the pointed-to address, effectively treating the pointer as an alias for the original variable.

#include <stdio.h>

int main()
{
    int original = 100;
    int* ptr = &original;
    *ptr = 200;
    printf("Original value: %d\n", original);
    return 0;
}

In this implementation, *ptr = 200 modifies the original variable indirectly. The pointer ptr contains original's address, and the dereference operator navigates to that location, replacing the stored value with 200. The printed output confirms this modification, displaying 200 instead of the initial value.

Pointer Sizes and Type Significance

Pointer variables occupy memory space proportional to address width. On 32-bit architectures, addresses span 32 bits (4 bytes), while 64-bit systems use 64-bit addresses (8 bytes). Consequently, pointer size varies between platforms—always 4 bytes on 32-bit systems and 8 bytes on 64-bit systems.

Although pointer storage requirements remain consistent regardless of the data type they reference, pointer types carry critical semantic meaning. The type determines two essential properties: the number of bytes accessed during dereference operations and the pointer arithmetic behavior. An int* pointer dereferences 4 consecutive bytes, while a char* accesses a single byte. When incrementing, an int* advances 4 bytes (the size of an integer), whereas a char* moves forward by only 1 byte.

#include <stdio.h>

int main()
{
    int target = 0x12345678;
    int* intPtr = &target;
    char* charPtr = (char*)&target;
    
    printf("Integer pointer dereference: %d\n", *intPtr);
    printf("First byte via char pointer: 0x%02x\n", *charPtr);
    return 0;
}

This example illustrates how the same memory location yields different interpretations based on pointer type. The integer pointer views the data as a complete 32-bit value, while the character pointer examines only the least significant byte.

Pointer Arithmetic

Adding or subtracting integers from pointers produces new addresses that maintain type alignment. When incrementing an int* pointer, the address advances by sizeof(int) bytes—typically 4 bytes on modern systems. Decrementing follows the same principle, shifting backward by the appropriate byte count.

Subtracting two pointers that reference elements within the same array yields the count of elements separating those positions. This operation requires both pointers to originate from the same memory block; otherwise, the result becomes undefined and potentially dangerous.

#include <stdio.h>

int main()
{
    int numbers[] = {10, 20, 30, 40, 50};
    int* first = &numbers[0];
    int* third = &numbers[2];
    
    printf("Address difference: %td elements\n", third - first);
    printf("Third element via pointer: %d\n", *third);
    printf("Moving first pointer: %d\n", *(first + 2));
    return 0;
}

The subtraction third - first yields 2, representing the element count between them. The expression *(first + 2) demonstrates pointer-offset notation, accessing the third array element (index 2) through arithmetic manipulation.

Special Pointer Types

Void Pointers

The void* type represents a generic pointer capable of holding addresses from any data type. This flexibility makes void* valuable for interfaces that must accommodate heterogeneous data types, such as memory allocation functions (malloc returns void*) and callback mechanisms. However, void* pointers impose restrictions: they cannot participate directly in pointer arithmetic or dereference operations without explicit type casting.

#include <stdio.h>
#include <stdlib.h>

void genericProcess(void* data, size_t size)
{
    unsigned char* byteStream = (unsigned char*)data;
    for (size_t i = 0; i < size; i++)
    {
        printf("Byte %zu: 0x%02x\n", i, byteStream[i]);
    }
}

int main()
{
    int value = 0xABCD;
    genericProcess(&value, sizeof(value));
    return 0;
}

This function accepts arbitrary memory regions and processes them byte-by-byte by casting the void* parameter to an unsigned char*, enabling byte-level inspection regardless of the original data type.

Const-Qualified Pointers

The const qualifier applied to pointers introduces immutable semantics at the pointer level, the pointed-to data, or both. Three distinct const configurations exist: pointers to constant data (data cannot change through the pointer), constant pointers (the address itself cannot change), and constant pointers to constant data (neither the address nor the data may change).

#include <stdio.h>

int main()
{
    int fixed = 500;
    
    // Pointer to constant: cannot modify value through ptr
    const int* ptr1 = &fixed;
    // Alternative syntax: int const* ptr1 = &fixed;
    
    // Constant pointer: cannot reassign to different address
    int* const ptr2 = &fixed;
    
    // Constant pointer to constant: neither can change
    const int* const ptr3 = &fixed;
    
    return 0;
}

However, const on pointed-to data provides only superficial protection. If the original variable remains mutable (without its own const qualification), a pointer—even one declared as pointing to const—can still modify the underlying value through type casting or pointer arithmetic that bypasses the const interface.

Wild Pointers

Wild pointers arise when variables contain indeterminate addresses—values that reference unpredictable or invalid memory regions. These pointers typically emerge from uninitialized declarations, where the pointer holds what ever garbage value resided in its allocated stack frame. Dereferencing wild pointers produces undefined behavior, potentially causing program crashes, memory corruption, or subtle security vulnerabilities.

Preventing wild pointers requires disciplined initialization practices. Always assign meaningful addresses before using pointers. If no valid address exists initially, initialize to NULL (defined as zero in pointer contexts), which creates a guaranteed invalid address that dereference operations will predictably reject.

#include <stdio.h>

int main()
{
    // Dangerous: uninitialized pointer
    int* dangerous;
    // Some platforms may crash on dereference, others may silently corrupt memory
    // *dangerous = 42; // UNDEFINED BEHAVIOR
    
    // Correct: initialize to NULL
    int* safe = NULL;
    
    // Validate before use
    if (safe != NULL)
    {
        *safe = 42;
    }
    else
    {
        printf("Pointer is null, cannot dereference\n");
    }
    
    return 0;
}

Additional wild pointer prevention strategies include avoiding out-of-bounds array access (which generates addresses beyond allocated memory), nullifying pointers immediately after freeing their associated memory, and abstaining from returning addresses of stack-allocated local variables that become invalid upon function exit.

Runtime Assertions with assert()

The <assert.h> header provides the assert() macro, which validates runtime conditions and terminates program execution upon detecting violations. During debugging, assertions serve as executable documentation, confirming that assumptions about program state hold true. When assertions fail, they output diagnostic information including the failing expression, source file name, and line number—facilitating rapid defect localization.

#include <stdio.h>
#include <assert.h>

void processMemory(void* buffer, size_t size)
{
    assert(buffer != NULL);
    assert(size > 0);
    
    printf("Processing %zu bytes at %p\n", size, buffer);
}

int main()
{
    void* validPtr = malloc(100);
    processMemory(validPtr, 100);
    
    void* nullPtr = NULL;
    // processMemory(nullPtr, 100); // Would trigger assertion failure
    
    free(validPtr);
    return 0;
}

The NDEBUG macro, when defined before including <assert.h>, disables all assertions in translation units—converting them to no-ops. This mechanism allows developers to enable comprehensive validation during development testing while eliminating assertion overhead in production releases. Debug builds typically include assertions by default, while optimized release builds exclude them for performance.

Practical Pointer Applications

Custom String Length Implementation

The standard library function strlen() computes string langth by counting characters preceding the null terminator. A custom implementation demonstrates pointer manipulation while respecting const correctness—ensuring the input string remains unmodified.

#include <stdio.h>
#include <assert.h>

size_t stringLength(const char* input)
{
    assert(input != NULL);
    
    const char* current = input;
    while (*current != '\0')
    {
        current++;
    }
    
    return (size_t)(current - input);
}

int main()
{
    char message[] = "Embedded systems";
    size_t len = stringLength(message);
    printf("Length of \"%s\": %zu\n", message, len);
    return 0;
}

The function traverses the string character by character, advancing the pointer until encountering the null terminator. The distance between the null terminator's position and the original address yields the character count.

Pass-by-Value versus Pass-by-Address

C exclusively employs pass-by-value semantics: function arguments receive copies of caller values, meaning modifications to parameters affect only local copies, leaving original caller variables unchanged. This behavior explains why naive swap implementations fail to modify caller variables.

#include <stdio.h>

void swapValues(int x, int y)
{
    int temporary = x;
    x = y;
    y = temporary;
}

int main()
{
    int alpha = 10;
    int beta = 20;
    
    printf("Before swap: alpha=%d, beta=%d\n", alpha, beta);
    swapValues(alpha, beta);
    printf("After swap: alpha=%d, beta=%d\n", alpha, beta);
    
    return 0;
}

The output reveals that both variables retain their original values: the function operated on copies. The alpha and beta variables inside swapValues() are independent allocations, disconnected from the caller's variables.

Pass-by-address enables genuine value exchange by providing functions with direct memory access to caller variables. Functions receive addresses as parameter values, then dereference those addresses to read or write the original storage locations.

#include <stdio.h>

void swapAddresses(int* left, int* right)
{
    int temporary = *left;
    *left = *right;
    *right = temporary;
}

int main()
{
    int first = 10;
    int second = 20;
    
    printf("Before swap: first=%d, second=%d\n", first, second);
    swapAddresses(&first, &second);
    printf("After swap: first=%d, second=%d\n", first, second);
    
    return 0;
}

This revised implementation passes addresses (&first, &second) rather than values. The function dereferences these addresses to exchange the actual values stored at those memory locations, producing the expected swap behavior visible in the output.

When designing functions, pass-by-value suits scenarios where functions only require input values for computation without modifying caller state. Conversely, functions intended to modify caller variables must receive addresses—enabling the indirect access pattern that C uses to simulate pass-by-reference semantics.