Using a const reference to a returned by value value

Question

Look at the following example:

string foo(int i) {
  string a;
  ... Process i to build a ...
  return a;
}

void bar(int j) {
  const string& b = foo(j);
  cout << b;
}

I know RVO and NRVO, but I thought that in order to do that, I need to write bar as the following:

void bar(int j) {
  string b = foo(j);
  cout << b;
}

Both versions seem to work, and I believe with the same performance. Is it safe to use the first version (with the const reference)?

Thanks.

score 7 · Accepted Answer · answered May 24 '11 at 08:21

7

Assigning a temporary to a const reference is perfectly valid. The temporary object will live until the reference goes out of scope.

While it does not make sense in your example, this feature is often used for function arguments:

string foo(int i) {
    string a;
    // ...
    return a;
}

void bar(const string& str) {
    // ...
}

void buzz() {
    // We can safely call bar() with the temporary string returned by foo():
    bar(foo(42));
}

answered May 24 '11 at 08:21

Ferdinand Beyer

64,979
15
154
145

How would this be implemented by a compiler? Would it refrain from unwinding the part of the stack used by `foo`'s local variables? What about if `foo` uses a huge amount of stack space? – jhourback Jan 25 '21 at 20:31

score 3 · Answer 2 · answered May 24 '11 at 08:13

3

It's safe in this simple case. It's easy to add code which makes it unsafe, however, and it's confusing to anyone who knows C++: why do you need a reference here? There's no reason to do so, and such code should generally be avoided.

answered May 24 '11 at 08:13

James Kanze

150,581
18
184
329

It's useful if I will change foo to return const & in the future. – brickner May 25 '11 at 10:47
If you change the semantics of `foo`, you'll probably have to change a lot more things than just this. – James Kanze May 25 '11 at 11:55

score 2 · Answer 3 · answered May 24 '11 at 08:15

2

A const-reference is allowed to bind to a temporary, and the live-time of the temporary will be extended to the live-time of the const-reference. So yes, it is safe to use.

answered May 24 '11 at 08:15

Xeo

129,499
52
291
397

score 2 · Answer 4 · edited May 25 '11 at 10:46

Is it safe to use the first version (with the const reference)?

Yes. Binding a temporary to a const reference lengthens the lifetime of the temporary to the lifetime of the reference itself, which is the scope in which the reference is declared:

void f()
{
   const string& a = foo(10);

   //some work with a

   {
     const string& b = foo(20);

     //some work with b

   } //<----- b gets destroyed here, so the temporary also gets destroyed!

   //some more work with a

} //<----- a gets destroyed here, so the temporary associated 
                                  //with it also gets destroyed!

Herb Sutter has explained this in great detail in his article:

A Candidate For the “Most Important const”

It is worth reading. Must read it.

Using a const reference to a returned by value value

4 Answers4