Call by Value vs. Call by Reference in C

When passing arguments to a function in C, there are two ways to do it:

1. Call by Value – A copy of the actual value is passed to the function. Any modifications inside the function do not affect the original value.

2. Call by Reference – The address of the actual value is passed, allowing modifications inside the function to reflect outside.

Call By Value

#include <stdio.h>

void changeValue(int x) { 
    x = 20; // Modifying the copy of the value
}

int main() {
    int num = 10;
    printf("Before function call: %d\n", num);
    
    changeValue(num); // Passing value
    
    printf("After function call: %d\n", num); // Original value remains unchanged
    return 0;
}

Output:

Before function call: 10
After function call: 10

Explanation:

The function changeValue() modifies x, but since it's a copy, num in main() remains unchanged.

Call by Reference

#include <stdio.h>

void changeValue(int *x) { 
    *x = 20; // Modifying the original value through pointer
}

int main() {
    int num = 10;
    printf("Before function call: %d\n", num);
    
    changeValue(&num); // Passing address of num
    
    printf("After function call: %d\n", num); // Original value is changed
    return 0;
}

Output:

Before function call: 10
After function call: 20

Explanation:

Here, we pass the memory address of the variable, allowing the function to modify the original value.

Example 2: Call by Reference

A real-world example of Call by Reference is swapping two numbers in a banking system. Imagine you have two bank accounts, and you want to swap their balances. Using Call by Reference, you can directly modify the original balances instead of returning new values.

#include <stdio.h>

// Function to swap two balances using call by reference
void swapBalances(float *acc1, float *acc2) {
    float temp = *acc1;
    *acc1 = *acc2;
    *acc2 = temp;
}

int main() {
    float balance1 = 5000.75, balance2 = 3000.25;

    printf("Before Swapping:\n");
    printf("Account 1 Balance: $%.2f\n", balance1);
    printf("Account 2 Balance: $%.2f\n", balance2);

    // Swapping balances
    swapBalances(&balance1, &balance2);

    printf("\nAfter Swapping:\n");
    printf("Account 1 Balance: $%.2f\n", balance1);
    printf("Account 2 Balance: $%.2f\n", balance2);

    return 0;
}

Output:

Before Swapping:
Account 1 Balance: $5000.75
Account 2 Balance: $3000.25

After Swapping:
Account 1 Balance: $3000.25
Account 2 Balance: $5000.75

This is useful in banking applications where you may need to swap balances between accounts without creating new variables.

A real-world scenario for Call by Reference could be:

🔹 ATM Cash Withdrawal: When you withdraw money from an ATM, the function handling the withdrawal directly modifies the balance stored in your account. Instead of returning a new balance (like Call by Value), it updates the actual balance in the bank's database.
🔹 Game Health System: In video games, when a character takes damage, their health is stored in a variable. A function that processes damage could use Call by Reference to directly update the player's health instead of returning a new value.
🔹 E-commerce Cart Update: When you add or remove items from your shopping cart, the function updates the original cart data directly rather than creating a separate copy.

These scenarios involve modifying the actual data rather than just working with copies, making Call by Reference useful.