Initializer-list-constructing a vector of noncopyable (but movable) objects

by

Maybe this clause from 8.5.4.5 explains it (my emphasis):

An object of type std::initializer_list is constructed from an
initializer list as if the implementation allocated an array of N
elements of type E, where N is the number of elements in the
initializer list. Each element of that array is copy-initialized
with the corresponding element of the initializer list, and the
std::initializer_list object is constructed to refer to that array.

So you can only initialize from lists if the objects are copyable.

Update: As Johannes points out, copy-initialization can be realized by both copy and move constructors, so that alone isn’t enough to answer the question. Here is, however, an excerpt of the specification of the initializer_list class as described in 18.9:

  template<class _E>
    class initializer_list
    {
    public:
      typedef _E            value_type;
      typedef const _E&     reference;
      typedef const _E&     const_reference;
      typedef size_t        size_type;
      typedef const _E*     iterator;
      typedef const _E*     const_iterator;

Note how there are no non-constant typedefs!

I just tried making an IL constructor which would traverse the initializer list via std::make_move_iterator, which failed because const T & cannot be converted to T&&.

So the answer is: You cannot move from the IL, because the standard says so.

More Related Contents:

  1. How to enforce move semantics when a vector grows?
  2. Can I list-initialize a vector of move-only type?
  3. initializer_list and move semantics
  4. Is a moved-from vector always empty?
  5. When should std::move be used on a function return value? [duplicate]
  6. Removing item from vector, while in C++11 range ‘for’ loop?
  7. Move assignment operator and `if (this != &rhs)`
  8. What does the standard library guarantee about self move assignment?
  9. lifetime of a std::initializer_list return value
  10. Why does auto x{3} deduce an initializer_list?
  11. Why does std::move prevent RVO (return value optimization)?
  12. How do I initialize a member array with an initializer_list?
  13. Brace-enclosed initializer list constructor
  14. C++ unordered_set of vectors
  15. Are multiple mutations within initializer lists undefined behavior?
  16. How to actually implement the rule of five?
  17. Why do we copy then move?
  18. Is it legal to declare a constexpr initializer_list object?
  19. Why can’t I create a vector of lambdas (of the same type) in C++11?
  20. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  21. Is an object guaranteed to be moved when it is returned?
  22. Why do you use std::move when you have && in C++11? [duplicate]
  23. Is there any case where a return of a RValue Reference (&&) is useful?
  24. Double delete in initializer_list vs 2013
  25. C++11 virtual destructors and auto generation of move special functions
  26. How can I resize a 2D vector of objects given the width and height?
  27. When is explicit move needed for a return statement?
  28. Move out element of std priority_queue in C++11
  29. Why would I std::move an std::shared_ptr?
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment