C Programming Pass By Value Vs Pass By Reference Complete Guide

Pass by Value

In C, when you pass a variable to a function by value, you are actually passing a copy of that variable. This means any modifications you make to the variable within the function do not affect the original variable outside of the function.

Example 1: Basic Pass by Value

#include <stdio.h>

// Function declaration
void modifyByValue(int x);

int main() {
    int number = 5;
    
    printf("Number before modification: %d\n", number);
    
    // Call the function by passing the variable 'number' by value
    modifyByValue(number);
    
    printf("Number after modification: %d\n", number);
    
    return 0;
}

// Function definition
void modifyByValue(int x) {
    // Modify the argument
    x = 20;
    printf("Value inside the function: %d\n", x);
}

Steps:

1. Declare the main function: In this example, the main() function is the entry point.

2. Initialize a variable: An integer variable number with the initial value 5 is declared inside main.

3. Print the variable before modification: Before calling modifyByValue(), number is printed.

4. Call the function: The modifyByValue() function is called passing number as an argument.

5. Modify the argument: Inside the function, we change x (which is a copy of number) to 20. This change does not affect number.

6. Print inside the function: The value of x inside modifyByValue() is printed.

7. Print after the function call: Back in main(), the value of number remains unchanged and is printed again.

Output:

Number before modification: 5
Value inside the function: 20
Number after modification: 5

Pass by Reference

Passing by reference in C is typically achieved using pointers. When a pointer is passed to a function, the function can access the original variable directly through that pointer and modify its value.

Example 2: Basic Pass by Reference

#include <stdio.h>

// Function declaration
void modifyByReference(int *x); // 'int *x' indicates that 'x' is a pointer to an integer

int main() {
    int number = 5;
    
    printf("Number before modification: %d\n", number);
    
    // Call the function by passing the address of 'number' using '&' operator
    modifyByReference(&number);
    
    printf("Number after modification: %d\n", number);
    
    return 0;
}

// Function definition
void modifyByReference(int *x) {
    // Modify the value pointed to by 'x'
    *x = 20; // '*' is used to dereference the pointer and change the original value
    printf("Value inside the function: %d\n", *x);
}

Steps:

1. Declare the main function: Again, starting with main() as the entry point.

2. Initialize a variable: An integer variable number with the initial value 5 is declared inside main.

3. Print the variable before modification: Before calling modifyByReference(), number is printed.

4. Call the function: This time, the function is called with the address of number, denoted by &number.

5. Modify the original variable: Inside the function, we use the pointer x to dereference and modify the original number.

6. Print inside the function: The value of *x inside modifyByReference() is printed.

7. Print after the function call: Back in main(), the value of number has been changed and is printed again.

Output:

Number before modification: 5
Value inside the function: 20
Number after modification: 20

Summary

• Pass by Value: A copy of the variable is passed to the function. Modifications inside the function do not affect the original variable.
• Pass by Reference: The memory address (pointer) of the variable is passed to the function. Modifications inside the function affect the original variable.

Additional Example: Swap Two Numbers

Here’s an example demonstrating how to swap two numbers using both pass-by-value and pass-by-reference:

Example 3: Swapping Numbers Using Pass by Value (Does Not Work)

#include <stdio.h>

// Function declaration - attempting swap by value
void swapByValue(int a, int b);

int main() {
    int x = 10, y = 20;
    
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    // Attempting to swap values using swapByValue
    swapByValue(x, y);
    
    printf("After swap (by value): x = %d, y = %d\n", x, y);
    
    return 0;
}

// Function definition
void swapByValue(int a, int b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
    
    printf("Inside swapByValue: a = %d, b = %d\n", a, b);
}

Output:

Before swap: x = 10, y = 20
Inside swapByValue: a = 20, b = 10
After swap (by value): x = 10, y = 20

As we can see, the swap did not work because a and b are only copies of x and y.

Example 4: Swapping Numbers Using Pass by Reference (Working Correctly)

#include <stdio.h>

// Function declaration - swap by reference
void swapByReference(int *a, int *b);

int main() {
    int x = 10, y = 20;
    
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    // Swapping values using swapByReference
    swapByReference(&x, &y);
    
    printf("After swap (by reference): x = %d, y = %d\n", x, y);
    
    return 0;
}

// Function definition
void swapByReference(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
    
    printf("Inside swapByReference: *a = %d, *b = %d\n", *a, *b);
}

Output:

Before swap: x = 10, y = 20
Inside swapByReference: *a = 20, *b = 10
After swap (by reference): x = 20, y = 10

In this example, swapping the numbers worked because the function uses pointers and modifies the original variables directly.

Conclusion