Eğer benim GCC ile aşağıdaki kodu 4.7 anlık geçersem, vektör içine unique_ptrs kopyalamak için çalışır.

#include <vector>
#include <memory>

int main() {
    using move_only = std::unique_ptr<int>;
    std::vector<move_only> v { move_only(), move_only(), move_only() };
}

Belli ki o std::unique_ptr copyable çünkü çalışamaz:

hata: silinmiş işlevi ':: unique_ptr&std;_Tp,^ _Dp lt . ::unique_ptr(inş std::unique_ptr&; _Tp,^ _Dp lt . &) [_Tp = int; _Dp = std::default_delete; std::unique_ptr&; _Tp,^ _Dp lt . = std::unique_ptr]'

GCC başlatıcı listeden işaretçileri kopyalamaya çalıştığınız doğru mu?

Düzenleme:@Johannes cevap olarak en iyi çözüm sonrası için istediğiniz gibi görünmüyor beri, sadece ben yaparım.

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

Bu yineleyicisi std::make_move_iterator tarafından döndürülen başvuru yapıldı olunca sivri öğe hareket edecek.

Orijinal cevabı: Küçük yardımcı bir türü burada kullanmak için:

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

Ne yazık ki, düz ileri kodunu burada işe yaramaz:

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

Her ne sebeple olursa olsun standart bir yana, bu gibi dönüştürme kopya yapıcı tanımlamaz:

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

initializer_list<rref_wrapper<move_only>> brace-ınit-liste ({...}) tarafından oluşturulan vector<move_only> alır initializer_list<move_only> dönüştürmek değildir. İki adımda burada başlatma ihtiyacımız var:

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