How do I pass a variable by reference?

Before diving into passing variables by reference, let’s take a step back and understand the memory management process in a computing system. Variables declared in programming languages request storage on the computer’s Random Access Memory (RAM). Think of the RAM as a gym locker or a long sequence of storage cells, each with a unique address. When a variable is declared, it reserves one of these addresses. The data stored in the address may vary depending on the data type a variable is assigned when reserving the memory address.

Computer memory used to store variables is usually either a heap or stack memory. Stack memory allocation is used for storing static memory, which is known only to the function calling it. In stack memory, memory allocation, and deallocation are done automatically when the method calling it finishes its execution; hence, it’s very safe for multi-threaded applications. Local variables and function call details are usually stored here. On the other hand, heap memory is typically available for the entire program, and allocation and de-allocation are done manually or with a garbage collector. Global variables and constant variables are usually stored in heap memory.

What does it mean to pass a variable by reference?

Passing a variable by reference means that the argument passed to a function references or points to a variable already in memory. This means that any changes made to the variable in the function directly change the original variable as they are pointing to the same memory address.

Passing a variable by reference should be contrasted with passing a variable by value. When passing a variable by value, a copy of the variable is made and allocated to another memory address. This means changing the variable in the function does not change the original variable values.

Most low-level programming languages like C/C++ and JAVA support both methods of passing variables.

To demonstrate, consider the following C++ Code:

As you can see, modifyList modifies the array in place, and they all point to the same memory address since the lst variable is passed by reference.

Furthermore, in the code above, the value of the integer can be referenced by value or by reference in C++, which allows C++ programs to be very memory efficient. From the two examples, it’s apparent that no matter the data type, C++ offers the flexibility to choose between pass-by-value (making a copy) and pass-by-reference (directly accessing the original) memory address.

In contrast, Python does not necessarily pass variables by reference or value.

As you can see, the memory address of the variable n changes when a modification is done on the n variable inside the function.

In Python, for immutable data types (like int, float, str), any modification operation inside a function results in the creation of a new object in memory. The function’s local reference is then updated to point to this new object, leaving the original reference unchanged. For mutable types (like list, dict, set), operations that modify the object’s content will reflect in the original object since both local and external references point to the same memory location.

Why would you want to pass a variable by reference?

The main reason for passing variables by reference is to ensure performance efficiency. Copying the entire data can be time-consuming and memory-intensive while working with large data structures (like arrays, matrices, or custom objects). Passing the data by reference avoids the overhead of copying, making the function call faster and more memory efficient. Passing by reference also helps to prevent return overheads. Suppose a function needs to modify multiple data elements. In that case, it’s easier to pass them by reference and change them directly rather than returning multiple values and then reassigning them outside the function.

Conclusion

In conclusion, high-level languages like C++ and Java provide mechanisms to pass variables by reference or value for all their data structures. This behavior makes them very fast. However, poorly constructed code may lead to memory leaks that might be hard to debug. On the other hand, Python does not pass variables by reference or value but by assignment. This way, Python chooses the best way to handle variable changes depending on whether the data structure is mutable or immutable.