Tutorial: Function Call by Value in C Programming

In C, functions are an essential part of programming that allow code to be modular and reusable. When passing arguments to a function, the call by value mechanism is the default in C.

This means that a copy of the argument's value is passed to the function.

Changes made to the parameter inside the function do not affect the original argument outside the function.

This tutorial covers:

1. What is Call by Value?

Call by value is a mechanism in which:

• A copy of the actual argument's value is passed to the function.
• The function works on this copy, and any modifications are not reflected in the original variable.

2. How Call by Value Works

Key Points

• Each argument is evaluated, and its value is stored in a new variable inside the function.
• The function operates on these new variables (local copies), leaving the original arguments unchanged.

Example Overview

#include <stdio.h>

// Function definition
void increment(int num) {
    num = num + 1;  // Modify the local copy
    printf("Inside function: num = %d\n", num);
}

int main() {
    int value = 10;
    printf("Before function call: value = %d\n", value);
    
    increment(value);  // Call by value: 'value' is not modified

    printf("After function call: value = %d\n", value);
    return 0;
}

Output:

Before function call: value = 10
Inside function: num = 11
After function call: value = 10

Explanation

• value is passed to the function increment.
• Inside the function, num is a local copy of value.
• Changes to num do not affect value in the main function.

3. Examples of Call by Value

3.1 Swapping Numbers (Unsuccessful Attempt)

Using call by value to swap two numbers will not work because only copies are modified.

#include <stdio.h>

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    printf("Inside function: a = %d, b = %d\n", a, b);
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    swap(x, y);  // Call by value: copies are swapped, not originals
    
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

Output:

Before swap: x = 5, y = 10
Inside function: a = 10, b = 5
After swap: x = 5, y = 10

3.2 Calculating the Square of a Number

Call by value works well for functions that compute values without modifying the original variable.

#include <stdio.h>

int square(int num) {
    return num * num;
}

int main() {
    int number = 7;
    printf("Original number: %d\n", number);
    
    int result = square(number);  // Call by value: number remains unchanged
    
    printf("Square of the number: %d\n", result);
    printf("Original number after function call: %d\n", number);
    return 0;
}

Output:

Original number: 7
Square of the number: 49
Original number after function call: 7

4. Advantages and Disadvantages of Call by Value

Advantages

1. Encapsulation: The original data is safe from unintended modification.
2. Simplicity: Easier to understand since functions only operate on local copies.

Disadvantages

1. Memory Usage: Creating copies of arguments consumes additional memory, especially for large structures or arrays.
2. No Modifications: If you need to modify the original value, call by value will not work.

5. Comparison with Call by Reference

In contrast to call by value, call by reference passes the address of the variable, allowing the function to modify the original data. In C, call by reference is implemented using pointers.

Call by Value vs. Call by Reference

6. Combining Call by Value with Call by Reference

Example: Swapping Numbers (Successful Attempt)

Here’s how call by reference can modify the original values.

#include <stdio.h>

void swap(int *a, int *b) {  // Pointers allow modifying the original variables
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    swap(&x, &y);  // Passing addresses for call by reference
    
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

Output:

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

Conclusion

In C, call by value is the default mechanism for passing arguments to functions. While it ensures the safety of the original data, it cannot modify the original values.

Understanding when to use call by value versus call by reference is essential for efficient and effective programming in C.

Use call by value for computations where the original data should remain unchanged and call by reference when modifications are required.