Can I list-initialize a vector of move-only type?

by

Edit: Since @Johannes doesn’t seem to want to post the best solution as an answer, I’ll just do it.

#include <iterator>
#include <vector>
#include <memory>

int main(){
  using move_only = std::unique_ptr<int>;
  move_only init[] = { move_only(), move_only(), move_only() };
  std::vector<move_only> v{std::make_move_iterator(std::begin(init)),
      std::make_move_iterator(std::end(init))};
}

The iterators returned by std::make_move_iterator will move the pointed-to element when being dereferenced.

Original answer:
We’re gonna utilize a little helper type here:

#include <utility>
#include <type_traits>

template<class T>
struct rref_wrapper
{ // CAUTION - very volatile, use with care
  explicit rref_wrapper(T&& v)
    : _val(std::move(v)) {}

  explicit operator T() const{
    return T{ std::move(_val) };
  }

private:
  T&& _val;
};

// only usable on temporaries
template<class T>
typename std::enable_if<
  !std::is_lvalue_reference<T>::value,
  rref_wrapper<T>
>::type rref(T&& v){
  return rref_wrapper<T>(std::move(v));
}

// lvalue reference can go away
template<class T>
void rref(T&) = delete;

Sadly, the straight-forward code here won’t work:

std::vector<move_only> v{ rref(move_only()), rref(move_only()), rref(move_only()) };

Since the standard, for whatever reason, doesn’t define a converting copy constructor like this:

// in class initializer_list
template<class U>
initializer_list(initializer_list<U> const& other);

The initializer_list<rref_wrapper<move_only>> created by the brace-init-list ({...}) won’t convert to the initializer_list<move_only> that the vector<move_only> takes. So we need a two-step initialization here:

std::initializer_list<rref_wrapper<move_only>> il{ rref(move_only()),
                                                   rref(move_only()),
                                                   rref(move_only()) };
std::vector<move_only> v(il.begin(), il.end());

More Related Contents:

  1. initializer_list and move semantics
  2. Initializer-list-constructing a vector of noncopyable (but movable) objects
  3. What is move semantics?
  4. How to enforce move semantics when a vector grows?
  5. What is std::move(), and when should it be used?
  6. What can I do with a moved-from object?
  7. Initializer lists and RHS of operators
  8. How do I use a custom deleter with a std::unique_ptr member?
  9. initializer_list and template type deduction
  10. Why no default move-assignment/move-constructor?
  11. What constitutes a valid state for a “moved from” object in C++11?
  12. What are the rules for automatic generation of move operations?
  13. Why is `std::move` named `std::move`?
  14. C++11 move constructor not called, default constructor preferred
  15. Is the pass-by-value-and-then-move construct a bad idiom?
  16. Move-only version of std::function
  17. How does std::move() transfer values into RValues?
  18. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  19. Why doesn’t my template accept an initializer list
  20. Is it possible to std::move objects out of functions? (C++11)
  21. Why do some people use swap for move assignments?
  22. Non-copyable elements in vector
  23. Can I typically/always use std::forward instead of std::move?
  24. Is a `=default` move constructor equivalent to a member-wise move constructor?
  25. C++11 initializer list fails – but only on lists of length 2
  26. Move or Named Return Value Optimization (NRVO)?
  27. Range-based for with brace-initializer over non-const values?
  28. Why would I std::move an std::shared_ptr?
  29. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  30. Move semantics == custom swap function obsolete?

Leave a Comment