Modifying Caller Variables with Pointers

The Problem: Why Functions Can't Normally Modify Their Arguments

By default, when you pass a variable to a function in C, you are passing a copy of its value. The function works on this local copy, and any changes it makes are discarded when the function returns. The original variable in the calling function remains completely untouched. This mechanism is known as pass-by-value.

Let's see a classic example of this in action. The following video provides an excellent illustration of an increment function that doesn't work as expected due to pass-by-value semantics. It then visualizes the underlying memory behavior using stack frames, which will build on your existing knowledge of C's memory model.

As the video explains, each function call gets its own "stack frame"—a private area of memory for its local variables and parameters. The increment function was only modifying the value in its own stack frame, which is destroyed upon function exit.

The Solution: Passing Pointers

To allow a function to modify a variable in its caller's scope, we don't pass the variable's value; we pass its address. The function then receives a pointer to the original variable. By dereferencing this pointer, the function can reach back into the caller's stack frame and modify the original data. This is often called "pass-by-reference" or, more accurately in C, pass-by-pointer.

Here are the three essential steps:

1. Define the function parameter as a pointer: The function signature must declare the parameter as a pointer to the correct data type (e.g., void func(int *p)).
2. Pass the address as the argument: When calling the function, use the address-of operator (&) to pass the memory address of the variable (e.g., func(&my_var)).
3. Dereference the pointer in the function: Inside the function, use the dereference operator (*) to access and modify the value at the stored address (e.g., *p = 100;).

Now, watch the final part of the same video to see this solution implemented.

The image below provides a complete, static view of this entire process, showing the C code, the corresponding memory layout, and the final output.

A Crucial Clarification: C is Always Pass-by-Value

It's important to be precise: C does not have true pass-by-reference like C++. C is always a pass-by-value language.

When we pass a pointer to a function, we are passing the value of the pointer (the memory address) by value. This means the function receives a copy of the memory address. While changing the pointer parameter itself inside the function (e.g., making it point to a different address) won't affect the original pointer in the caller, using the copied address to dereference allows modification of the data at that address.

The following resource explains this subtle but important distinction and provides a clean, step-by-step guide to implementing the pass-by-pointer pattern.

#include <stdio.h>

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10;
    int y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(x, y);
    printf("After swap: x = %d, y = %d\n", x, y); // This will show x and y are unchanged
    return 0;
}

#include <stdio.h>

// 1. Change parameters to pointers
void swap(int *a, int *b) {
    // 3. Dereference pointers to access the original values
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10;
    int y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    // 2. Pass the addresses of the variables
    swap(&x, &y); 
    
    printf("After swap: x = %d, y = %d\n", x, y); // Correctly prints x = 20, y = 10
    return 0;
}

Application: Modifying Complex Data in Place

This technique is not just for simple types like int. In your work with AUTOSAR, you frequently deal with complex struct types for message payloads or component configurations. Passing a pointer to a large struct is far more efficient than passing it by value, which would require copying the entire structure onto the stack.

When you have a pointer to a struct, you can access its members using the arrow operator (->). This operator is simply syntactic sugar for dereferencing the pointer and then accessing the member.
st_ptr->age is equivalent to (*st_ptr).age.

The following resource demonstrates passing a pointer to a struct to a function.

To make the modification aspect explicit, imagine the show_name function from the example also needed to update the employee's age:

void show_name_and_increment_age(struct tag *p) {
    printf("\n%s ", p->fname); 
    printf("%s, ", p->lname);
    printf("Age: %d\n", p->age);

    // Modify the original structure's data through the pointer
    p->age++; 
}

Calling show_name_and_increment_age(st_ptr) would now permanently increment the age in the my_struct variable located in the main function.

Conclusion

You have now mastered one of the most fundamental and powerful idioms in C programming. By understanding the default pass-by-value mechanism and how to overcome its limitations with pointers, you can write functions that efficiently modify data anywhere in your program.

Key Takeaways:

• By default, C passes arguments by value, meaning functions operate on local copies and cannot alter the original variables.
• To modify a caller's variable, you must pass a pointer to it (i.e., pass its address using the & operator).
• The function must be defined to accept a pointer parameter (*).
• Inside the function, you must dereference the pointer (* for basic types, -> for structs) to access and modify the data at the original address.
• This "pass-by-pointer" technique is crucial for both functionality (modifying caller data) and performance (avoiding large data copies on the stack).

In our next lesson, we will continue exploring the relationship between pointers and functions. We'll delve into the implications of returning pointers from functions, a technique that is powerful but also fraught with potential dangers, such as returning pointers to local variables that no longer exist. This is a critical topic for writing robust and safe code, directly relevant to the functional safety standards you work with.