我可以对仅移动类型的向量进行列表初始化吗?


95

如果我通过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在尝试从初始化列表中复制指针时是否正确?


Visual Studio和clang具有相同的行为
Jean-Simon Brochu

Answers:


46

<initializer_list>18.9中的概要使我们很清楚地知道,初始化列表的元素始终通过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

4
考虑一下cpptruths(cpptruths.blogspot.com/2013/09/…)中描述的in <T>习惯用法。这个想法是在运行时确定左值/右值,然后调用move或copy-construction。即使initializer_list提供的标准接口是const引用,in <T>也会检测到rvalue / lvalue。
Sumant

3
@Sumant似乎对我不那么“习惯”:不是,而是纯UB?不仅是迭代器,而且底层元素本身也可能是const,而这些元素不能在格式正确的程序中丢弃。
underscore_d

62

编辑:由于@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());

1
啊...这是的右值类似物std::ref,不是吗?也许应该叫它std::rref
Kerrek SB 2011年

17
现在,我想这不应该在评论中被提及:) move_only m[] = { move_only(), move_only(), move_only() }; std::vector<move_only> v(std::make_move_iterator(m), std::make_move_iterator(m + 3));
Johannes Schaub-litb 2011年

1
@Johannes:有时候,简单的解决方案让我难以理解。尽管我必须承认,但是我还没有去理会那些move_iterator
Xeo

2
@Johannes:另外,为什么还没有答案呢?:)
Xeo

1
@JohanLundberg:我认为这是QoI问题,但我不明白为什么它不能做到这一点。VC ++的stdlib例如基于迭代器类别进行标记分派,并std::distance用于转发或更好的迭代器,并std::move_iterator适应基础迭代器的类别。无论如何,好的简洁的解决方案。发布它作为答案,也许吗?
Xeo 2012年

10

如其他答案中所述,的行为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


4
可以用伪数组逗号运算符hack替换递归包扩展,以节省几行代码
MM 2015年

0

使用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


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

那是一个可怕的主意。放置新的不是锤子,而是精密的工具。result.data()不是指向某些随机存储器的指针。它是指向对象的指针。想一想当您将新物体放置在那个不良物体上时会发生什么。
R. Martinho Fernandes

此外,安置新的阵列形式是不是真的有用stackoverflow.com/questions/8720425/...
R.费尔南德斯Martinho

@R。Martinho Fernandes:感谢您指出新的数组放置不起作用。现在我明白了为什么这是一个坏主意。
加特,
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.