C++ Call by Reference

Call by Reference is a C++ method for passing arguments to a function that enables us to pass the actual memory address of the parameter rather than a copy of its value. The function can now directly change the initial variable due to it.

Working:

• The function argument is referenced by the & (ampersand) symbol.
• The parameter itself is affected by internal modifications made to the function.
• By eliminating unnecessary duplication of large objects, performance is enhanced.

Key Features:

Several key features of the call by reference in C++ are as follows:

The initial variable is modified:

• Any changes made inside the function have an effect outside of it because it interacts directly with the original variable.

Uses Memory Addresses:

• Instead of passing a copy, the original variable is referenced in order to save memory.

Optimized for Big Data Types:

• As it avoids unnecessary repetition, it is ideal for passing large structures, arrays, and objects.

The Use of Ampersands (&) in Syntax:

• In the function specification, parameters are provided with & to display references.
• Example: void func(int &x) { x = x * 2; }

Increased Action Speed:

• Because no copies are created, function calls execute faster, which improves performance.

Capable of Identifying Different Values:

• Functions can alter more than one variable by supplying multiple references.

Example 1:

Let us take an example to illustrate the Call by Reference in C++.

#include <iostream>

using namespace std;

// Function using Call by Reference

void modifyValue(int &x) {

    x = x * 2; // Modifying the original variable

}

int main() {

    int num = 10;

    cout << "Before function call: " << num << endl;   

    modifyValue(num); // Passing by reference   

    cout << "After function call: " << num << endl;

    return 0;

}

Output:

Before function call: 10

After function call: 20

Algorithm:

• Start

• Declare a function that takes a reference parameter.

• Inside the function, modify the referenced variable.

• In the main function:

1. Declare a variable and initialize it.

2. Print its value before the function call.

3. Call the function and pass the variable by reference.

4. Print the value after the function call.

• End

Pseudo code:

BEGIN

    DEFINE FUNCTION ModifyValue(REFERENCE x)

        x ← x * 2  // Modify the original variable

    END FUNCTION


    MAIN

        DECLARE num ← 10

        PRINT "Before function call: ", num

       

        CALL ModifyValue(num)  // Passing by reference

       

        PRINT "After function call: ", num

    END MAIN

END

Advantages:

• Changes Original Value: Changes persist once the function is completed.
• Efficient Memory Utilization: No new copies are created.
• Advantageous for Big Data Structures: It reduces unnecessary overhead when copying objects.

Example 2:

Let us take a C++ example code for Swapping of Two Numbers by using Call by Reference:

#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: " << endl;

    cout << "num1 = " << num1 << ", num2 = " << num2 << endl;   

    swapNumbers(num1, num2); // Passing by reference   

    cout << "After swapping: " << endl;

    cout << "num1 = " << num1 << ", num2 = " << num2 << endl;   

    return 0;

}

Output:

Before swapping:

num1 = 5, num2 = 10

After swapping:

num1 = 10, num2 = 5

Explanation:

The function swapNumbers(int &a, int &b):

• It receives two integer references as parameters they are &a and &b.
• It swaps their values using a temporary variable.

Main Function:

• Numer1 is set to 5 and Numer2 to 10.
• Calling swapNumbers(num1, num2) instantly modifies num1 and num2.
• The values that have been changed are printed.

Example 3:

Let us take a C++ example to find the square of a number by using the call by reference:

#include <iostream>

using namespace std;

// Function to calculate the square using Call by Reference

void findSquare(int &num) {

    num = num * num; // Modifies the original variable

}

int main() {

    int value = 6;   

    cout << "Before function call: " << value << endl;   

    findSquare(value); // Passing by reference   

    cout << "After function call (Square): " << value << endl;   

    return 0;

}

Output:

Before function call: 6

After function call (Square): 36

Conclusion:

In C++, calling by reference is a more efficient way to supply parameters to functions by giving the variable's real memory address rather than making a copy. For situations like value swapping, altering large data structures, and producing multiple outputs, it enables functions to directly change the original variable. Call by Reference increases program efficiency, particularly when working with large objects, by reducing execution time and removing the need for additional memory allocation. It needs to be used carefully to prevent inadvertent changes to variables. Overall, Call by Reference is a strong feature that offers alternatives for function design in addition to performance advantages.