Pointers for Utility Functions

The Challenge: Modifying the Caller's Variables

Let's say we have two integer variables in main, a and b, and we want to write a function swap to exchange their values. A programmer new to C might first attempt this:

#include <stdio.h>

void swap_fail(int x, int y) {
    int temp = x;
    x = y;
    y = temp;
    printf("Inside swap_fail: x = %d, y = %d\n", x, y); // Values will be swapped here
}

int main() {
    int a = 10;
    int b = 20;
    printf("Before swap: a = %d, b = %d\n", a, b);
    swap_fail(a, b);
    printf("After swap: a = %d, b = %d\n", a, b); // But will they be swapped here?
    return 0;
}

What do you think the final output for a and b will be? The answer reveals the core nature of how C passes arguments to functions.

Why Pass-by-Value Fails for Swapping

The swap_fail function above will not work as intended. The values of a and b in main will remain unchanged. This is because C, by default, uses pass-by-value. When swap_fail(a, b) is called, the values of a and b are copied into new, separate local variables x and y within the swap_fail function's stack frame. The function successfully swaps its local copies, but these are destroyed when the function returns, having no effect on the original a and b in main.

The following video provides an excellent explanation of this process, visualizing the function call stack and making the distinction between local variables clear.

The Solution: Pass-by-Reference Using Pointers

As you've likely deduced, to modify a and b from within a function, we must pass their memory addresses. The function will accept these addresses into pointer variables. By dereferencing these pointers, the function can reach back into the caller's stack frame and manipulate the original variables. This mechanism is known as pass-by-reference.

Here is what the correct swap function looks like:

void swap(int *ptr_a, int *ptr_b) {
    int temp = *ptr_a;  // Get the value at the address ptr_a points to
    *ptr_a = *ptr_b;    // Set the value at ptr_a's address to the value at ptr_b's address
    *ptr_b = temp;      // Set the value at ptr_b's address to the stored temp value
}

To use it, the caller must pass the addresses of the variables: swap(&a, &b);.

Let's watch two short videos that walk through the implementation and then read a textual summary.

For a solid reference, the following article provides the C code and a clear explanation of how the pointer-based swap works.

The swap function is a building block in many algorithms, especially sorting algorithms like bubble sort or quicksort, where elements in an array must be exchanged in-place for efficiency. In your work with AUTOSAR and embedded systems, where performance and direct memory manipulation are critical, this pattern of modifying data in-place via pointers is ubiquitous.

Conclusion

This lesson concludes our module on the fundamental interactions between pointers and functions. The seemingly simple swap function perfectly encapsulates why these concepts are so deeply intertwined.

Key Takeaways:

• C uses pass-by-value, meaning functions receive copies of arguments. This prevents a function from directly modifying its caller's variables.
• To modify a caller's variables, you must simulate pass-by-reference by explicitly passing pointers (memory addresses) to them.
• The swap utility function is the classic example of this requirement: you must pass pointers to the variables you intend to swap. The function then uses the dereference operator (*) to access and change the values at those original addresses.

This marks a significant point in your journey. You now have a solid command of how pointers work with variables and functions that reside on the stack.

Preview of the Next Module:
In our next module, Dynamic Memory Management, we will shift our focus from the stack to the heap. You'll learn how to request, use, and release memory at runtime using malloc(), calloc(), realloc(), and free(). This will unlock the ability to create data structures, like dynamic arrays and linked lists, whose size is not known when you compile your program—a critical skill for any advanced C programmer.