web-dev-qa-db-ja.com

移動専用タイプのベクトルをリスト初期化できますか？

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は初期化子リストからポインターをコピーしようとして正しいですか？

c++c++11initializer-listmove-semantics
88
R. Martinho Fernandes

18.9の<initializer_list>の概要は、初期化リストの要素が常にconst-referenceを介して渡されることを合理的に明確にします。残念ながら、言語の現在のリビジョンでは、初期化リストの要素にmove-semanticを使用する方法はないようです。

具体的には次のとおりです。

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
44
Kerrek SB

編集： @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);

Brace-init-listによって作成されたinitializer_list<rref_wrapper<move_only>>（{...}）は、initializer_list<move_only>が取るvector<move_only>に変換されません。したがって、ここでは2段階の初期化が必要です。

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

他の回答で述べたように、_std::initializer_list_の動作は、値によってオブジェクトを保持し、移動を許可しないことです。したがって、これは不可能です。初期化子が可変引数として指定されている関数呼び出しを使用して、可能な回避策の1つを次に示します。

_#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_を使用）

9
M.M

Johannes Schaubのstd::make_move_iterator()と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 !!
}
_

ライブで見る Colir。

おそらく、誰かがstd::make_array()のトリックを利用してmake_vector()に直接そのことをさせることができるかもしれませんが、どのように（正確には、私はうまくいくと思ったものを試し、失敗し、先に進みました）。いずれの場合でも、ClangはO2をオンにして、配列からベクトルへの変換をインライン化できる必要があります。 GodBolt。

0
metal