lifetime extension for function taking parameter by const& and returning by const&

Question

In C++ when you have the following:

std::string get_string();
std::string const& v = get_string();

The lifetime of the temporary returned from get_string() is extended for the same lifetime of the reference v;

If I have the following:

std::string const& get_string(std::string const& p) {
  return p;
}

std::string const& v = 
get_string(std::string{"Hello"});

Is the lifetime of the temporary extended? or is this a dangling reference;

My understanding is that the temporary is bound to the lifetime of p and that only exists for the duration of the function and that secondary references to the temporary dont extend the lifetime.

What is the expected result?

This seems to be a much better version of the old https://stackoverflow.com/q/14735630/560648 — Lightness Races in Orbit, May 16 '19 at 10:56

score 1 · Accepted Answer · edited Jun 20 '20 at 09:12

1

Yes, the lifetime of the temporary is not extended further more; after the full expression the reference v becomes dangled.

std::string const& v = get_string(std::string{"Hello"});
// v becomes dangled now

My understanding is that the temporary is bound to the lifetime of p and that only exists for the duration of the function

To be precisely, the temporary exists until the end of the full expression, not only the duration of the function.

a temporary bound to a reference parameter in a function call exists until the end of the full expression containing that function call: if the function returns a reference, which outlives the full expression, it becomes a dangling reference.

In general, the lifetime of a temporary cannot be further extended by "passing it on": a second reference, initialized from the reference to which the temporary was bound, does not affect its lifetime.

That means something like auto sz = get_string(std::string{"Hello"}).size(); is fine.

edited Jun 20 '20 at 09:12

Community

1
1

answered May 16 '19 at 10:35

songyuanyao

169,198
16
310
405

So it is because it is bound to p and in the parameter list and there for at the end of the call cant be extended to v. so v is dangling yeah? – Blair Davidson May 16 '19 at 10:40
@BlairDavidson I think this way of thinking is right; I added some quotes in my answer. – songyuanyao May 16 '19 at 10:44
The odd thing is this works in gcc so im a bit confused. – Blair Davidson May 16 '19 at 10:46
@BlairDavidson Dereference on dangled reference leads to UB; anything is possible. Even it seems working well. – songyuanyao May 16 '19 at 10:47
Is the full expression just right hand side of the assignment operator = or both the left and right side of the assignment operator – Blair Davidson May 16 '19 at 11:23
@BlairDavidson Both. From the start to the `;`. :) – songyuanyao May 16 '19 at 11:24
So one possible way to remove the undefined behaviour is to declare v as std::string without the reference. – Blair Davidson May 16 '19 at 11:35
Assume these rules are the same for function taking and returning an rvalue reference? – Blair Davidson May 16 '19 at 13:04
@BlairDavidson Yes and yes. – songyuanyao May 16 '19 at 15:37

lifetime extension for function taking parameter by const& and returning by const&

1 Answers1