Slideshow | The C++ rvalue lifetime disaster

class: middle

# The C++ Rvalue Lifetime Disaster

###by Arno Schoedl
###<aschoedl@think-cell.com>

---
#Rvalue References

- STL advocates value semantics
- lead to frequent copying in C++03
- rvalue references invented to avoid copying
  * replaced by more efficent moving

```cpp
std::vector< std::vector<int> > vecvec;
std::vector<int> vec={1,2,3};
vecvec.emplace_back( std::move(vec) ); // rvalue reference avoids copy
```

- Increasingly used to manage lifetime
  * C++11 `std::cref`
  * C++20 Ranges
  
--

```cpp
auto rng=std::vector<int>{1,2,3} | std::ranges::view::filter([](int i){ return 0==i%2; });
// DOES NOT COMPILE
```

- `rng` would contain dangling reference to `std::vector<int>`
- So `std::ranges::view::filter` does not compile for rvalues

---
#Rvalue References for Moving - Pitfalls

```cpp
A foo() {
  A const a=...;
  ...
  return std::move(a);
};
```

- What happens?
--

* Copy - cannot move out of `const`

```cpp
A foo() {
  A a=...;
  ...
  return std::move(a);
};
```

- What happens?
--

* Move
  * Best we can do?

---
#Rvalue References for Moving - Pitfalls

```cpp
A foo() {
  A a=...;
  ...
  return a;
};
```

- What happens?
--

* NRVO (Named Return Value Optimization) - copy/move elided
  * `std::move` can make things worse

```cpp
A foo() {
  A const a=...;
  ...
  return a;
};
```

- What happens?
--

* Still NRVO (Named Return Value Optimization) - copy/move elided

---
#Rvalue References for Moving - Pitfalls

```cpp
A foo() {
  if(... condition ...) {
    A const a=...;
    ...
    return a;
  } else {
    A const a=...;
    ...
    return a;
  }
};
```

- What happens?
--

* No NRVO, returned object is not always same one
  * Copy because of `const` :-(

---
#Rvalue References for Moving - Pitfalls

```cpp
A foo() {
  if(... condition ...) {
    A a =...;
    ...
    return a;
  } else {
    A a=...;
    ...
    return a;
  }
};
```

- What happens?
  * Move

---
#Rvalue References for Moving - Pitfalls

```cpp
struct B {
  A m_a;
};

A foo() {
  B b=...;
  ...
  return b.m_a;
};
```

- What happens?
--

* Copy
  * Members do not automatically become rvalues

---
#Rvalue References for Moving - Pitfalls

```cpp
struct B {
  A m_a;
};

A foo() {
  B b=...;
  ...
  return std::move(b).m_a;
};
```

- What happens?
--

* Move
  * Member access of rvalue is rvalue

- Recommendations
  * Make return variables non-`const`
  * Use Clang's `-Wmove`

---
#Temporary Lifetime Extension

```cpp
struct A;

struct B {
private:
  A m_a;
public:
  A const& getA() const& { return m_a; }
};

B b;
auto const& a=b.getA();
```

---
#Temporary Lifetime Extension

```cpp
struct A;

struct B {
private:
  A m_a;
public:
  A const& getA() const& { return m_a; }
};

struct C {
  A getA() const&;
};

B b;
C c;
auto const& a=< b or c >.getA();
```

- `auto const& a=c.getA();` works thanks to _temporary lifetime extension_
- Idea: always write `auto const&`, the right thing happens

---
#Temporary Lifetime Extension vs. Rvalues

```cpp
bool operator<(A const&, A const&);

struct C {
  A getA() const&;
} c1, c2;
auto const& a=std::min( c1.getA(), c2.getA() );
```

```cpp
namespace std {
  template<typename T>
  T const& min( T const& lhs, T const& rhs ) {
    return rhs<lhs ? rhs : lhs;
  }
}
```

- `std::min` forgets about rvalue-ness
- `a` dangles

---
#Temporary Lifetime Extension vs. Rvalues

```cpp
bool operator<(A const&, A const&);

struct C {
  A getA() const&;
} c1, c2;
auto const& a=our::min( c1.getA(), c2.getA() );
```

```cpp
namespace our {
  template<typename Lhs, typename Rhs>
  decltype(auto) min( Lhs&& lhs, Rhs&& rhs ) {
    return rhs<lhs ? std::forward<Rhs>(rhs) : std::forward<Lhs>(lhs);
  }
}
```

- `our::min` correctly returns `A&&`

--
- `a` still dangles
- _temporary lifetime extension does not keep rvalue references alive!_
  * would only be possible by creating a copy

---
#Temporary Lifetime Extension vs. decltype(auto)

```cpp
A some_A();
- or -
A const& some_A();
```

- forwarding return:

```cpp
decltype(auto) foo() {
  return some_A();
}
```

- forwarding return with code in between:

```cpp
??? foo() {
  ??? a = some_A();
  ... do something ...
  return a;
}
```

---
#Temporary Lifetime Extension vs. decltype(auto)

```cpp
decltype(auto) foo() {
  auto const& a = some_A();
  ... do something ...
  return a;
}
```

- creates dangling reference if `some_A()` returns value

```cpp
auto foo() {
  auto const& a = some_A();
  ... do something ...
  return a;
}
```

- always copies

- Problem: temporary lifetime extension lies about its type
  * if `some_A()` returns value, `a` is really value, not reference

---
#auto_cref

- Deprecate temporary lifetime extension
- Automatically declare variable
  * `auto` if constructed from value or rvalue reference, and
  * `auto const&` if constructed from lvalue reference
  
  
--

```cpp
template<typename T>
struct decay_rvalues;

template<typename T>
struct decay_rvalues<T&> {
  using type=T&;
};

template<typename T>
struct decay_rvalues<T&&> {
  using type=std::decay_t<T>;
};

#define auto_cref( var, ... ) \
  typename decay_rvalues<decltype((__VA_ARGS__))&&>::type var = ( __VA_ARGS__ );
```

---
#auto_cref

```cpp
decltype(auto) foo() {
  auto_cref( a, some_A() );
  ... do something with a ...
  return a;
}
```

---
#auto_cref

```cpp
decltype(auto) foo() {
  auto_cref( a, some_A() );
  ... do something with a ...
* return a; // no parentheses here!
}
```

- Make it your default `auto` !
  * does not work yet if expression contains lambda, fixed in C++20

- Choice: `auto_cref` value `const`? 
```cpp
template<typename T>
struct decay_rvalues<T&&> {
  *using type=std::decay_t<T> const;
};
```

- Then `auto_cref_return` for NRVO/move optimization

---
#auto_cref

```cpp
bool operator<(A const&, A const&);

struct C {
  A getA() const&;
} c1, c2;

*auto_cref( a, our::min( c1.getA(), c2.getA() ) );
```

```cpp
namespace our {
  template<typename Lhs, typename Rhs>
  decltype(auto) min( Lhs&& lhs, Rhs&& rhs ) {
    return rhs<lhs ? std::forward<Rhs>(rhs) : std::forward<Lhs>(lhs);
  }
}
```

- `our::min` correctly returns rvalue reference
- `auto_cref` correctly turns it into value

---
#C++ Rvalue Amnesia

```cpp
struct A;

struct B {
  A m_a;
};

auto_cref( a, B().m_a );
```
--

- Works
  * `decltype((B().m_a))` is `A&&`
  * `a` is value

---
#C++ Rvalue Amnesia

```cpp
struct A;

struct B {
private:
  A m_a;
public:
  A const& getA() const {
    return m_a;
  }
};

auto_cref( a, B().getA() );
```
--

- Does not work
  * `decltype(B().getA())` is `A const&`
  * `a` is `const&`, dangles

---
#C++ Rvalue Amnesia

```cpp
struct A;

struct B {
private:
  A m_a;
public:
* A const& getA() const& {
    return m_a;
  }
};

auto_cref( a, B().getA() );
```

- Does not work
  * `decltype(B().getA())` is `A const&`
  * `a` is `const&`, dangles
  
  
--

- Fundamental problem: `const&` binds anything, including rvalues
- Affects any `const&` accessor

---
#Conditional Operator Afraid Of Rvalue Amnesia

```cpp
struct A;
A const& L();
A const&& R();
```

- What is `decltype( false ? L() : L() )`?
  * `A const&`
- What is `decltype( false ? R() : R() )`?
  * `A const&&`
--

- What is `decltype( false ? R() : L() )`?

--
  * `A const`
  * C++ forces a copy
  
  
---
#C++20 common_reference Not Afraid

- C++20 has new trait `common_reference_t`
  * invented for C++20 Ranges
  
  
--

- `std::common_reference_t< A const&, A const& >` is
  * `A const&`
- `std::common_reference_t< A const&&, A const&& >` is
  * `A const&&`
--

- `std::common_reference_t< A const&&, A const& >` is

--
  * `A const&` !
  
  
  
--

- `std::common_reference_t< A const, A const& >` is

--
  * `A` !
  
  
  
--

- `std::common_reference` embraces rvalue amnesia

WHAT IS CORRECT?

---
#Promises of References

```
           Lifetime    short           long     
Mutablity

immutable              const&&         const&
 
 
 
 
 
mutable                  &&              &

```

---
#Promises of References

```
           Lifetime    short           long     
Mutablity

immutable              const&&         const&
 
 
 
 
 
mutable                  &&              &
                   [can scavenge]
```

---
#Promises of References

```
           Lifetime    short           long     
Mutablity

immutable              const&& ----->  const&
                                   ->
                          ^      /       ^
                          |   --         |
						    /
mutable                  &&              &
                   [can scavenge]
```

- Current C++ reference binding strengthens lifetime promise

---
#Promises of References

```
           Lifetime    short           long     
Mutablity

immutable              const&& <-----  const&
                               <-
                          ^       \      ^
                          |         --   |
						               \
mutable                  &&              &
                   [can scavenge]
```

- Better: Allow binding only if promises get weaker
  * less lifetime
  * less mutability
  * less "scavenge-ability"
  
- only lvalues should bind to `const&`
- anything may bind to `const&&`
  
---
#UUuuuuuuuh

- This is so sad.
- It is very sad.
- We dug ourselves a hole.
- And fell into it.
- UUuuuuh.

---
#Any Chance to Fix C++?

- Warning: These are Ideas! Has not been Implemented!

- Existing code must continue to work

- Existing libraries must work with new code
  * gradual introduction of new binding rules within one codebase

- Any reference uses either new or old rules
  * Reference binding only at beginning of reference lifetime
  * Type of resulting reference unchanged

- All declarations inside `#new-reference-binding on/off` bind along new rules

```cpp
auto const& a = ... // old rules apply
#new-reference-binding on
auto const& a = ... // new rules apply
#new-reference-binding off
auto const& a = ... // old rules apply
```

---
#Reference Declarations (1)

- local/global variable initialization
```cpp
auto const& a = ...
```
  
- structured binding
```cpp
auto const& [a,b] = ...
```

- function/lambda parameter lists
```cpp
void foo(A const& a);
```

---
#Reference Declarations (2)

- members (initialized in PODs)
```cpp
struct B {
	  A const& m_a;
} b = { a };
```

- members (initialized in constructors)
```cpp
struct B {
      A const& m_a;
      B(A const& a) : m_a(a) {} 
};
```

- lambda captures
```cpp
  [&a = b]() { .... };
```

---
#How to opt in to new behavior?

- All declarations inside `#new-reference-binding on/off` bind along new rules

```cpp
void A(int const& a);

#new-reference-binding on
void B(int const& a);
void C(int const&& a);

#new-reference-binding off
void B(int const& a) { // error: declared with different binding behavior
	...
}

A(5); // compiles
B(5); // error: cannot bind rvalue to lvalue
C(5); // compiles

int a=1;
C(a); // compiles
```

---
#Impact on Standard Library

- Feature-test macro if `#new-reference-binding` is enabled

- Functions can be implemented equivalently
  * typically replace `const&` parameters with `const&&`
  
  
- `<type_traits>`
  * `std::common_reference`
  * others not affected

---
#Until then... Mitigations (1)

- temporary lifetime extension
  * replace by `auto_cref`

- member accessors
  * delete rvalue accessors
  * macro?

```cpp  
struct B {
private:
  A m_a;
public:
  A const& getA() const& {
    return m_a;
  }
  A const& getA() const&& = delete;
};
```

---
#Until then... Mitigations (2)

- `common_reference`

```cpp
namespace our {
  template<typename... Ts>
  struct common_reference {
    using oldtype=std::common_reference_t<Ts...>;
    using type=std::conditional_t<
      std::is_lvalue_reference<oldtype>::value &&
        std::disjunction<std::is_rvalue_reference<Ts> ...>::value,
      std::remove_reference_t<oldtype>&&,
      oldtype
    >;
  };
}
```

---
#Until then... Mitigations (3)

- `decltype( false ? R() : L() )`?
  * `A const`
  * C++ forces a copy
  
--

- `our::common_reference` allows fearless conditional (ternary) operator

```cpp
#define CONDITIONAL(b, l, r) ( \
	b \
	? static_cast< typename our::common_reference<decltype((l)),decltype((r))>::type >(l) \
	: static_cast< typename our::common_reference<decltype((l)),decltype((r))>::type >(r) \
)
```

- `decltype( CONDITIONAL( false, R(), L() ) )`?
  * `A const&&`
  * no immediate copy

---
#Summary

- `const&` should never have bound to rvalues
- Fixing C++ may be possible, but must demonstrate it
  * Clang implementation
  * large code base to try it on
- Until then, consider mitigations
  
THANK YOU!

Share