PREV_LEC NEXT_LEC

Prerequisites

You should know how to declare a pointer, take an address with &, and dereference with *. You should also have read the previous lecture on dangling pointers, because the lifetime rules there explain why callee variables vanish after the return.

Call by Value in C Explained

When you call a function, C copies each argument into a new variable owned by the callee. Change that copy and the caller’s original stays untouched. This holds for integers, structs and pointers alike. A pointer parameter is simply a variable that happens to contain an address.

The Confusing Swap: Why *(&x) Changes Nothing

A common exam trick writes the swap body using the pattern *(&x) and *(&y), hoping the address operator makes the change reach the caller. It does not. The address of a parameter is the address of the callee’s copy, and *(&x) simply gives that copy back. Writing *(&x) = value is exactly the same as x = value. The function swaps its private copies, returns, and the caller sees the original numbers.

Advancing a Pointer: One Level Is Not Enough

The second classic puzzle has two helpers. One takes int * and increments it. The other takes int ** and increments *pptr. Only the second changes the caller’s pointer. The first increments its private copy of the address and discards it. The same rule applies one level up: to change a pointer, pass the address of the pointer.

Both ideas appear in this single program. Save it as ep_ptr_params.c:

#include <stdio.h>

static void swap_copy(int x, int y)
{
    int t = x;
    x = y;
    y = t;
}

static void swap_addr(int *x, int *y)
{
    int t = *x;
    *x = *y;
    *y = t;
}

static void skip_copy(const char *cursor)
{
    cursor += 3;                 /* moves only the local copy */
}

static void skip_addr(const char **cursor)
{
    *cursor += 3;                /* moves the caller's pointer */
}

int main(void)
{
    int gain = 5, offset = 8;

    swap_copy(gain, offset);
    printf("after swap_copy: gain=%d offset=%d\n", gain, offset);
    swap_addr(&gain, &offset);
    printf("after swap_addr: gain=%d offset=%d\n", gain, offset);

    const char frame[] = "HDR:payload";
    const char *cur = frame;

    skip_copy(cur);
    printf("after skip_copy: index %td -> %s\n", cur - frame, cur);
    skip_addr(&cur);
    printf("after skip_addr: index %td -> %s\n", cur - frame, cur);
    return 0;
}

Build and Run

$ gcc -Wall -Wextra -std=c11 -o ep_ptr_params ep_ptr_params.c
$ ./ep_ptr_params
after swap_copy: gain=5 offset=8
after swap_addr: gain=8 offset=5
after skip_copy: index 0 -> HDR:payload
after skip_addr: index 3 -> :payload

Notice that we print the cursor position as an index, cur - frame, instead of the raw address. That output is identical on every machine, while a printed address would change between runs and platforms.

Pointer Parameter Styles Compared

Real-World Uses in Embedded Code

• Out parameters for status. Many HAL functions return an error code and write the actual reading through a pointer, for example hal_adc_read(chan, &value).
• Protocol parsers. A parser takes const uint8_t **cursor and advances it past each field so the next call continues where the last stopped. This is the same shape as skip_addr above.
• Ring buffers. Functions receive a pointer to the buffer struct and update head and tail indices inside it.
• Passing large structs. Copying a 200-byte config struct to a callee costs stack and cycles on a small MCU, so you pass const config_t *.

Common Mistakes and Troubleshooting

Best Practices

• Use const on every pointer parameter you only read.
• Prefer returning a value when there is only one result. Use out parameters when you need several.
• Give out parameters a clear name such as out_value or p_status.
• Check for NULL at module boundaries, and nowhere else if your interface documents the contract.
• For parsers, return the new cursor or use a small context struct instead of nesting more than two levels of stars.

Performance and Security Considerations

Passing a pointer is a single register on most architectures, so it is cheaper than copying any struct larger than a word or two. Security-wise, every pointer parameter is an input you must trust or validate. Parsers that advance a cursor must also track the end of the buffer, or a malformed frame will walk the pointer past it.

Suggested Images

Summary and Key Takeaways

Conclusion

Once you accept that a pointer parameter is just another copied variable, the confusing exercises stop being confusing. Ask two questions at every call: what is being copied, and what does that copy point to? Those two answers tell you exactly what the callee can and cannot change. Next we look at what happens when the thing you pass is an array.

FAQ: Pointer Parameters in C

PREV_LEC NEXT_LEC