Call by Value is one of the most commonly used methods for passing arguments to functions in C. In this method, the actual value of a variable is copied and passed to the function. Any changes made inside the function do not affect the original variable.
Understanding Call by Value is important because functions frequently use parameters to perform operations. It helps programmers keep original data safe while processing values inside functions.
 

Table of Contents

---

What is Call by Value?

Call by Value is a method of passing arguments to a function where a copy of the original value is sent to the function.
The function works only on the copied value. The original variable remains unchanged even if modifications are made inside the function.
Syntax:

return_type function_name(data_type parameter)
{
    // function body
}

Example:

void display(int num)
{
    num = num + 10;
}

Here, num receives only a copy of the value.

How Call by Value Works?

The working process of Call by Value can be understood in the following steps:

1. A variable is created in the main function.
2. The variable value is passed during the function call.
3. A copy of the value is created and stored in the function parameter.
4. The function works on the copied value.
5. Original variables remain unchanged after function execution.

Program to Demonstrate Call by Value

Write a C program to show that changes made inside a function do not affect the original variable when using Call by Value.

// C program to implement call by value
#include stdio.h

void changeValue(int num)
{
    num = num + 20;

    printf("Value inside function: %d\n", num);
}

int main()
{
    int number = 10;

    printf("Original value before function call: %d\n", number);

    changeValue(number);

    printf("Original value after function call: %d\n", number);

    return 0;
}

Output:

Original value before function call: 10
Value inside function: 30
Original value after function call: 10

Explanation:

1. Variable number stores value 10.
2. During the function call, a copy of 10 is passed to changeValue().
3. The parameter num stores the copied value.
4. Inside the function, the copied value changes from 10 to 30.
5. The original variable number remains unchanged.

This proves that Call by Value works on copied data.

Memory Representation of Call by Value

In Call by Value, the original variable and function parameter are stored in separate memory locations.
Example:

1. The variable number in the main() function stores value 10.
2. When the function is called, another variable num is created in memory.
3. The value 10 is copied into num.
4. Any changes made to num affect only the copied value.
5. The original variable number remains safe and unchanged.

This separate memory allocation prevents direct modification of actual variables.

Swap Two Numbers Using Call by Value

Write a C program to swap two numbers using Call by Value and observe whether the original values change or not.

// C program to swap two numbers 
// using call by value
#include stdio.h

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

    temp = a;
    a = b;
    b = temp;

    printf("Values inside function: %d %d\n", a, b);
}

int main()
{
    int x = 5;
    int y = 8;

    swap(x, y);

    printf("Values after function call: %d %d\n", x, y);

    return 0;
}

Output:

Values inside function: 8 5
Values after function call: 5 8

Explanation:

1. Values are swapped only inside the function.
2. Original variables x and y remain unchanged.
3. This happens because the function receives copies instead of actual variables.

Key Features of Call by Value in C

1. Original Variables Remain Unchanged: The actual values are protected from modification.
2. Separate Memory Allocation: Copied variables use different memory locations.
3. Safe Data Processing: Functions cannot accidentally modify original data.
4. Simple Function Execution: This method is easy to understand and implement.
5. Independent Function Operations: Functions work independently using copied values.

Advantages of Call by Value

1. Better Data Security: Original variables remain protected from accidental changes.
2. Fewer Side Effects: Changes inside a function do not affect other parts of the program.
3. Easier Debugging: Errors become easier to identify because original data remains unchanged.
4. Simple for Beginners: The concept is straightforward and easy to learn.
5. Reliable Program Execution: Functions operate independently without changing actual variables.

Limitations of Call by Value

1. Cannot Modify Original Variables: Functions cannot directly update actual values.
2. Additional Memory Usage: Extra memory is required for storing copied values.
3. Reduced Efficiency for Large Data: Copying large structures or arrays may reduce performance.
4. Swapping Cannot Be Performed Properly: Actual variables cannot be swapped using only Call by Value.
5. Repeated Copying Creates Overhead: Continuous copying may increase execution time in large programs.

Difference Between Call by Value and Call by Reference

Feature	Call by Value	Call by Reference
Definition	In Call by Value, a copy of the actual value is passed to the function.	In Call by Reference, the address of the actual variable is passed to the function.
Data Passed	The function receives copied data only.	The function receives the memory address of the original variable.
Effect on Original Variable	Changes inside the function do not affect original variables.	Changes inside the function directly modify original variables.
Memory Allocation	Separate memory is allocated for copied values.	No separate copy is created because original memory is used.
Safety	This method is safer because original values remain protected.	This method is less secure because original values can change directly.
Use of Pointers	Pointers are generally not required.	Pointers are required in C for Call by Reference.
Swapping Variables	Actual variables cannot be swapped successfully.	Actual variables can be swapped successfully.
Memory Usage	More memory is required because copies are created.	Less memory is required because addresses are passed.
Program Complexity	Easier for beginners to understand.	Slightly more difficult because pointers are involved.
Best Use Case	Best when original data should remain unchanged.	Best when functions need to update actual values.

Common Mistakes in Call by Value

1. Expecting Original Variables to Change: Many beginners assume changes inside the function affect actual variables.
2. Confusing Call by Value With Call by Reference: Both methods work differently and should not be mixed.
3. Trying to Swap Variables Directly: Original variables cannot be swapped using Call by Value alone.
4. Ignoring Separate Memory Allocation: Function parameters and actual variables use different memory locations.
5. Passing Large Data Frequently: Repeated copying of large data may reduce program efficiency.

Conclusion

Call by Value is a fundamental concept in C programming that passes copies of variables to functions instead of original values. This method keeps actual data safe and prevents accidental modification. It is simple, secure, and widely used in programs where original values should remain unchanged. Understanding Call by Value helps programmers build a strong foundation in functions, memory handling, and parameter passing techniques in C.

Frequently Asked Questions

1. What is Call by Value in C?

Call by Value is a method where copies of variables are passed to functions instead of original variables.

2. Does Call by Value change original variables?

No, original variables remain unchanged.

3. Why is Call by Value important?

It protects actual data from accidental modification.

4. Can original variables be swapped using Call by Value?

No, only copied values are swapped inside the function.

5. Which is safer: Call by Value or Call by Reference?

Call by Value is generally safer because original variables cannot be modified directly.