Memory addresses serve as the foundation of C programming, enabling direct hardware interaction and efficient resource management. An address variable, commonly referred to as a pointer, stores memory locations rather than data values, establishing a layer of indirection between storage and access.

Declaration and Initialization

Creating an address variable requires the asterisk symbol to denote indirection:

float* velocity;

This establishes velocity as a variable capable of holding the location of a floating-point value. To capture an actual memory location, apply the address-of operator to an existing variable:

float speed = 88.5f;
float* velocity = &speed;

Retrieving the value stored at that location—dereferencing—uses the same asterisk notation:

float current = *velocity;  // current contains 88.5

Dynamic Storage Management

Heap allocation relies entirely on address variables to track reserved memory blocks. The malloc function returns a void pointer that requires casting to the appropriate type:

size_t capacity = 10;
double* dataset = (double*)malloc(capacity * sizeof(double));

Always verify the allocation succeeded before dereferencing, and release the memory with free when operations conclude.

Array Decay and Arithmetic

Array identifiers implicitly convert to pointers pointing to their initial element. This relationship enables arithmetic navigation through contiguous memory:

int sequence[] = {10, 20, 30, 40};
int* cursor = sequence;

cursor++;        // Advances to sequence[1]
int second = *cursor;  // Retrieves 20

The compiler automatically scales pointer arithmetic by the size of the referenced type, ensuring proper byte offset calculation.

Parameter Passing by Reference

Address variables enable functions to modify caller-scope data without global variables. Implementing a value exchange illustrates this pattern:

void exchange(int* alpha, int* beta) {
    int temporary = *alpha;
    *alpha = *beta;
    *beta = temporary;
}

int main(void) {
    int x = 5, y = 10;
    exchange(&x, &y);
    // x now holds 10, y holds 5
    return 0;
}

Multiple Levels of Indirection

Pointers can reference other pointers, creating chains of indirection useful for dynamic data structures:

int base = 100;
int* direct = &base;
int** indirect = &direct;
int*** meta = &indirect;

int final = ***meta;  // Retrieves 100

Each additional asterisk in the declaration increases the depth of indirection, requiring corresponding dereferencing operations to reach the underlying value.

Composite Structure Access

When working with aggregate types, the arrow operator provides concise member access through pointers:

typedef struct {
    char identifier[32];
    unsigned int priority;
} Task;

Task current;
Task* handle = &current;

// Equivalent access methods
(*handle).priority = 1;
handle->priority = 1;  // Preferred syntax

Arrays of Pointers and Pointer Arrays

A collection of address variables—commonly used for string tables or jagged arrays—declares as:

const char* labels[] = {
    "Pending",
    "Processing", 
    "Complete"
};

Contrast this with a pointer to an entire array block:

int matrix[3][3];
int (*grid_pointer)[3] = matrix;

The parentheses modify precedence, declaring grid_pointer as a reference to an array of three integers rather than an array of three references.

Function Dispatch Tables

Address variables can reference executable code, enabling runtime polymorphism and callback mechanisms:

int multiply(int a, int b) {
    return a * b;
}

int (*operation)(int, int) = multiply;
int product = operation(6, 7);  // Invokes multiply, yields 42

These function pointers facilitate strategy patterns and event-driven architectures where the specific implementation resolves dynamically.

Type Safety and Casting

Occasionally, raw memory requires reinterpretation under different types. Explicit casting converts between pointer types, though potentially violating strict aliasing rules:

unsigned long raw = 0xDEADBEEF;
unsigned char* bytes = (unsigned char*)&raw;

// Inspects individual bytes of the integer
unsigned char first_byte = bytes[0];

Void pointers (void*) provide generic storage but require casting before dereferencing, serving as the foundation for generic algorithms and container implementations.