What are Reference Collapsing Rules in C++?

In C++, we have a very useful feature called reference collapsing, which comes into play when dealing with references to references, especially in the context of templates. It is very important to make templates work seamlessly with references, ensuring that code behaves consistently and as expected.

In this article, we will learn what reference collapsing is, why it is important, and how it works in C++.

What is Reference Collapsing in C++?

In C++, a reference is an alias for another variable. References themselves cannot be references, meaning we can't have a reference to a reference directly. However, in templates or other scenarios involving type deduction, we may encounter situations where a reference to a reference could theoretically exist. Reference collapsing rules dictate how these references are handled by the compiler to produce a valid type.

Need of Reference Collapsing

Reference collapsing is used for writing generic and flexible code using templates. Without reference collapsing, templates that involve references could lead to complex and unintuitive behavior or even compilation errors. Reference collapsing rules ensure that templates behave predictably, making it easier to write and maintain code.

Reference Collapsing Rules

The rules of reference collapsing in C++ can be summarized as follows:

• T& & becomes T&: If we try to form a reference to a reference where both are lvalue references (&), it collapses to a single lvalue reference.
• T& && becomes T&: If we have an lvalue reference to an rvalue reference, it collapses to an lvalue reference.
• T&& & becomes T&: If we have an rvalue reference to an lvalue reference, it collapses to an lvalue reference.
• T&& && becomes T&&: If we have an rvalue reference to an rvalue reference, it remains an rvalue reference.

These rules ensure that no matter how references are combined, the result is a valid reference type.

Example of Reference Collapsing

The below example will help to understand how reference collapsing rules are applied.

// C++ program demonstrating reference collapsing rules
// using various template functions
#include <iostream>
#include <utility> 
using namespace std;

// Function that demonstrates lvalue reference handling
template<typename T>
void func1(T& a) {
  
    // Inform that func1 is called with lvalue reference (T&)
    cout << "func1 called with lvalue reference (T&)" << endl;
    
    // T& remains as T&
    T& ref = a;
    
    // Display the value of ref
    cout << "Value of ref: " << ref << endl;
}

// Function that demonstrates rvalue reference handling and collapsing when passed an lvalue
template<typename T>
void func2(T&& a) {
  
    // Inform that func2 is called with rvalue reference (T&&)
    cout << "func2 called with rvalue reference (T&&)" << endl;
    
    // T&& remains T&& or collapses to T& if T is lvalue reference
    T&& ref = forward<T>(a);
    
    // Display the value of ref
    cout << "Value of ref: " << ref << endl;
}

int main() {
  
    // Initialize an integer variable x with value 10
    int x = 10;

    // Call func1 with lvalue (x)
    cout << "Calling func1 with lvalue (x):" << endl;
    func1(x);  // T deduced as int, ref becomes int&

    // Call func2 with lvalue (x)
    cout << "\nCalling func2 with lvalue (x):" << endl;
    func2(x);  // T deduced as int&, ref becomes int& due to reference collapsing

    // Call func2 with rvalue (std::move(x))
    cout << "\nCalling func2 with rvalue (move(x)):" << endl;
    func2(move(x));  // T deduced as int, ref becomes int&&

    return 0;
}

Calling func1 with lvalue (x):
func1 called with lvalue reference (T&)
Value of ref: 10

Calling func2 with lvalue (x):
func2 called with rvalue reference (T&&)
Value of ref: 10

Calling func2 with rvalue (move(x)):
func2 called with rvalue reference (T&&)
Value of ref: 10

Conclusion

Reference collapsing is an advanced but essential concept in C++ that ensures templates and functions work correctly with different types of references. By understanding and applying the rules of reference collapsing, we can write more flexible and efficient code, particularly when working with templates and perfect forwarding. This feature of C++ helps maintain the consistency and predictability of reference types, making C++ a more powerful and versatile language for system and application development.