What is pass-by-reference?

Pass by reference is a mechanism where a function receives the address (reference) to a memory area where the argument variable's data is stored. As a result, any changes made to the variable inside the function are reflected outside the function on the original variable.

Main characteristics:

• The memory address is passed, not a copy of the value.
• The function works directly with the original data.
• Changes inside the function are preserved after it finishes.
• Applicable to objects, arrays, and other reference types in many programming languages.
• In some languages (e.g., C++), primitive types can be explicitly passed by reference using pointers or references.

Example code in Python:

# Passing a list (reference type)
def modify_list(my_list):
    my_list.append(4) # Modifies the original list

data = [1, 2, 3]
modify_list(data)
print(data) # Outputs [1, 2, 3, 4]

# Passing a number (primitive type - pass by value in Python)
def modify_number(my_number):
    my_number += 1 # Creates a local copy that is modified

value = 5
modify_number(value)
print(value) # Outputs 5 - the original value remains unchanged

Example code in C++:

#include <iostream>

// Passing by reference
void modify_value_ref(int &val) {
    val += 10; // Modifies the original variable
}

// Passing by value (for comparison)
void modify_value_copy(int val) {
    val += 10; // Modifies the local copy
}

int main() {
    int a = 5;
    modify_value_ref(a);
    std::cout << "After ref: " << a << std::endl; // Outputs After ref: 15

    int b = 5;
    modify_value_copy(b);
    std::cout << "After copy: " << b << std::endl; // Outputs After copy: 5

    return 0;
}

Advantages:

• Efficient when working with large amounts of data, as copying is not required.
• Allows functions to modify multiple values through arguments.

Disadvantages:

• Can make code less predictable if the function modifies arguments without explicitly indicating this in the name or documentation.
• Requires caution to avoid unintended side effects.