Pointer Parameter

A pointer parameter in C is a function argument that accepts a memory address rather than a direct data value. By passing a pointer, the function receives a reference to the original variable’s location in memory, enabling direct manipulation of the caller’s data and avoiding the overhead of copying large data structures.

Under the hood, C strictly employs pass-by-value semantics. When a pointer is passed as a parameter, the function receives a local, independent copy of the memory address. Modifying the pointer variable itself within the function does not affect the original pointer in the calling scope. However, applying the indirection operator (*) to the pointer allows the function to mutate the data residing at that specific memory address.

// Function declaration with a pointer parameter
void mutateData(int *ptr);

int main() {
    int target = 10;
    
    // The address-of operator (&) yields the memory address of 'target'
    mutateData(&target); 
    
    return 0;
}

void mutateData(int *ptr) {
    // Dereferencing 'ptr' accesses the memory location of 'target'
    *ptr = 20; 
}

Memory Model Behavior

When a function with a pointer parameter is invoked:

1. A new stack frame is allocated for the called function.
2. The pointer parameter (e.g., ptr) is instantiated as a local variable within this new stack frame.
3. The value assigned to ptr is the raw memory address of the argument passed by the caller.
4. Any dereference operation (*ptr) resolves this address, crossing stack frame boundaries to read or write to the caller’s original memory location.

Const Qualifiers in Pointer Parameters

Pointer parameters frequently utilize the const qualifier to enforce strict memory access controls at compile-time. The placement of the const keyword relative to the asterisk (*) dictates the mutability of the pointer and the underlying data.

// 1. Pointer to constant data: 
// The function can change where 'ptr' points, but cannot modify the data at that address.
void readOnlyData(const int *ptr);

// 2. Constant pointer to mutable data: 
// The function can modify the data, but 'ptr' must always point to the initial address.
void fixedPointer(int * const ptr);

// 3. Constant pointer to constant data: 
// Neither the memory address held by 'ptr' nor the underlying data can be modified.
void strictlyReadOnly(const int * const ptr);

Array Decay

In C function signatures, array parameters automatically decay into pointers to their first element. The compiler treats an array declaration in a parameter list as syntactically and semantically identical to a pointer declaration. Because of this decay, the sizeof operator applied to an array parameter will yield the size of the pointer, not the size of the original array.

// These two function signatures are entirely equivalent to the C compiler
void processBuffer(int buffer[]);
void processBuffer(int *buffer);

Master C with Deep Grasping Methodology!

Learn More