Skip to main content
A value parameter in C (implemented via the pass-by-value evaluation strategy) is a function parameter that receives a distinct, independent copy of the caller’s argument. When a function is invoked, the C runtime evaluates the actual argument to an r-value and copies that data into a newly allocated memory location designated for the function’s formal parameter. Consequently, the function operates strictly on this local copy, ensuring that any mutations applied to the parameter do not alter the original variable in the calling scope.

​
Memory and Execution Mechanics

  1. Stack Frame Allocation: Upon function invocation, a new stack frame is pushed onto the call stack. Memory for the formal parameter is allocated within this local frame.
  2. Data Duplication: The bitwise representation of the actual argument is copied into the formal parameter’s memory address.
  3. Isolation: The formal parameter and the actual argument possess distinct memory addresses (&parameter != &argument).
  4. Deallocation: When the function returns, its stack frame is popped, and the memory allocated for the value parameter is immediately reclaimed.

​
Syntax and Behavior Visualization

#include <stdio.h>

// 'x' is a formal value parameter. It exists only in this function's scope.
void mutateValue(int x) {
    printf("Callee: Address of x = %p, Initial Value = %d\n", (void*)&x, x);
    
    // Mutation only affects the local stack frame copy
    x = x * 2; 
    
    printf("Callee: Mutated Value = %d\n", x);
}

int main() {
    int arg = 10; // Actual argument
    
    printf("Caller: Address of arg = %p, Value = %d\n", (void*)&arg, arg);
    
    // 'arg' is evaluated, and the value '10' is copied into 'x'
    mutateValue(arg);
    
    // 'arg' remains unmodified because 'x' was an isolated copy
    printf("Caller: Post-call Value = %d\n", arg);
    
    return 0;
}

​
Type-Specific Behaviors

  • Primitive Types (int, float, char, etc.): The exact numeric or character value is duplicated onto the stack.
  • Pointers: The memory address held by the pointer is copied. The pointer parameter itself is a value parameter (a copy of the address). Reassigning the pointer to a new address inside the function modifies only the local copy of the pointer, not the caller’s pointer. (Note: Dereferencing this copied address will modify the shared underlying data, but the parameter passing mechanism remains strictly pass-by-value).
  • Structs: The entire memory footprint of the structure is duplicated via a shallow bitwise copy. The size of the struct dictates the amount of memory pushed onto the stack.
  • Arrays: C does not support passing arrays by value. In a function call, an array identifier undergoes type decay, converting into a pointer to its first element (&array[0]). This resulting pointer is what is actually passed by value.
Tired of Poor C Skills? Fix That With Deep Grasping!Learn More