Что означает авто & amp; Расскажи нам?

Используя auto&& var = <initializer> ты говоришь: Я приму любой инициализатор независимо от того, является ли он выражением lvalue или rvalue, и я сохраню его константу. Это обычно используется для пересылка (обычно с T&&). Причина, по которой это работает, заключается в том, что «универсальная ссылка», auto&& или же T&&будет привязывать к что-нибудь.

Вы можете сказать, ну почему бы просто не использовать const auto& потому что это будет также привязать к чему-либо? Проблема с использованием const Ссылка в том, что это const! Вы не сможете позже связать его с любыми неконстантными ссылками или вызвать любые функции-члены, которые не помечены const,

В качестве примера представьте, что вы хотите получить std::vectorВозьмите итератор к его первому элементу и измените значение, на которое указывает этот итератор:

auto&& vec = some_expression_that_may_be_rvalue_or_lvalue;
auto i = std::begin(vec);
(*i)++;

Этот код будет прекрасно компилироваться независимо от выражения инициализатора. Альтернативы auto&& потерпеть неудачу следующими способами:

auto         => will copy the vector, but we wanted a reference
auto&        => will only bind to modifiable lvalues
const auto&  => will bind to anything but make it const, giving us const_iterator
const auto&& => will bind only to rvalues

Так что для этого, auto&& работает отлично! Пример использования auto&& как это в диапазоне на основе for петля. Увидеть мой другой вопрос Больше подробностей.

Если вы тогда используете std::forward на ваше auto&& ссылка для сохранения того факта, что изначально она была либо lvalue, либо rvalue, ваш код говорит: Теперь, когда я получил ваш объект из выражения lvalue или rvalue, я хочу сохранить значение, которое у него было изначально, чтобы я мог использовать его наиболее эффективно — это может сделать его недействительным. Как в:

auto&& var = some_expression_that_may_be_rvalue_or_lvalue;
// var was initialized with either an lvalue or rvalue, but var itself
// is an lvalue because named rvalues are lvalues
use_it_elsewhere(std::forward<decltype(var)>(var));

Это позволяет use_it_elsewhere вырвать его внутренности ради производительности (избегая копий), когда исходный инициализатор был изменяемым значением.

Что это означает относительно того, можем ли мы или когда мы можем украсть ресурсы у var? Ну так как auto&& будет привязан к чему-либо, мы не можем попытаться вырвать vars s внутренности — это вполне может быть lvalue или даже const. Мы можем однако std::forward это к другим функциям, которые могут полностью разрушить его внутренности. Как только мы сделаем это, мы должны рассмотреть var находиться в недопустимом состоянии.

Теперь давайте применим это к случаю auto&& var = foo();, как указано в вашем вопросе, где foo возвращает T по значению. В этом случае мы точно знаем, что тип var будет выведено как T&&, Поскольку мы точно знаем, что это значение, нам не нужно std::forwardразрешение украсть его ресурсы. В этом конкретном случае знаю это foo возвращается по значению, читатель должен просто прочитать это как: Я беру ссылку на временное возвращение из fooтак что я могу с радостью отойти от этого.

В качестве дополнения, я думаю, что стоит упомянуть, когда такое выражение, как some_expression_that_may_be_rvalue_or_lvalue может появиться, кроме ситуации «хорошо, ваш код может измениться». Итак, вот надуманный пример:

std::vector<int> global_vec{1, 2, 3, 4};

template <typename T>
T get_vector()
{
return global_vec;
}

template <typename T>
void foo()
{
auto&& vec = get_vector<T>();
auto i = std::begin(vec);
(*i)++;
std::cout << vec[0] << std::endl;
}

Вот, get_vector<T>() это то прекрасное выражение, которое может быть lvalue или rvalue в зависимости от универсального типа T, Мы существенно изменим тип возвращаемого значения get_vector через параметр шаблона foo,

Когда мы звоним foo<std::vector<int>>, get_vector вернусь global_vec по значению, которое дает выражение Rvalue. В качестве альтернативы, когда мы звоним foo<std::vector<int>&>, get_vector вернусь global_vec по ссылке, в результате чего получается выражение lvalue.

Если мы делаем:

foo<std::vector<int>>();
std::cout << global_vec[0] << std::endl;
foo<std::vector<int>&>();
std::cout << global_vec[0] << std::endl;

Мы получаем следующий результат, как и ожидалось:

2
1
2
2

Если бы вы должны были изменить auto&& в коде к любому из auto, auto&, const auto&, или же const auto&& тогда мы не получим желаемого результата.

Альтернативный способ изменить логику программы в зависимости от того, auto&& ссылка инициализируется выражением lvalue или rvalue для использования черт типа:

if (std::is_lvalue_reference<decltype(var)>::value) {
// var was initialised with an lvalue expression
} else if (std::is_rvalue_reference<decltype(var)>::value) {
// var was initialised with an rvalue expression
}