Puis-je liste d'initialisation d'un vecteur de mouvement-type seul?

Si je passe le code suivant à travers mon GCC 4.7 de l'instantané, il essaie de copier les unique_ptrs dans le vecteur.

#include <vector>
#include <memory>

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

Évidemment cela ne peut pas fonctionner, car std::unique_ptr n'est pas copiable:

erreur: utilisation de supprimé la fonction 'std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [avec _Tp = int; _Dp = std::default_delete; std::unique_ptr<_Tp, _Dp> = std::unique_ptr]'

Est GCC corriger en essayant de copier les pointeurs de la liste d'initialiseur?

Visual Studio et clang a le même comportement

OriginalL'auteur R. Martinho Fernandes | 2011-12-12

  1. 42

    Le synopsis de <initializer_list> dans 18.9 fait assez clairement que les éléments d'une liste d'initialiseur sont toujours transmis via const référence. Malheureusement, il ne semble pas être un moyen de déplacer à l'aide de la sémantique dans l'initialiseur de la liste des éléments dans la révision actuelle de la langue.

    Plus précisément, nous avons:

    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
    Envisager le<T> idiome décrit sur cpptruths (cpptruths.blogspot.com/2013/09/...). L'idée est de déterminer lvalue/rvalue au moment de l'exécution, puis appel de déplacer ou de copier-construction. dans<T> détecter les rvalue/lvalue même si l'interface standard fourni par initializer_list est const référence.
    Ne semble pas si "idiomatiques pour moi": n'est-il pas, au lieu de cela, pur UB? non pas seulement comme l'itérateur, mais plutôt les éléments qui sous-tendent eux-mêmes pourraient être const, qui ne peuvent être jetées dans un puits formé programme.

    OriginalL'auteur Kerrek SB

  2. 55

    Edit: Depuis @Johannes ne semble pas vouloir poster la meilleure solution, une réponse, je vais juste le faire.

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

    Les itérateurs retourné par std::make_move_iterator va déplacer le-pointu à l'élément d'être déréférencé.

    Réponse originale à cette question:
    Nous allons utiliser un peu de type d'assistance ici:

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

    Malheureusement, le simple code suivant ne fonctionne pas:

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

    Depuis la norme, pour quelque raison que ce soit, ne définit pas une conversion de constructeur de copie comme ceci:

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

    La initializer_list<rref_wrapper<move_only>> créé par le corset-init-liste ({...}) de ne pas se convertir à l' initializer_list<move_only> que le vector<move_only> prend. Nous avons donc besoin d'un deux-étape d'initialisation ici:

    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());
    Ah... c'est la rvalue analogique de std::ref, non? Peut-être qu'il devrait être appelé std::rref.
    Maintenant, je suppose que ce ne doit pas être de gauche sans être mentionné dans un commentaire 🙂 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));.
    Parfois, les solutions les plus simples qui vient de m'échapper. Même si je dois admettre, je ne vous embêtez pas avec ces move_iterators encore.
    Aussi, pourquoi n'est-ce pas une réponse? 🙂
    Je considère qu'un QoI problème, mais je ne vois pas pourquoi il ne pouvait pas le faire. VC++stdlib par exemple la balise dépêches basé sur l'itérateur catégorie et utilise std::distance avant-ou-mieux les itérateurs et std::move_iterator s'adapte le sous-jacent des itérateurs de la catégorie. De toute façon, la bonne et concis solution. Poster une réponse, peut-être?

    OriginalL'auteur Xeo

  3. 8

    Comme mentionné dans d'autres réponses, le comportement de std::initializer_list est de détenir des objets par valeur et ne pas permettre de déménager, donc ce n'est pas possible. Voici une solution de contournement possible, à l'aide d'un appel de fonction où les initialiseurs sont donnés à titre variadic arguments:

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

    Malheureusement multi_emplace(foos, {}); échoue car il ne peut pas déduire le type de {}, donc pour les objets à défaut construit vous devez répéter le nom de la classe. (ou utilisez vector::resize)

    Le récursive pack d'extension pourrait être remplacé par le mannequin tableau opérateur virgule hack , pour sauver un couple de lignes de code

    OriginalL'auteur M.M

  4. 0

    À l'aide de Johannes Schaub astuce est de std::make_move_iterator() avec std::experimental::make_array(), vous pouvez utiliser une fonction d'assistance:

    #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 !!
}

    Voir en direct sur Coliru.

    Peut-être quelqu'un peut tirer parti de std::make_array()'une ruse pour permettre make_vector() de faire sa chose directement, mais je ne vois pas comment (avec plus de précision, j'ai essayé ce que je pensais devrait fonctionner, a échoué, et a déménagé sur). Dans tous les cas, le compilateur doit être en mesure d'insérer le tableau de vecteur de transformation, comme Clang ne avec O2 sur GodBolt.

    OriginalL'auteur metal

  5. -1

    Comme il a été souligné, il n'est pas possible d'initialiser un vecteur de mouvement-type uniquement avec une liste d'initialiseur. La solution initialement proposée par @Johannes fonctionne très bien, mais j'ai une autre idée... et si nous n'avons pas créer un tableau temporaire, puis de déplacer les éléments dans le vecteur, mais l'utilisation placement new pour initialiser ce tableau déjà en place dans le vecteur de bloc de mémoire?

    Voici ma fonction pour initialiser un vecteur de unique_ptr's à l'aide d'un argument pack:

    #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;
    }
}
    C'est une idée terrible. Le Placement de nouvelles n'est pas un marteau, c'est un outil de précision. result.data() n'est pas un pointeur à certains de mémoire vive. Il est un pointeur vers un objet. Pensez à ce qui arrive à ce pauvre objet lorsque vous le placement de nouveau sur elle.
    En outre, la matrice de la forme de placement de la nouvelle n'est pas vraiment utilisable stackoverflow.com/questions/8720425/...
    Martinho Fernandes: merci de remarquer que le placement de nouveau pour les tableaux ne fonctionnerait pas. Maintenant je vois pourquoi c'était une mauvaise idée.

    OriginalL'auteur Gart