Till now, we have read that C++ supports two types of variables:
How to create a reference?
Reference can be created by simply using an ampersand (&) operator. When we create a variable, then it occupies some memory location. We can create a reference of the variable; therefore, we can access the original variable by using either name of the variable or reference. For example,
Now, we create the reference variable of the above variable.
The above statement means that 'ref' is a reference variable of 'a', i.e., we can use the 'ref' variable in place of 'a' variable.
C++ provides two types of references:
References to non-const values
It can be declared by using & operator with the reference type variable.
References as aliases
References as aliases is another name of the variable which is being referenced.
Let's look at a simple example.
In the above code, we create a variable 'a' which contains a value '70'. We have declared two reference variables, i.e., b and c, and both are referring to the same variable 'a'. Therefore, we can say that 'a' variable can be accessed by 'b' and 'c' variable.
Value of a is :70 Value of b is :70 Value of c is :70
Properties of References
The following are the properties of references:
It must be initialized at the time of the declaration.
In the above code, we have created a reference variable, i.e., 'b'. At the time of declaration, 'a' variable is assigned to 'b'. If we do not assign at the time of declaration, then the code would look like:
The above code will throw a compile-time error as 'a' is not assigned at the time of declaration.
value of a is 10
It cannot be reassigned means that the reference variable cannot be modified.
In the above code, 'y' reference variable is referring to 'x' variable, and then 'z' is assigned to 'y'. But this reassignment is not possible with the reference variable, so it throws a compile-time error.
References can also be passed as a function parameter. It does not create a copy of the argument and behaves as an alias for a parameter. It enhances the performance as it does not create a copy of the argument.
Let's understand through a simple example.
In the above code, we are swapping the values of 'a' and 'b'. We have passed the variables 'a' and 'b' to the swap() function. In swap() function, 'p' is referring to 'a' and 'q' is referring to 'b'. When we swap the values of 'p' and 'q' means that the values of 'a' and 'b' are also swapped.
value of a is :10 value of b is :9
References as shortcuts
With the help of references, we can easily access the nested data.
In the above code, we are trying to access the 'id' of the profile struct of the employee. We generally access this member by using the statement e.p.id, but this would be a tedious task if we have multiple access to this member. To avoid this situation, we create a reference variable, i.e., ref, which is another name of 'e.p.id'.