Объявление ссылки

Схлопывание ссылок

Ссылки на ссылки можно сформировать с помощью манипуляций с типами в шаблонах или typedef-объявлениях; в этом случае применяются правила схлопывания ссылок: ссылка на rvalue на ссылку на rvalue схлопывается в ссылку на rvalue, а все остальные комбинации образуют ссылку на lvalue:

typedef int&  lref;
typedef int&& rref;
int n;

lref&  r1 = n; // type of r1 is int&
lref&& r2 = n; // type of r2 is int&
rref&  r3 = n; // type of r3 is int&
rref&& r4 = 1; // type of r4 is int&&

(Это правило вместе со специальными правилами выведения аргументов шаблона в случаях, когда в шаблоне функции используется T&&, образует правила, благодаря которым возможен std::forward.)

Ссылки на rvalue

Ссылки на rvalue можно использовать, чтобы продлить время жизни временных объектов (обратите внимание: ссылки на const lvalue тоже могут продлить время жизни временных объектов, но через них нельзя изменять эти объекты):

#include <iostream>
#include <string>

int main()
{
    std::string s1 = "Test";
//  std::string&& r1 = s1;           // error: can't bind to lvalue

    const std::string& r2 = s1 + s1; // okay: lvalue reference to const extends lifetime
//  r2 += "Test";                    // error: can't modify through reference to const

    std::string&& r3 = s1 + s1;      // okay: rvalue reference extends lifetime
    r3 += "Test";                    // okay: can modify through reference to non-const
    std::cout << r3 << '\n';
}

Что важнее, если у функции есть перегрузки со ссылкой на rvalue и ссылкой на lvalue, перегрузка со ссылкой на rvalue связывается с rvalue (включая prvalue и xvalue), а перегрузка со ссылкой на lvalue — с lvalue:

#include <iostream>
#include <utility>

void f(int& x)
{
    std::cout << "lvalue reference overload f(" << x << ")\n";
}

void f(const int& x)
{
    std::cout << "lvalue reference to const overload f(" << x << ")\n";
}

void f(int&& x)
{
    std::cout << "rvalue reference overload f(" << x << ")\n";
}

int main()
{
    int i = 1;
    const int ci = 2;
    
    f(i);  // calls f(int&)
    f(ci); // calls f(const int&)
    f(3);  // calls f(int&&)
           // would call f(const int&) if f(int&&) overload wasn't provided
    f(std::move(i)); // calls f(int&&)

    // rvalue reference variables are lvalues when used in expressions
    int&& x = 1;
    f(x);            // calls f(int& x)
    f(std::move(x)); // calls f(int&& x)
}

Это позволяет автоматически выбирать подходящие конструкторы перемещения, операторы присваивания перемещением и другие функции с поддержкой перемещения (например, std::vector::push_back()).

Поскольку ссылки на rvalue могут связываться с xvalue, они могут ссылаться на нет временные объекты:

int i2 = 42;
int&& rri = std::move(i2); // binds directly to i2

Это позволяет переместить данные из объекта в области видимости, который больше не нужен:

std::vector<int> v{1, 2, 3, 4, 5};
std::vector<int> v2(std::move(v)); // binds an rvalue reference to v
assert(v.empty());

Пересылающие ссылки

Пересылающие ссылки — это особый вид ссылок, сохраняющих категорию значения аргумента функции, что позволяет пересылать его с помощью std::forward. Пересылающей ссылкой является:

template<class T>
int f(T&& x)                      // x is a forwarding reference
{
    return g(std::forward<T>(x)); // and so can be forwarded
}

int main()
{
    int i;
    f(i); // argument is lvalue, calls f<int&>(int&), std::forward<int&>(x) is lvalue
    f(0); // argument is rvalue, calls f<int>(int&&), std::forward<int>(x) is rvalue
}

template<class T>
int g(const T&& x); // x is not a forwarding reference: const T is not cv-unqualified

template<class T>
struct A
{
    template<class U>
    A(T&& x, U&& y, int* p); // x is not a forwarding reference: T is not a
                             // type template parameter of the constructor,
                             // but y is a forwarding reference
};

auto&& vec = foo();       // foo() may be lvalue or rvalue, vec is a forwarding reference
auto i = std::begin(vec); // works either way
(*i)++;                   // works either way

g(std::forward<decltype(vec)>(vec)); // forwards, preserving value category

for (auto&& x: f())
{
    // x is a forwarding reference; this is a common way to use range for in generic code
}

auto&& z = {1, 2, 3}; // *not* a forwarding reference (special case for initializer lists)

См. также выведение аргументов шаблона и std::forward.