Comment appliquer la sémantique de déplacement lorsqu'un vecteur se développe?

J'ai un std::vectorobjet d'une certaine classe A. La classe n'est pas triviale et a des constructeurs de copie et des constructeurs de déplacement définis.

std::vector<A>  myvec;

Si je remplis le vecteur avec des Aobjets (en utilisant par exemple myvec.push_back(a)), le vecteur augmentera en taille, en utilisant le constructeur de copie A( const A&)pour instancier de nouvelles copies des éléments dans le vecteur.

Puis-je en quelque sorte imposer que le constructeur de mouvement de la classe Asoit utilisé à la place?

Vous devez informer C ++ (spécifiquement std::vector) que votre constructeur et destructeur de déplacement ne lance pas, en utilisant noexcept. Ensuite, le constructeur de déplacement sera appelé lorsque le vecteur se développera.

Voici comment déclarer et implémenter un constuctor de déplacement qui est respecté par std::vector:

A(A && rhs) noexcept { 
  std::cout << "i am the move constr" <<std::endl;
  ... some code doing the move ...  
  m_value=std::move(rhs.m_value) ; // etc...
}

Si le constructeur ne l'est pas noexcept, ne std::vectorpeut pas l'utiliser, car il ne peut pas garantir les garanties d'exception exigées par le standard.

Pour en savoir plus sur ce qui est dit dans la norme, lisez la sémantique et les exceptions C ++ Move

Merci à Bo qui a laissé entendre que cela pourrait avoir à voir avec des exceptions. Tenez également compte des conseils de Kerrek SB et utilisez-les emplace_backsi possible. Cela peut être plus rapide (mais ce n'est souvent pas le cas), cela peut être plus clair et plus compact, mais il y a aussi quelques pièges (surtout avec les constructeurs non explicites).

Modifier , souvent la valeur par défaut est ce que vous voulez: déplacez tout ce qui peut être déplacé, copiez le reste. Pour demander cela explicitement, écrivez

A(A && rhs) = default;

En faisant cela, vous obtiendrez noexcept lorsque cela est possible: le constructeur Move par défaut est-il défini comme noexcept?

Notez que les premières versions de Visual Studio 2015 et les versions antérieures ne le prenaient pas en charge, même s'il prend en charge la sémantique de déplacement.

Fait intéressant, le vecteur de gcc 4.7.2 n'utilise le constructeur de déplacement que si le constructeur de déplacement et le destructeur le sont noexcept. Un exemple simple:

struct foo {
    foo() {}
    foo( const foo & ) noexcept { std::cout << "copy\n"; }
    foo( foo && ) noexcept { std::cout << "move\n"; }
    ~foo() noexcept {}
};

int main() {
    std::vector< foo > v;
    for ( int i = 0; i < 3; ++i ) v.emplace_back();
}

Cela produit le attendu:

move
move
move

Cependant, lorsque je supprime noexceptde ~foo(), le résultat est différent:

copy
copy
copy

Je suppose que cela répond également à cette question .

Il semble que le seul moyen (pour C ++ 17 et les versions antérieures) d'imposer la std::vectorsémantique use move lors de la réallocation est de supprimer le constructeur de copie :). De cette façon, il utilisera vos constructeurs de mouvement ou mourra en essayant, au moment de la compilation :).

Il existe de nombreuses règles où il std::vectorNE DOIT PAS utiliser le constructeur de déplacement lors de la réallocation, mais rien sur l'endroit où il DOIT L'UTILISER .

template<class T>
class move_only : public T{
public:
   move_only(){}
   move_only(const move_only&) = delete;
   move_only(move_only&&) noexcept {};
   ~move_only() noexcept {};

   using T::T;   
};

Vivre

ou

template<class T>
struct move_only{
   T value;

   template<class Arg, class ...Args, typename = std::enable_if_t<
            !std::is_same_v<move_only<T>&&, Arg >
            && !std::is_same_v<const move_only<T>&, Arg >
    >>
   move_only(Arg&& arg, Args&&... args)
      :value(std::forward<Arg>(arg), std::forward<Args>(args)...)
   {}

   move_only(){}
   move_only(const move_only&) = delete;   
   move_only(move_only&& other) noexcept : value(std::move(other.value)) {};    
   ~move_only() noexcept {};   
};

Code en direct

Votre Tclasse doit avoir noexceptun opérateur de constructeur / d'assignation de déplacement et un noexceptdestructeur. Sinon, vous obtiendrez une erreur de compilation.

std::vector<move_only<MyClass>> vec;