Время жизни временного объекта, к которому привязано несколько ссылок в C++.

Это дефект в том разделе, о котором я сообщил как http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1299 .

Предлагаемая резолюция заключается в добавлении термина «временные выражения». Продление срока службы происходит только для объектов, на которые ссылаются временные выражения.

Вот мой оригинальный отчет, который я отправил по электронной почте в частном порядке. думаю понятно о чем речь

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

Временные объекты создаются с помощью определенных операций, таких как функциональные приведения к типам классов. Временные объекты имеют ограниченное указанное время жизни.

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

Несколько абзацев относятся к «временным», но явно не указывают, относятся ли они к временным объектам, на которые ссылаются произвольные выражения, или они относятся только к временным выражениям. Параграфы о RVO (параграф 12.8p31) используют «временный» в смысле временных объектов (они говорят такие вещи, как «временный объект класса, который не был привязан к ссылке»). Пункты о продлении срока службы (подпункт 12.2) относятся к обоим видам временных изделий. Например, в дальнейшем «*this» не рассматривается как временное, даже если оно относится к временному

struct A { A() { } A &f() { return *this; } void g() { } };

// call of g() is valid: lifetime did not end prematurely
// at the return statement
int main () { A().f().g(); }

В качестве другого примера, основная проблема 462 касается временных выражений (делая выражение оператора запятой временным, если левый операнд был одним). Это очень похоже на понятие «битовые поля lvalue». Lvalues, которые отслеживают, что они ссылаются на битовые поля во время трансляции, так что чтение из них может действовать соответствующим образом, и чтобы определенные сценарии связывания ссылок могли выдавать диагностику.

Что вам нужно знать, так это то, что ссылочный возвращаемый тип не считается временным для целей этого раздела и никогда не приведет к увеличению времени жизни.

(Педантичное примечание: стандарт требует, чтобы ссылка была привязана к xvalue, а не просто к временному. Вторая ссылка связана через lvalue, а не через xvalue.)

Ваш первый пример возвращает висячую ссылку - строка cout имеет неопределенное поведение. Он может напечатать Hello!, и это ничего не докажет.

Вот более простой пример:

template<class T>
const T& ident(const T& in) { return in; }

int main(void)
{
    const X& ref1 = X(1); // lifetime extension occurs
    const X& ref2 = ident(X(2)); // no lifetime extension
    std::cout << "Here.\n";
}

Порядок строительства и разрушения следующий:

X(1)
X(2)
~X() for X(2) object
"Here." is printed
~X() for X(1) object

Первая функция, представленная в вопросе,

const std::string &f() {
    const std::string &s = "hello";
    static const std::string &ss = s;
    return ss;
}

дает неопределенное поведение, если используется возвращенная ссылка. Упомянутый объект перестает существовать, когда возвращается первый вызов функции. А при последующих вызовах ss будет висячей ссылкой.

Контекст параграфа о продлении срока действия стандарта:

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

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

Один из двух контекстов, за четырьмя отмеченными исключениями,

когда ссылка привязана к [такому] временному

В приведенном выше коде временное std::string, созданное полным выражением "hello", привязано к ссылке s, а время жизни расширено до области s, которая является телом функции.

Последующее объявление и инициализация статической ссылки ss не включает полное выражение, создающее временное. Его выражение инициализатора s не является временным: это ссылка на локальный объект. Следовательно, это выходит за рамки контекста, охватываемого параграфом о продлении срока службы.

Но как мы узнаем, что имелось в виду именно это? Что ж, отслеживание того, ссылается ли ссылка динамически на что-то, что изначально было временным, невычислимо для общего случая, а стандарт языка C++ не включает таких надуманных понятий. Так что это просто, на самом деле.

ИМХО более интересный случай, wrt. формальные правила, это

#include <string>
#include <iostream>
using namespace std;

template< class Type >
auto temp_ref( Type&& o ) -> T& { return o; }

auto main() -> int
{
    auto const& s = temp_ref( string( "uh" ) + " oh!" );
    cout << s << endl;
}

Я утверждаю, что здесь нет продления жизни, и что оператор вывода, использующий ссылку s, использует висячую ссылку, в результате чего получается UB.

И я думаю, что этот вывод, в отличие от примера, выбранного ОП, нельзя аргументировать исключительно на основе формулировки стандарта, потому что (мне кажется) формулировка стандарта немного ущербна. Что он не может сделать исключение для ссылочных типов. Но я могу ошибаться, и если я узнаю об этом, я обновлю этот ответ, чтобы отразить это новое понимание.