Exemples pour un tutoriel

Je vais être hyper réducteur: je n'en ai plus besoin, je move :).

Par contre, la sémantique de mouvement à changé ma façon d'envoyer des paramètres, il y a beaucoup plus de copie qu'avant (cf. type plein). Mais en apparence seulement, l'appelant décide lui-même si oui ou non une rvalue est approprié. Bien sûr, je ne le fais pas pour tout, mais uniquement pour les paramètres qui vont être absorbés par la classe/fonction (principalement les constructeurs).

Parmi les exemples possibles, j'en vois 2:

• responsabilité unique (unique_ptr est un bon exemple)
• performance (parce qu'un move n'est pas moins rapide qu'une copie quand possible). Je dis performance, mais il serait mieux de parler de sémantique: s'il y a copie, c'est que la variable d'origine est importante. Comme exemple, une implémentation de std::vector ::erase(It) ? while (cin >> s) vec.emplace_back(std::move(s)) ?

Il y a quand même un piège: les structures ne garantissent pas toujours l'affectation de mouvement sur soi-même. C'est le cas de std::vecteur, il faut passer par une temporaire pour avoir cet garanti.

Le cours va-t-il parler des fonctions ref-qualifiée ? Le truc qui permet de faire

• a.foo() // affiche "je suis "
• std::move(a).foo() // affiche "schizo !"

PS: Comment fait-on pour voir les tutos en bétâ ?

J'ai noté une erreur concernant les constructeurs/operateur= ajoutés par le compilo.

Le compilateur crée toujours les 5 fonctions (ctor par défaut, T const& et T&&). Par contre, si les prototypes prenant const& sont définit, les prototypes avec T && ne sont plus accessible.

L'implémentation de operator=(T&&) est plutôt moyenne pour plusieurs raisons:

• La condition (je n'ai jamais aimé cette vérification)
• le swap sur m_ptr qui va prolonger la durée de vie du pointeur.
• (return mal placé)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

X& X::operator=(X&& autre) noexcept
{
  X(std::move(autre)).swap(*this);
  // plus jolie que
  //X tmp(std::move(autre));
  //delete m_ptr;
  //m_ptr = std::move(tmp.m_ptr);
  //m_phrase = std::move(tmp.m_phrase);
  return *this;
}

X::X(X&& autre) noexcept
: m_ptr(std::exchange(autre.m_ptr, nullptr))
, m_phrase(std::move(autre.m_phrase))
{}

void X::swap(X & autre) noexcept
{
  std::swap;
  swap(m_ptr, autre.m_ptr);
  swap(m_phrase, autre.m_phrase);
}

En revanche, je ne comprends pas pourquoi la move semantic te fait passer tes params par copie ? Pour continuer a utiliser l objet "source" ?

Pour profiter de la copie élision. La flemme d'expliquer (l'explication commence au titre "Mais ça c'était avant…").

Tu peux aussi mentionner std::forward et std::move_if_noexcept (les containers de la sl ont une garantie très forte au niveau des exceptions: pas de mouvement si move-ctor pas noexcept (autrement, la séquence ne pourrait pas être dans un état cohérent si une exception est lancée)).