Call by Value and Call by Reference in C++

I have had numerous experiences on using C++ as a software engineer and the different approaches to use when passing parameters to functions. The two major passing techniques are call by value and call by reference. Having huge knowledge on these two is very essential while coding to make the code efficient and effective.

Let me explain call by value and call by reference in C++ in this tutorial. At the end of the following tutorial, you will have understudied both call by value and call by reference in C++ program; the difference of both will be clear-as-mud to you.

So, let’s begin!

What is Call by Value and Call by Reference in C++?

In C++, when you give parameters to a function, there are two ways for it to happen: call by value and call by reference.

What is Call by Value?

Call by value in C++ is a way of transferring the arguments to a function by value. In this method, a duplicate copy of the real parameter is created and provided to the function. Any modifications done on this parameter within the function are limited only in that particular process or subprogram; they do not manifest in the caller's actual parameter.

What is Call by Reference?

The other type is "call by reference," and this means the passing of parameters through their references. In call by reference, a function is given with an address to the variable being passed as parameter rather than giving it a duplicate copy of that variable itself. This way any alterations made within the function affect the passed argument because both parameter and real argument are pointing towards similar memory space.

What is Call by Value and Call by Reference in C++ Difference?

While both methods allow you to pass parameters to a function, they do so in fundamentally different ways. Here’s how you can understand the call by value and call by reference in C++ difference:

• Call by Value:
• • A copy of the data is passed to the function.
  • Changes to the parameter inside the function do not affect the actual argument.
  • Safer for protecting the original data against unwanted modifications.
• Call by Reference:
• • A reference to the actual data is passed (effectively a pointer).
  • Changes to the parameter affect the actual argument.
  • More efficient for passing large data structures like vectors, since no copying of data is required.

Elaborate Call by Value and Call by Reference in C++ with Example

To illustrate how both methods work, I'll use a simple example. We’ll look at both call by value and call by reference in C++ program one after the other for you to get a proper understanding of what’s going on under the hood!

Example of Call by Value

Example:

#include <iostream>
using namespace std;
void modifyValue(int x) {
x = 30;
cout << "Value inside function: " << x << endl;
}
int main() {
int a = 20;
modifyValue(a);
cout << "Value in main after function call: " << a << endl;
return 0;
}

Output:

Value inside function : 30
Value in main after function call: 20

This output further proves that the alteration that was done on x within the function does not impact on the value of a in the main program. This is the core characteristic of call by value: it has been pointed out that the function operates on a copy of the argument and not the argument itself.

Explanation:

• Function Definition: void modifyValue(int x) { ... }
• • This function takes one parameter x of type int.
  • Inside the function, the value of x is modified to 30.
  • The function then prints the value of x inside the function, which will be 30.
• Main Function:
• • An integer variable a is declared and initialized to 20.
  • The modifyValue function is called with a as the argument.
  • Inside modifyValue, the value of x is a copy of a, so changing x does not affect a.
  • After the function call, the program prints the value of a in the main function, which remains 20 because the function modified a copy, not the original a.

Example of Call by Reference

#include <iostream>
using namespace std;
void modifyReference(int &x) {
x = 30;
cout << "Value inside function: " << x << endl;
}
int main() {
int a = 20;
modifyReference(a);
cout << "Value in main after function call: " << a << endl;
return 0;
}

Output:

Value inside function : 30
Value in main after function call: 30

This output shows that the change made to x inside the function reflects in the value of a in the main program. This behavior is the hallmark of call by reference: the function works directly with the original variable, allowing it to modify the variable's value.

Explanation:

• Function Definition: void modifyReference(int &x) { ... }
• • This function takes one reference parameter x of type int.
  • The & symbol indicates that x is a reference to the variable passed into the function.
  • Inside the function, the value of x is changed to 30.
  • This change directly affects the original variable because x is a reference to that variable.
• Main Function:
• • An integer variable a is declared and initialized to 20.
  • The modifyReference function is called with a as the argument.
  • Since x is a reference to a, when x is changed inside the function, a is also changed.
  • After the function call, the program prints the value of a in the main function, which is now 30 because the function modified the original variable a.

When to Opt For Which in C++

Deciding when to apply call by value or call by reference in C++, is a critical choice that might considerably influence how your application runs and behaves. Below, I provide some suggestions for you to consider when it is best appropriate to use each method.

Use Call by Value When:

When you want to guard the original data from being changed within the function, go with call by value. It acts as a protection shield which makes certain that any changes carried out inside this function won't influence data outside its boundaries. For example, when you are calculating the square of a number, it is wise to pass the number by value so that the original integer stays unmodified and side effects are prevented.

In particular, call by value can be seen as a very appropriate method when working with small or primitive data types. The cost of copying these types of data is low, and so using call by value is simple without much performance drawback. For example, if you have a function that checks whether a character is a vowel or not; then it's good to pass the character by value because it's small and cannot change.

Additionally, in situations where recursion is involved, call by value can prove advantageous if every recursive call needs its separate data copy. This is especially useful when calculating mathematical series or permutations. For instance, if a recursive function calculates Fibonacci numbers and uses call by value, it guarantees that every function call functions on its own without affecting the calculations of other calls.

Use Call by Reference When:

On the other hand, if your function is meant to change the original input data, then using call by reference would be more suitable. This way of passing allows the function to directly alter what has been passed on from its caller. For example, when making a function that can reverse a string in place, giving the string through reference lets this action happen by modifying the original string without needing to create another new one.

Pass by reference is also useful when working with large data structures such as vectors, matrices or custom objects. It prevents the need to copy all of the data which can be costly and not needed. For example, if you are sorting a big vector of integers, using pass by reference lets the sorting happen directly on this original vector without duplicating its data.

When it comes to performance-critical applications, using call by reference can make a big difference in terms of memory usage and execution time. It does this by getting rid of the extra workload related to copying large data sets. For example, when a function has to change a huge image or 3D model in graphic applications, if we pass these big structures as references then it will greatly decrease memory use and speed up the process.

And the last reason is some functions or APIs need parameters as references. This happens mostly in operator overloading and when you use particular design patterns. When we do overloading of assignment operators or comparison operators, C++ frequently requires us to work with references so that we don't duplicate the objects. This aids in enhancing performance and memory consumption by avoiding copying them unnecessarily.

To dive deep into these or other high-level programming ideas, I suggest you look at courses from upGrad. There, you can study software engineering basics and C++ coding with much more needed depth and nuances.

Concluding Remarks

To conclude, choosing which to use between call by value and call by reference in C++ mainly depends on your particular situation. Knowing the distinctions and effects of each method lets you create more efficient and powerful C++ programs. For extra study and work growth, check out courses at upGrad to become expert in these abilities as well as many more.

FAQs

What is call by value in C++?

In C++, call by value is a method for passing parameters where a duplicate of the real parameter is given to the function. Changes done to the parameter inside the function don't affect the original argument.

What is call by reference in C++?

Call by reference in C++ is a method where the function gets an alias (or reference) to the real parameter. Modifications done on this reference are shown in the passed argument.

How are parameters passed in call by value?

When you pass parameters by value, it is like making a copy of the actual argument. This happens because the function creates its own new local variable and copies the value from your provided argument into this newly created space.

Why is call by reference faster than call by value?

When using call by reference instead of call by value, it is often chosen because with call by value you must copy the real data. Call by reference uses the data's location which is usually quicker, this is very noticeable when dealing with big data structures.

What is the difference between call by reference and call by pointer in C++?

When we use call by reference, it involves references marked with '&', and call by pointer means using pointers indicated by '*'. Neither method makes a copy of the information; however, references are typically safer and more straightforward to work with than pointers.

What are the limitations of call-by-value?

The main drawback of using call by value is that the function's second parameter becomes a duplicate of the first one, and when you have a big structure, it means copying this large structure into the function can consume much time and resources.

What are the advantages of Call by Reference over call by value?

The advantages of call by reference include:

• Efficiency in processing large data due to no copying.
• Ability to modify the original data directly.
• Reduced program memory usage since no additional copies are created.

Is call by value a function?

No, call by value is not a function but a method of parameter passing in functions where copies of the actual parameters are made.