A reference is an alias for a variable and must be initialised to a variable at declaration. A reference cannot be null and once initialised, it cannot be made to refer to a different variable. A reference can be thought of as a constant pointer that is automatically dereferenced once out of scope.

Declaration and initialisation

Syntax:

data_type &ref_var = var;

Where,

• data_type is any data type; user-defined or primitive.
• var is a variable of data type data_type.

Note that the ampersand (&) before the reference variable is compulsory during the declaration of a reference variable.

Use of references in Range-based for loop

When one needs to modify the variable in a loop, using references in a range-based for loop is the best combination. The following program is an example of how to do it:

#include <iostream>
#include <vector>
using namespace std;
int main() {
    vector <int> int_num {1, 2, 3, 4, 5};
    for (int &var: int_num)
        var = var * var;
    for (int var: int_num)
        cout << var << " ";
    return 0;
}

Using references is very efficient as the extra cost of copying each collection element is not incurred. Sometimes this approach can be deadly as this is prone to accidental modifications of the collection elements inside of the loop. To solve this, one can use a const modifier which prohibits modifying the collection elements which are being iterated upon.

#include <iostream>
#include <vector>
using namespace std;
int main() {
    vector <int> int_num {1, 2, 3, 4, 5};
    for (const int &var: int_num)
        var = var * var;
    return 0;
}

Using references in function calls

Similar to the use of references in range-based for loop, using references in function parameters is very efficient. The use of references in this context can be done in 2 scenarios described as follows:

1. When the data of the parameters have to be accessed and not modified
   1. In this scenario, the parameters in the function should be made constant references to the argument passed by the calling function. This prevents accidental modification of the values and reduces the overhead of copying contents to the called function scope as the reference variables are used.
   2. This is illustrated in the following set of examples:

#include <iostream>
#include <vector>
using namespace std;
void print_num(int &num) {
    cout << "Received num: " << num;
}
int main() {
    int num {5};
    print_num(num);
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
void print_num(const int &num) {
    cout << "Received num: " << num;
}
int main() {
    int num {5};
    print_num(num);
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
void print_num(const int &num) {
    cout << "Received num: " << num;
    num++;
}
int main() {
    int num {5};
    print_num(num);
    return 0;
}

2. When the data of the parameters have to be modified
   1. Previously, pointers were an optimal way to modify the values in the functions to reduce the overhead of copying. References provide a cleaner way to achieve the same goal. This is illustrated in the following set of examples:

#include <iostream>
#include <vector>
using namespace std;
void square(int &num) {
    num *= num;
}
int main() {
    int num {5};
    square(num);
    cout << "Square of num: " << num;
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
void square(vector<int> &num) {
    for (int &val : num)
        val *= val;
}
int main() {
    vector <int> num {1, 2, 3, 4, 5};
    square(num);
    for (int &val : num)
        cout << val << " ";
    return 0;
}

Difference between a reference and a pointer

It is common for beginners to get confused between a reference and a pointer. The following table lists the differences between a reference and a pointer.

Reference of pointers

It is possible to have references of pointers. The following example shows the same:

#include <iostream>
using namespace std;
void swap(int * &ptr_var1, int * &ptr_var2){
    int temp = *ptr_var1;
    *ptr_var1 = *ptr_var2;
    *ptr_var2 = temp;
}
int main(){
    int var1 = 5, var2 = 6;
    int *ptr_var1 = &var1, *ptr_var2 = &var2;
    swap(ptr_var1, ptr_var2);
    cout << "var1 is " << var1 << endl;
    cout << "var2 is " << var2;
    return 0;
}

Exercises

1. Write a function which has a reference int variable as a parameter and returns void. The function name should be ‘cube’ and it should save the cube of the parameter to itself.
2. Write a function which has a reference vector variable and returns void. This function should square all the elements of the vector.

L-values and R-values

L-values

• It is an object that occupies a location in memory and is addressable.
• These are modifiable if they are not constants.
• All variables with valid memory allocation are l-values.
• The name l-value comes from the fact that these entities can be kept in the left hand side of an equality operator: x = 100;

R-values

• The constant literals with no memory are r-values. These essentially cannot be placed in the left hand side of the equality operator, hence the name r-value.
• Example “String Literal”, 1, (10 + 20).
• Assigning values to r-values is illegal:
  • "String literal" = str;
• Hence we cannot create a reference to an r-value. This is especially important when we are passing values to a function. Consider the following program:

#include <iostream>
#include <vector>

using std::cout;

int double_it(int &a) {
    return a * 2;
}

int main() {
    int n = 5;
    cout << double_it(n); // Legal
    cout << double_it(5); // Illegal
    return 0;
}