Для чего нужна двойная ссылка &&?

Question

[Kevsh]

На данный момент я ссылку понимаю так:

int a = 5;
int& b = a;

В таком коде мы как бы создаём псевдоним для a, который называется b. То есть обе эти переменные указывают на одну и ту же область памяти, у этих переменных одинаковый адрес.
Такая логика плюс-минус работает с такой записью:
const int& c = 5;
Я представляю это так: 5 находится в области памяти, записать в которую мы ничего не можем (из-за этого мы не можем написать, допустим, 5 = a), но при этом мы можем из этой области читать. Получается, что запись без const опасна - мы рискуем изменить что-то в этой памяти, а с const всё хорошо - мы создали псевдоним для области памяти, которую мы можем только читать.
А вот это что такое и какой у этого смысл, я не могу понять:
int&& d = 5;
Псевдоним для псевдонима... не могу понять. Чувствуется потребность в знании языка ассемблера, но я хотел бы для начала основы понять.

Comments

[Евгений Шатунов]

Владимир Коршунов

Я представляю это так: 5 находится в области памяти, записать в которую мы ничего не можем (из-за этого мы не можем написать, допустим, 5 = a), но при этом мы можем из этой области читать.

Этот момент ты понимаешь неправильно.
5 - это литерал с категорией prvalue. Категория выражения говорит о том, что выражение имеет полный тип и не является полиморфным, не является массивом, лишено идентичности.
Но вот что важно! Для такого выражения невозможно получить адрес и такое выражение не может находиться в левой части операции присвоения.
Вот почему 5 = a приводит к ошибке трансляции.

Но что тогда происходит в выражении const int& c = 5;?
Тут происходит инициализация константной ссылки. prvalue могут использоваться для инициализации только константной ссылки, в следствии чего создается локальный временный объект с типом эквивалентным подлежащему типу ссылки. Литерал же используется для инициализации этого локального временного. Обычно локальный временный уничтожается сразу после завершения операции. Однако здесь вступает в силу продление жизни временного за счет именно инициализации константной ссылки.

Код очень простой, но понимать его нужно только правильно. Иное понимание такого простого кода обычно приводит к неуловимым ошибкам и большим проблемам отладки.
Вот достаточно простой пример такой ошибки. Код работает не так, как написан.

[Kevsh]

Евгений Шатунов, я прогнал у себя ваш пример и у меня отладчик в цикл даже не заходит. Что тут должно вызвать ошибку мне не очень ясно, если честно. Мы возвращаем ссылку на вектор - то есть в цикле мы работаем прямо с тем вектором, который создаётся при создании объекта класса. Такая логика вроде работает, если переписать всё вот таким образом:

auto vect = Foo{}.GetValues();

for (const auto& value : vect)
{
	std::cout << value << std::endl;
}

Видимо тут проблема в том, что результат вызова функции никуда не сохраняется.
Ещё возник вопрос, а есть ли разница между этими вариантами? В обоих случаях c имеет один и тот же адрес.

#include <iostream>
int main()
{
	int a = 5;
	int& b = a;
	int& c = b;
}

#include <iostream>
int main()
{
	int a = 5;
	int& b = a;
	int& c = a;
}

[Евгений Шатунов]

Владимир Коршунов,

Ещё возник вопрос, а есть ли разница между этими вариантами? В обоих случаях c имеет один и тот же адрес.

Нет, разницы между этими двумя примерами нет никакой. Ссылка, согласно стандарту, это эфемер. У ссылки не описывается характеристик размера или выравнивания. С т.з. стандарта ссылка присутствует в коде только до момента окончания 7й стадии трансляции - стадии компиляции кода.
На практике, все трансляторы под ссылкой понимают нечто иное и не такое эфемерное. Но суть сейчас в том, что на счет ссылки говорит стандарт.

я прогнал у себя ваш пример и у меня отладчик в цикл даже не заходит.

Это все потому что ты пока еще не очень хорошо ориентируешься между стандартами. В 14-м стандарте этот код может даже работать так как он написан. В 17-м поведет себя так, как я описал и это будет правильно. Если у тебя стандарт 17й и нет входа в цикл, то все тоже нормально.
Все потому что в моем примере присутствует неопределенное поведение в следствии обращения к висячей ссылке.
Я изначально написал что пример у тебя простой, но понимать его нужно строго правильно.

В 17-м стандарте мой пример будет эквивалентен вот этому коду.

int main()
{
	const std::vector<int>& data{ Foo{}.GetValues() };
	auto current = data.begin();
	auto end = data.end();
	for( ; current != end; ++current )
	{
		const auto& value = *current;
		std::cout << value << std::endl;
	}
}

Теперь проблему лучше видно?
Давай обратим внимание на std::vector<int>& data{ Foo{}.GetValues() }; и то, что я писал комментарием выше. Локальный временный уничтожается сразу после завершения операции.
Сразу же после инициализации data становится висячей ссылкой. Следующая же строка уже вносит в код UB.

[Kevsh]

Евгений Шатунов, а вот этот пример у меня даже не компилируется, ну и ладно. Как я понял - был создан временный объект, мы вернули константную ссылку на его поле, после чего объект сразу же уничтожается, от чего ссылка, с помощью которой мы создали вектор data, стала висячей. Вы хотели сказать, что нельзя возвращать из функции ссылку на временный объект? Не очень понятно, какая разница - возвращать константную ссылку или обычную (именно в вашем примере)?
Кстати о ссылках на временные объекты:

class A
{
private:
	int value;
public:
	A(int x) { this->value = x; };
	int& getValue() { return this->value; };
};

A& getRef()
{
	A a(5);
	return a;
}

int main()
{
	A& m = getRef();
	std::cout << m.getValue();

Вот тут всё понятно - выводится мусор, потому что возвращаемый по ссылке объект уже уничтожен.
А вот тут другая ситуация:

int& getRef()
{
	A a(5);
	return a.getValue();
}

int main()
{
	int& m = getRef();
	std::cout << m;
}

Тут возвращается ссылка на поле уничтожаемого объекта, а выводится все корректно. Странно

[Евгений Шатунов]

Владимир Коршунов
int& m = getRef(); - тут ровно так же UB и, на самом деле, это чистая случайность что вывелась 5.
int - это очень плохой тип для таких проверок. Измени код чтобы везде использовался std::shared_ptr<int> и посмотри что будет. Транслятор тебе даже пометил неприемлемость возврата ссылки на локальный объект.
Продление жизни временного работает только при инициализации константных ссылок.

Вы хотели сказать, что нельзя возвращать из функции ссылку на временный объект?

Это - само собой разумеющееся. В коде моих примеров ведь нет возврата временных объектов по ссылке.
Я хотел сказать что нужно правильно понимать время жизни локальных временных и продление их жизни через инициализацию константной ссылки.
const int& c = 5; - тут локальный временный int( 5 ) продолжит жить после инициализации локальной ссылки.
for( const auto& value : Foo{}.GetValues() ) - тут локальный временный Foo{} уничтожается еще до выборки первого элемента.

Answer 1

[Mercury13]

Ссылка на временный объект.

Прямо (int&& d = 5) используется крайне редко, чтобы продлить время жизни временному объекту.

Куда чаще оно используется в типах возврата (string&& Container::give()), и означает: это ссылка на объект, который спокойно можно выпотрошить. Или в типах параметров — Container& Container::operator = (string&& x): то есть принимает объект, который больше не нужен.

Для чего потрошить объекты? Вот представьте себе код.

std::vector<int> doSmth() {
  std::vector<int> r;
  r.push_back(42);
  return r;
}
...
std::vector<int> a = doSmth();

Забьём на необязательные оптимизации — как эта штука будет действовать по семантике Крестов?
std::vector<int> r; — создадим в стековом фрейме переменную r.
return r; — vector(const vector&) в какое-то место, предложенное вызывающей функцией.
std::vector<int> a = doSmth(); — vector(const vector&) из этого места в a.

Си++17 ТРЕБУЕТ, чтобы подобный возврат гарантированно вызывал ОДИН конструктор копирования (а если конструировать на месте вроде return vector<int>{ 42 }; — то ни одного), но у нас-то Си++03. Не много конструкторов? А ведь зная, что объект больше не нужен, можем просто перенести указатель из одного вектора в другой, точка — даже впрямую, без оптимизаций, никаких перевыделений памяти. Вот этот прямой перенос указателей я и назвал словом «выпотрошить объект».

Пример 1: container = string("alpha") + "bravo"; Тут в контейнер перемещается временная строка.
Пример 2: string a = "alpha"; container = a; Не компилируется: строка a не временная.
Пример 3. container1 = container2.give(); Перенос строки из контейнера в контейнер без выделения памяти.
Пример 4: string a = "alpha"; container = std::move(a); Компилируется (мы функцией move сказали: с обычным объектом обращаться как с временным), но в результате в строке a может быть что угодно и не стоит закладываться на дальнейшее её значение. Но объект после потрошения в любом случае должен быть корректным, ведь ему ещё вызывать деструктор :)

Последний вопрос: кто потрошит? Функция, которая принимает временную ссылку как параметр. В данном случае Container::op=. Чем потрошит? — ну, например, кодом myString=std::move(x) или std::swap(myString, x). А они, в свою очередь — внутренняя string::op= и дружественная swap — прямыми играми с указателями.

Comments

[Kevsh]

Вроде понятно, что если мы видим в списке аргументов функции &&, то мы говорим, что нам этот объект больше не нужен. То есть это имеет смысл использовать только для конструктора переноса, верно? Допустим, вот в таком случае:

void RvalueTest(std::vector<int>&& vectRvalue)
{
	std::vector newVect(vectRvalue);
	std::cout << "Тут, по идее, ничего никуда не копировалось" << std::endl;
}

int main()
{
	setlocale(LC_ALL, "Russian");
	std::vector<int> myVect = { 1, 2, 3, 4, 5 };
	RvalueTest(std::move(myVect));
	std::cout << "Тут должен быть ноль: " << myVect.size();
}

В последней строке должен быть ноль, но выводится 5, почему? Если просто в main'е сделать то же самое, то размер первого вектора будет равен нулю...

[Mercury13]

Владимир Коршунов, Я думал, написать это или нет, но вы задали вопрос.
Снаружи в качестве vectRvalue годится только временный объект. Но внутри этот параметр — ОБЫЧНАЯ ссылка.
Так что надо std::vector newVect(std::move(vectRvalue));

https://mercury13-kiev.livejournal.com/96961.html

[Mercury13]

Владимир Коршунов, Для чего он обычная ссылка? Временная была бы ошибкоопасной: любая потеря данных опаснее любой неоптимальности.

[Mercury13]

Владимир Коршунов, Ну что, понятно?

[Mercury13]

Kevsh, Ну что, понятно?

[Kevsh]

Mercury13, я сейчас немного другим занят, на самообразование времени очень не хватает, извините. Как только время появится - обязательно продолжу разбираться в теме и вам отвечу.

[Mercury13]

Ну что, понятно?

Answer 2

[Александр Ананьев]

Это называется rvalue reference