次のコードをGCC4.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は正しいですか？
編集： @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>>brace-init-list（）によって作成されたものは、それが取る{...}ものに変換されません。したがって、ここでは2段階の初期化が必要です。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());
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
他の回答で述べたように、の動作は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）
C ++ 20の更新：JohannesSchaubのstd::make_move_iterator()C++ 20のトリックを使用して、ここでは：と呼ばれるstd::to_array()untoなどのヘルパー関数を使用できます。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()トリックを利用make_vector()してそのことを直接行うことができるかもしれませんが、私はその方法がわかりませんでした（より正確には、私はうまくいくはずだと思ったものを試し、失敗し、次に進みました）。いずれの場合も、ClangがのO2で行うように、コンパイラーは配列からベクトルへの変換をインライン化できる必要がありますGodBolt。
指摘されているように、初期化リストを使用して移動専用タイプのベクトルを初期化することはできません。@Johannesによって最初に提案されたソリューションは正常に機能しますが、別のアイデアがあります...一時的な配列を作成せず、そこから要素をベクトルに移動し、placementを使用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;
}
}