Can I use rvalue reference to temporary? Is it undefined behavior or not?

Question

Updating the question Why this two rvalue references examples have different behavior?:

Source code:

int a = 0;
auto && b = a++;
++a;
cout << a << b << endl;

prints 20

Is it undefined behavior (UB) to use b after the a++ call? Maybe we cannot use b because it refers to a temporary?

This document could be useful to you : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1993/N0345.pdf — dkg, Feb 10 '16 at 13:01
Hmm, from my understanding it's not as the value of the temporary from `a++`is "moved" to `b`. Yet I think it might be UB if you would use `auto && b = ++a;` as in your example in the other question. But I may be totally wrong as I am not really familiar with move semantics. — Simon Kraemer, Feb 10 '16 at 13:04
@dkg Is it actual for references to rvalues introduced in C++11 (`&&`)? — vladon, Feb 10 '16 at 13:05
@SimonKraemer and OP you may want to see: http://stackoverflow.com/questions/13230480/what-does-auto-tell-us — NathanOliver, Feb 10 '16 at 13:09

score 13 · Answer 1 · answered Feb 10 '16 at 13:01

13

The code is fine. b refers to a lifetime-extended object that is the result of the expression a++, which is a different object from a. (Binding a temporary object to a reference extends the lifetime of the object to that of the reference.) You can use and modify both objects.

answered Feb 10 '16 at 13:01

Kerrek SB

464,522
92
875
1,084

but in C++98 it was `binding a temporary to a CONST reference extends...` so that's quite scary, thus the need to check twice :) – v.oddou Mar 22 '19 at 06:59
@v.oddou: I think that's a misleading way to think about it. What matters is the "binding to a reference". Whether you *can* in fact bind to a reference is a separate, unrelated rule. In C++98 rvalues can bind to const lvalue references only; in C++11 they can also bind to any (cv-compatible) rvalue reference. – Kerrek SB Mar 22 '19 at 10:18

Niall · Accepted Answer · 2016-02-10T18:57:32.770

7

No it is not undefined behavior (UB). It's fine - you can modify the contents of the temporary here (so long as the reference is valid for the lifetime of the temporary, in this case the bind to the rvalue reference extends that lifetime of the rvalue to the lifetime of the reference).

A more general question is; is it UB to modify a temporary through the rvalue reference? No it is not UB. Move semantics, where the "moved-to" object "steals" the "moved-from" object's contents, relies on this to be well defined.

edited Feb 10 '16 at 18:57

answered Feb 10 '16 at 13:02

Niall

30,036
10
99
142

How about `auto && b = ++a;`? Is it safe to use `a` after this assigment? – Simon Kraemer Feb 10 '16 at 13:06
6

Yes it is. The `auto&&` is then not an rvalue reference, the references collapse such that b is `int&` and binds an lvalue reference normally would. – Niall Feb 10 '16 at 13:08
1

Ah ok, so there is no implicit move from `a` to `b`!? Thank you – Simon Kraemer Feb 10 '16 at 13:10

score 3 · Answer 3 · answered Feb 10 '16 at 13:12

Taking a reference to a temporary extends its lifetime to the end of lifetime of that reference.

ISO/IEC 14882 § 12.2/5:

The second context is when a reference is bound to a temporary. The temporary to which the reference is bound or the temporary that is the complete object of a subobject to which the reference is bound persists for the lifetime of the reference […]

Can I use rvalue reference to temporary? Is it undefined behavior or not?

3 Answers3

Linked