> ## 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 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.
```c theme={"dark"}
// 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.
```c theme={"dark"}
// 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.
```c theme={"dark"}
// These two function signatures are entirely equivalent to the C compiler
void processBuffer(int buffer[]);
void processBuffer(int *buffer);
```
Tired of Poor C Skills? Fix That With Deep Grasping!
Learn More
