C++ Call by Value and Call by Reference

In C++, when passing arguments to functions, there are two common methods: call by value and call by reference. These methods determine how the arguments are passed and how they can be modified within the function. In this article, we will explore the differences between call by value and call by reference, along with examples to illustrate their usage.

Call by Value

Call by value is the default method of passing arguments to functions in C++. When using call by value, a copy of the argument’s value is made and passed to the function. This means that any modifications made to the argument within the function will not affect the original value outside of the function.

Let’s consider an example to understand call by value:

#include <iostream>
using namespace std;

void increment(int num) {
    num++;
    cout << "Inside the function: " << num << endl;
}

int main() {
    int num = 5;
    cout << "Before function call: " << num << endl;
    increment(num);
    cout << "After function call: " << num << endl;
    return 0;
}

In the above example, we have a function called “increment” that takes an integer argument “num”. Inside the function, we increment the value of “num” by 1. However, when we call the function “increment” from the main function, the original value of “num” remains unchanged. This is because the argument is passed by value, and any modifications made to the argument within the function do not affect the original value.

Call by Reference

Call by reference is another method of passing arguments to functions in C++. When using call by reference, instead of passing a copy of the argument, we pass the address of the argument. This allows the function to directly access and modify the original value of the argument.

Let’s consider an example to understand call by reference:

#include <iostream>
using namespace std;

void increment(int& num) {
    num++;
    cout << "Inside the function: " << num << endl;
}

int main() {
    int num = 5;
    cout << "Before function call: " << num << endl;
    increment(num);
    cout << "After function call: " << num << endl;
    return 0;
}

In the above example, we have a function called “increment” that takes an integer reference “num”. Inside the function, we increment the value of “num” by 1. When we call the function “increment” from the main function, the original value of “num” is modified. This is because the argument is passed by reference, allowing the function to directly access and modify the original value.

Call by reference is useful when we want to modify the original value of a variable within a function. It can also be more efficient than call by value, especially when working with large data structures, as it avoids making unnecessary copies of the data.

It is important to note that when using call by reference, we need to ensure that the referenced variable exists and is valid throughout the function’s lifetime. If the referenced variable goes out of scope or is destroyed, accessing it will result in undefined behavior.

In conclusion, call by value and call by reference are two different methods of passing arguments to functions in C++. Call by value creates a copy of the argument’s value, while call by reference allows direct access to the original value. Understanding these methods and their implications can help in writing more efficient and effective C++ programs.