我可以列出-初始化一个只移动类型的向量吗？

Question

我可以列出-初始化一个只移动类型的向量吗？如果我通过GCC 4.7快照传递以下代码，它将尝试复制unique_ptrs进入向量。#include <vector>#include <memory>int main() {     using move_only = std::unique_ptr<int>;     std::vector<move_only> v { move_only(), move_only(), move_only() };}很明显这是行不通的，因为std::unique_ptr不可复制：错误：使用已删除的函数‘std：UNIQUE_PTR<_TP，_dp>：UNIQUE_PTR(Const STD：UNIQUE_PTR<_TP，_DP>&)[WITTP=int；_dp=std：default_DELETE；STD：UNIQUE_PTR<_TP，_DP>=STD：UNIQUE_PTR]’GCC试图从初始化程序列表复制指针是正确的吗？

Answer 1

简介<initializer_list>在18.9中，可以相当清楚地表明，初始化程序列表的元素总是通过Const-引用传递的。不幸的是，在当前语言的修订版中，在初始化程序列表元素中似乎没有任何使用移动语义的方法。

具体而言，我们有：

typedef const E& reference;

typedef const E& const_reference;

typedef const E* iterator;

typedef const E* const_iterator;

const E* begin() const noexcept; // first element

const E* end() const noexcept; // one past the last element

Answer 2

因为@Johannes似乎不想发布最好的解决方案作为一个答案，所以我就这么做。

#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))};}

返回的迭代器std::make_move_iterator将在取消引用时移动指向元素。

---

原文：我们要在这里利用一个小帮手类型：

#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 temporariestemplate<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 awaytemplate<class T>void rref(T&) = delete;

遗憾的是，这里的直接代码无法工作：

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

由于标准没有定义如下的转换副本构造函数，无论出于什么原因：

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

这个initializer_list<rref_wrapper<move_only>>由大括号-init-列表创建({...})不会转换为initializer_list<move_only>认为vector<move_only>拿着。所以我们需要两步初始化：

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());

Answer 3

如其他答案所述，std::initializer_list是按值保存对象，而不允许移出，因此这是不可能的。下面是一种可能的解决方法，使用函数调用，其中初始化器作为各种参数提供：

#include <vector>#include <memory>struct Foo{
    std::unique_ptr<int> u;
    int x;
    Foo(int x = 0): x(x) {}};template<typename V>        
    // recursion-ender
    void multi_emplace(std::vector<V> &vec) {}template<typename V, typename T1, typename... 
    Types>void multi_emplace(std::vector<V> &vec, T1&& t1, Types&&... args){
    vec.emplace_back( std::move(t1) );
    multi_emplace(vec, args...);}int main(){
    std::vector<Foo> foos;
    multi_emplace(foos, 1, 2, 3, 4, 5);
    multi_emplace(foos, Foo{}, Foo{});}

不幸的是multi_emplace(foos, {});失败，因为它无法推断{}因此，对于默认构造的对象，必须重复类名。(或使用)vector::resize)