112

如果我通过我的 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>&) [with _Tp = int; _Dp = std::default_delete; std::unique_ptr<_Tp, _Dp> = std::unique_ptr]'

GCC 尝试从初始化列表中复制指针是否正确？

4

5 回答 5

77

编辑：由于@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 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;

可悲的是，这里的直接代码不起作用：

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

由于标准，无论出于何种原因，都没有定义这样的转换复制构造函数：

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

由initializer_list<rref_wrapper<move_only>>大括号初始化列表 ( {...}) 创建的 不会转换为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());
于 2011-12-12T01:30:26.513 回答
52

18.9的概要<initializer_list>清楚地表明，初始化列表的元素总是通过 const-reference 传递。不幸的是，在当前版本的语言中，似乎没有任何方法可以在初始化列表元素中使用移动语义。

具体来说，我们有：

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
于 2011-12-12T00:55:54.630 回答
12

正如其他答案中所提到的， 的行为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）

于 2015-11-10T01:03:47.693 回答
7

C++20 更新：使用 Johannes Schaub 的std::make_move_iterator()C++20 's 技巧std::to_array()，您可以使用类似的辅助函数make_tuple()等，这里称为make_vector()：

#include <array>
#include <memory>
#include <vector>

struct X {};

template<class T, std::size_t N>
auto make_vector( std::array<T,N>&& a )
    -> std::vector<T>
{
    return { std::make_move_iterator(std::begin(a)), std::make_move_iterator(std::end(a)) };
}

template<class... T>
auto make_vector( T&& ... t )
{
    return make_vector( std::to_array({ std::forward<T>(t)... }) );
}

int main()
{
    using UX = std::unique_ptr<X>;
    const auto a  = std::to_array({ UX{}, UX{}, UX{} });     // Ok
    const auto v0 = make_vector( UX{}, UX{}, UX{} );         // Ok
    //const auto v2 = std::vector< UX >{ UX{}, UX{}, UX{} }; // !! Error !!
}

看它直播Godbolt。

旧 C++ 的类似答案：

使用 Johannes Schaub 的std::make_move_iterator()with技巧std::experimental::make_array()，您可以使用辅助函数：

#include <memory>
#include <type_traits>
#include <vector>
#include <experimental/array>

struct X {};

template<class T, std::size_t N>
auto make_vector( std::array<T,N>&& a )
    -> std::vector<T>
{
    return { std::make_move_iterator(std::begin(a)), std::make_move_iterator(std::end(a)) };
}

template<class... T>
auto make_vector( T&& ... t )
    -> std::vector<typename std::common_type<T...>::type>
{
    return make_vector( std::experimental::make_array( std::forward<T>(t)... ) );
}

int main()
{
    using UX = std::unique_ptr<X>;
    const auto a  = std::experimental::make_array( UX{}, UX{}, UX{} ); // Ok
    const auto v0 = make_vector( UX{}, UX{}, UX{} );                   // Ok
    //const auto v1 = std::vector< UX >{ UX{}, UX{}, UX{} };           // !! Error !!
}

看它直播Coliru。

也许有人可以利用std::make_array()'s 的诡计来允许make_vector()直接做它的事情，但我没有看到如何（更准确地说，我尝试了我认为应该工作的方法，失败了，然后继续前进）。在任何情况下，编译器都应该能够内联数组到向量的转换，就像 Clang 对 O2 on 所做的那样GodBolt。

于 2017-03-20T22:31:20.597 回答
-1

正如已经指出的那样，不可能用初始化列表初始化只移动类型的向量。@Johannes 最初提出的解决方案工作正常，但我有另一个想法......如果我们不创建一个临时数组然后将元素从那里移动到向量中，而是使用放置new来初始化这个数组已经代替向量的内存块？

unique_ptr这是我使用参数包初始化 ' 向量的函数：

#include <iostream>
#include <vector>
#include <make_unique.h>  /// @see http://stackoverflow.com/questions/7038357/make-unique-and-perfect-forwarding

template <typename T, typename... Items>
inline std::vector<std::unique_ptr<T>> make_vector_of_unique(Items&&... items) {
    typedef std::unique_ptr<T> value_type;

    // Allocate memory for all items
    std::vector<value_type> result(sizeof...(Items));

    // Initialize the array in place of allocated memory
    new (result.data()) value_type[sizeof...(Items)] {
        make_unique<typename std::remove_reference<Items>::type>(std::forward<Items>(items))...
    };
    return result;
}

int main(int, char**)
{
    auto testVector = make_vector_of_unique<int>(1,2,3);
    for (auto const &item : testVector) {
        std::cout << *item << std::endl;
    }
}
于 2013-05-15T11:36:55.593 回答