Call by Value and Call by Reference

Hey there, young coders! Today, we’re going to unravel the mysteries of C++ and explore two crucial concepts: Call by Value and Call by Reference. We’ll break it down step by step, making it as easy as piecing together a puzzle. So, are you ready to dive in? Let’s go!

Introduction

Imagine you’re playing a game of chess and you want to experiment with different moves. In programming, we have the concepts of Call by Value and Call by Reference, which allow us to make changes and observe their effects. Call by Value means passing a copy of the value to a function, while Call by Reference means passing the actual variable itself. Understanding these concepts is important for making changes to variables and manipulating data effectively. In this article, we will explore Call by Value and Call by Reference and discuss how they can be used in programming. Let’s get started!

Call By Value And Call By Reference
Call by Value and Call by Reference

Call by value in C++

Call by value in C++ is a method used to pass arguments to a function. When we pass a variable to a function by value, a copy of the variable’s value is created, and this copy is used within the function. Any changes made to the parameter inside the function do not affect the original variable outside the function.

This approach ensures that the original variable remains unchanged, making call by value a safe way to work with data in functions. However, it might be less efficient when dealing with large data structures, as copying the data can consume memory and time.

Code Example:

C++
#include <iostream>
using namespace std;

// Function to swap two numbers using call by value
void swapValues(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;

    cout << "Before swapping: x = " << x << ", y = " << y << endl;

    // Call the function to swap values
    swapValues(x, y);

    cout << "After swapping: x = " << x << ", y = " << y << endl;

    return 0;
}

Output:

C++
Before swapping: x = 5, y = 10
After swapping: x = 5, y = 10

Explanation:

  • The ‘swapValues‘ function swaps a and b inside it, but it doesn’t change the original ‘x‘ and ‘y‘ values in the ‘main‘ function.
  • Call by value passes the values of variables to functions, not their memory addresses.
  • Changes made to the parameters inside the function do not affect the original variables outside the function.

Call by Reference in C++

Call by Reference is a method in programming where a function receives the memory address of a variable as a parameter, allowing the function to directly access and modify the original variable’s value. This means that changes made to the parameter inside the function will reflect in the original variable outside the function. In simpler terms, it’s like sharing a book with someone and any notes they write in it also appear in your own copy.

Code Example:

C++
#include <iostream>
using namespace std;

// Function to swap two numbers using call by reference
void swapNumbers(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int num1 = 5, num2 = 10;

    cout << "Before swapping: num1 = " << num1 << ", num2 = " << num2 << endl;

    // Calling the swapNumbers function with call by reference
    swapNumbers(num1, num2);

    cout << "After swapping: num1 = " << num1 << ", num2 = " << num2 << endl;

    return 0;
}

Output:

C++
Before swapping: num1 = 5, num2 = 10
After swapping: num1 = 10, num2 = 5

Explanation:

  • The example uses a function called ‘swapNumbers‘ that takes two integer parameters using call by reference.
  • Call by reference means the function works with the actual variables passed to it, not just copies.
  • Inside the function, the values of the parameters are swapped using a temporary variable.
  • This swapping affects the original variables ‘num1‘ and ‘num2‘ in the ‘main‘ function.
  • After calling the function, ‘num1‘ and ‘num2‘ have their values swapped

A Real-world Example for Call by Value and Call by Reference

Call by Value:

Real-life Analogy: Think of “Call by Value” as reading a recipe from a cookbook. When you read a recipe, you’re getting the ingredients and steps, but if you make any changes or notes directly on the recipe (like adjusting the quantity of an ingredient), the original recipe in the book remains unchanged. You would need to physically write or edit the book to make a permanent change.

In C++: When you use call by value, you’re passing the value of a variable to a function. This means the function gets a copy of the data, not the actual data itself. Any changes made to this data inside the function do not affect the original data outside the function.

Example:

C++
void modify(int x) {
    x = x + 10;
}

int main() {
    int num = 5;
    modify(num);
    cout << num; // Outputs: 5
}

In the above code, even though we modified x inside the function, num remains unchanged because we passed the value, not the actual variable.

Call by Reference:

Real-life Analogy: Think of “Call by Reference” as lending a personal diary to a friend. If your friend writes or erases something in the diary, the diary is modified directly. When you get the diary back, the changes made by your friend are there to stay.

In C++: When you use call by reference, you’re passing the address of the variable to the function, which means the function can access and modify the actual data. If the function changes the data, the original variable outside the function is also changed.

Example:

C++
void modify(int &x) {
    x = x + 10;
}

int main() {
    int num = 5;
    modify(num);
    cout << num; // Outputs: 15
}

In the above code, ‘num‘ gets modified inside the function because we passed its reference, not just its value.

In Summary:

  • Call by Value is like reading a recipe from a cookbook. You get the info, but the original remains unchanged.
  • Call by Reference is like lending your diary. Any changes made to it directly affect the original.

A Problem Statement

Problem Statement:

Alice and Bob are playing with two numbers, ‘a‘ and ‘b‘. Alice wants to double the value of both numbers, while Bob wants to swap the values of both numbers. They need your help to achieve these tasks using functions.

  1. Write a function named ‘doubleValues‘ that doubles the value of both numbers. This function should use Call by Value.
  2. Write a function named ‘swapValues‘ that swaps the values of both numbers. This function should use Call by Reference.

Implement both functions and demonstrate their effects on ‘a‘ and ‘b‘ in the ‘main‘ function.

Guide:

  1. doubleValues should take two integer arguments and return their doubled values. However, the original values of a and b in the main function should remain unchanged after the call.
  2. swapValues should not return anything but should directly swap the values of the two integer references it receives.
  3. In the main function, define two integer values for a and b, then call both functions and display the values of a and b before and after each function call to show the students the effect of each function.

Expected Output:

For initial values a = 5 and b = 10, the output should be:

C++
Original values: a = 5, b = 10
After doubling: a = 5, b = 10
After swapping: a = 10, b = 5

Hint:

  • For the doubleValues function, just double the numbers inside the function and print them, demonstrating the “Call by Value”. The main values should not change.
  • For the swapValues function, you can use a temporary variable to store one value, overwrite that value with the other, and then assign the temporary value to the other variable, demonstrating the “Call by Reference”.

Examples of Call by Value and Call by Reference

Let’s look at some examples to understand these concepts better.

First Example

Consider a function that tries to change the value of a variable.

C++
#include <iostream>
using namespace std;

// Function to change the value of a variable
void changeValue(int &num) {
    num = 20; // Changing the value of the variable
}

int main() {
    int number = 10;

    cout << "Original value: " << number << endl;

    // Calling the function to change the value
    changeValue(number);

    cout << "New value after function call: " << number << endl;

    return 0;
}

Output:

C++
Original value: 10
New value after function call: 20

Explanation:

  • The function ‘changeValue‘ is used in this example.
  • It takes an integer reference parameter, ‘int &num‘.
  • The function directly modifies the value of the variable ‘number‘ in the ‘main‘ function.
  • After calling the ‘changeValue‘ function, the value of ‘number‘ changes from 10 to 20.

Second Example

Now, let’s try to change the value of a variable using Call by Reference.

C++
#include <iostream>
using namespace std;

// Function to change the value of a variable using call by reference
void changeValue(int &x) {
    x = 20;
}

int main() {
    int num = 10;

    cout << "Before calling the function: " << num << endl;

    // Calling the function to change the value
    changeValue(num);

    cout << "After calling the function: " << num << endl;

    return 0;
}

Output:

C++
Before calling the function: 10
After calling the function: 20

Explanation:

  • The ‘changeValue‘ function uses an integer reference parameter.
  • When the function is called, it modifies the value using call by reference.
  • This modification directly affects the original variable outside the function.
  • As a result, the value of ‘num‘ changes from 10 to 20 after calling the function.

Difference between Call by Value and Call by Reference

AspectCall by ValueCall by Reference
DefinitionA method where the function receives a copy of the actual value.A method where the function receives the address of the actual value.
Effect on Original DataNo changes made inside the function affect the original data.Changes made inside the function directly affect the original data.
MemoryUses more memory as it creates a separate copy for function calls.Uses less memory as it works on the original data without making copies.
SpeedMight be slower due to copying of values.Usually faster as there’s no copying, just referencing.
UsageSafer for ensuring data doesn’t get changed unintentionally.Useful when you need to update the original variables or when working with large data structures (to avoid copying).
Example in C++void function(int x)void function(int &x) or void function(int *x)
Difference between Call by Value and Call by Reference

Pros and Cons to Consider

ProsCons
Call by Value is simpler and easier to useCall by Value creates a copy of the variable
Call by Reference allows modifying the original variable directlyCall by Reference can lead to unintended side effects
Multiple Inheritance allows inheriting from multiple classes, providing flexibilityMultiple Inheritance can introduce complexity and ambiguity
Inheritance allows code reuse and promotes modular designInheritance can lead to tightly coupled code and maintenance challenges
Functions help break down complex tasks into smaller, manageable partsOveruse of functions can lead to code bloat and decreased readability
Pros and Cons

Essential Points to Remember

  • Call by Value passes a copy of the value, while Call by Reference passes a reference to the original variable.
  • Call by Value doesn’t change the original data, but Call by Reference can.
  • Multiple inheritance in C++ allows a class to inherit from multiple classes.

Conclusion

Understanding Call by Value and Call by Reference is important in C++ programming. They allow us to control whether we want to modify the original data or not. Remember, choosing between them depends on what you need for your program. Keep practicing, and soon, these concepts will be as clear as a sunny day!

FAQs

What is the difference between Call by Value and Call by Reference?

  • Call by Value passes a copy of the value, while Call by Reference passes a reference to the original variable.

Does Call by Value change the original data?

  • No, Call by Value doesn’t change the original data as it works with a copy of the data.

Can Call by Reference change the original data?

  • Yes, Call by Reference can change the original data as it works with a reference to the original data.

What is multiple inheritance in C++?

  • Multiple inheritance in C++ allows a class to inherit from more than one class.

Is Call by Value safer than Call by Reference?

  • Yes, Call by Value is generally safer than Call by Reference as it doesn’t modify the original data. However, it can be slower for large data as it creates a copy.
Avatar Of Deepak Vishwakarma
Deepak Vishwakarma

Founder

RELATED Articles

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.