ENIB LANG-CPP 02_Sharing - Accès partagé aux données

{} Recopie et déplacement

Une nouveauté fondamentale qui marque le passage à C++ moderne (en contraste avec C++98) est la possibilité de déplacer une donnée élaborée sans nécessairement impliquer la duplication et la recopie de toutes les informations utiles qui la constituent.
Cette notion de déplacement matérialise parfaitement l'idée d'un transfert de propriété : les ressources qui appartenaient à une variable par exemple peuvent ensuite appartenir à une autre (et donc n'appartiennent plus à la première) sans avoir à être dupliquées.
Nous chercherons à explorer ceci à travers l'analyse attentive des résultats d'une expérimentation ; il y aura très peu de code à produire mais un effort soutenu dans l'interprétation des observations sera essentiel.

{} Durée de vie d'une donnée

L'expérimentation passera par la réalisation d'un nouveau programme.
Créez alors sur votre poste de travail un répertoire de votre choix dans lequel vous placerez le fichier GNUmakefile, un fichier prog.cpp et le fichier noisy.hpp✎

Contenu du fichier noisy.hpp

//----------------------------------------------------------------------------

#ifndef S4PRC_NOISY_HPP
#define S4PRC_NOISY_HPP

#include <iostream>
#include <string>
#include <vector>

namespace s4prc {

inline
std::ostream &
operator<<(std::ostream &output,
           const std::string &s) // display string within quotes
{
  using std::operator<<;
  output << '"';
  if(const auto sz=size(s); sz>20) // prevent from using too much space
  {
    output << s.substr(0, 10) << "..." << s.substr(sz-10);
  }
  else
  {
    output << s;
  }
  return output << '"';
}

template<typename E>
inline
std::ostream &
operator<<(std::ostream &output,
           const std::vector<E> &v) // display vector within braces
{
  output << '{';
  if(const auto sz=size(v); sz>4) // prevent from using too much space
  {
    output << v[0] << ',' << v[1] << ",...," << v[sz-2] << ',' << v[sz-1];
  }
  else
  {
    int count=0;
    for(const auto &elem: v)
    {
      if(count++)
      {
        output << ',';
      }
      output << elem;
    }
  }
  return output << '}';
}

template<typename T>
struct Noisy : T
{
  Noisy()
  : T{}
  {
    std::cout << "construct " << *this
              << " from nothing\n";
  }

  Noisy(const T &t)
  : T{t}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << t << '\n';
  }

  Noisy(T &&t)
  : T{std::move(t)}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << t << '\n';
  }

  Noisy(const Noisy &n)
  : T{static_cast<const T &>(n)}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << n << '\n';
  }

  Noisy(Noisy &&n) noexcept
  : T{std::move(static_cast<T &&>(n))}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << n << '\n';
  }

  Noisy &
  operator=(const T &t)
  {
    T::operator=(t);
    std::cout << "copy-assign " << *this
              << "\n   ... from " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(T &&t)
  {
    T::operator=(std::move(t));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(const Noisy &n)
  {
    T::operator=(static_cast<const T &>(n));
    std::cout << "copy-assign " << *this
              << "\n   ... from " << n << '\n';
    return *this;
  }

  Noisy &
  operator=(Noisy &&n) noexcept
  {
    T::operator=(std::move(static_cast<T &&>(n)));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << n << '\n';
    return *this;
  }

  ~Noisy()
  {
    std::cout << "destroy " << *this << '\n';
  }

  friend
  std::ostream &
  operator<<(std::ostream &output,
             const Noisy &n)
  {
    return output << "Noisy@" << &n << ":" << static_cast<const T &>(n);
  }
};

} // namespace s4prc

#endif // S4PRC_NOISY_HPP

//----------------------------------------------------------------------------

.
Ce fichier d'en-tête est un module fournissant le type s4prc::Noisy<T> dont nous ferons usage sans chercher à comprendre les détails de sa réalisation✍.
Le fichier prog.cpp devra contenir la fonction suivante :

void
test_construct_destroy()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n1;
  NoisyStr n2{"DATA"};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

qui sera appelée depuis la fonction principale.
Le type NoisyStr est une abréviation de

s4prc::Noisy<std::string>

afin de faciliter l'écriture répétée de ce type tout au long de cette expérimentation ; cela sera rendu possible grâce à la saisie préalable de la directive :

using NoisyStr = s4prc::Noisy<std::string>;

(déjà rencontrée à la fin de cette section).
Ce type se propose d'être l'équivalent de std::string si ce n'est que, comme son nom l'indique, il produira des messages (à vocation pédagogique uniquement) rendant explicites les opérations que nous nous proposons d'étudier dans cette expérimentation.
Assurez-vous du fait que le programme se fabrique et s'exécute sans encombre.

L'observation attentive et la bonne compréhension des affichages produits sont essentielles pour passer à la suite de l'expérimentation.
Dans cette toute première situation, nous constatons que chacune des deux variables de type NoisyStr fait apparaître des messages qui lui sont propres.
De tels messages indiquent systématiquement l'adresse en mémoire de la donnée concernée✍ ainsi que l'information qu'elle mémorise (une donnée de type std::string, il ne s'agit que d'un prétexte à l'observation ici).

Exemple de messages produits

~~~~ enter test_construct_destroy() ~~~~
construct Noisy@0x7ffd08373350:"" from nothing
move-construct Noisy@0x7ffd08373390:"DATA"
   ... from (moved) ""
  n1=Noisy@0x7ffd08373350:""
  n2=Noisy@0x7ffd08373390:"DATA"
~~~~ leave test_construct_destroy() ~~~~
destroy Noisy@0x7ffd08373390:"DATA"
destroy Noisy@0x7ffd08373350:""

Les messages de création construct nous confirment que n1 contient une chaîne vide car elle n'a pas reçu d'autre valeur à l'initialisation, et que n2 contient la chaîne

"DATA"

transmise explicitement à son initialisation✍.
C'est bien ce que montre l'affichage explicite de ces deux variables.

Les messages de destruction destroy permettent de retrouver ces mêmes adresses et contenus, ce qui confirme le fait que les variables ont bien une durée de vie limitée.
Ils apparaissent seulement après le message qui signale la sortie de la fonction ; c'est effectivement à la destruction du contexte qui les contient (c'est-à-dire les accolades du corps de la fonction test_construct_destroy() dans le cas présent) que ces variables sont elles-mêmes détruites.

{} Initialisation et affectation

Complétez maintenant le fichier prog.cpp par cette fonction :

void
test_copy()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n1;
  NoisyStr n2{"DATA"};
  NoisyStr n3{n2};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=n3;
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=NoisyStr{"NEW DATA"};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

qui sera également appelée depuis la fonction principale.
Assurez-vous du fait que le programme se fabrique et s'exécute sans encombre.

Exemple de messages produits

~~~~ enter test_copy() ~~~~
construct Noisy@0x7ffd08373290:"" from nothing
move-construct Noisy@0x7ffd083732d0:"DATA"
   ... from (moved) ""
copy-construct Noisy@0x7ffd08373350:"DATA"
   ... from Noisy@0x7ffd083732d0:"DATA"
  n1=Noisy@0x7ffd08373290:""
  n2=Noisy@0x7ffd083732d0:"DATA"
  n3=Noisy@0x7ffd08373350:"DATA"
copy-assign Noisy@0x7ffd08373290:"DATA"
   ... from Noisy@0x7ffd08373350:"DATA"
  n1=Noisy@0x7ffd08373290:"DATA"
  n2=Noisy@0x7ffd083732d0:"DATA"
  n3=Noisy@0x7ffd08373350:"DATA"
move-construct Noisy@0x7ffd083733d0:"NEW DATA"
   ... from (moved) ""
move-assign Noisy@0x7ffd08373290:"NEW DATA"
   ... from (moved) Noisy@0x7ffd083733d0:""
destroy Noisy@0x7ffd083733d0:""
  n1=Noisy@0x7ffd08373290:"NEW DATA"
  n2=Noisy@0x7ffd083732d0:"DATA"
  n3=Noisy@0x7ffd08373350:"DATA"
~~~~ leave test_copy() ~~~~
destroy Noisy@0x7ffd08373350:"DATA"
destroy Noisy@0x7ffd083732d0:"DATA"
destroy Noisy@0x7ffd08373290:"NEW DATA"

La fonction test_copy() commence comme la fonction test_construct_destroy() (vérifiez que les premiers et derniers messages produits respectent bien la même logique) mais est complétée par des recopies et des affectations sur des données de type NoisyStr.
Le message de création copy-construct indique clairement que l'initialisation de la nouvelle variable n3 se fait en recopiant le contenu de la variable n2 (notamment sa chaîne

"DATA"

) qui lui est transmise.
De la même façon, lors de l'affectation de la variable n3 à la variable n1, un nouveau message copy-assign nous indique encore qu'une telle recopie du contenu a lieu.
L'initialisation et l'affectation d'une donnée à partir d'une autre sont deux opérations bien distinctes :

l'initialisation a lieu uniquement au moment où la donnée est créée et utilise une valeur initiale spécifiée entre accolades✍
La forme de l'initialisation admet toutefois quelques variantes :
- Type name{values...};
  
  notation supportée sur tous les types uniquement en C++ moderne,
  
  notation préférée, notamment pour les types élaborés.
- Type name(values...);
  
  notation supportée sur tous les types en C++ moderne et ancien.
- Type name={values...};
  
  notation supportée sur tous les types en C++ moderne,
  
  notation supportée en C++ ancien et en C mais applicable uniquement aux champs d'une structure.
- Type name=value;
  
  notation supportée en C++ moderne, ancien et en C,
  
  notation historique mais toujours en vigueur en C++ moderne pour les types de base issus du langage C (par habitude).
,
l'affectation consiste, quant à elle, à modifier une donnée déjà initialisée et utilise l'opérateur = pour en spécifier la nouvelle valeur.

Seulement, nous constatons dans les faits que la problématique est très similaire pour ces deux opérations dans la mesure où il s'agit de renseigner le contenu d'une donnée en réalisant une copie de ce qui est contenu dans une autre.
Assurez-vous d'avoir bien compris l'enchaînement des messages obtenus jusqu'à celui qui matérialise n1=n3.

L'affectation suivante modifie à nouveau n1 mais cette fois-ci la valeur à recopier n'est pas issue d'une variable existante.
La notation

NoisyStr{"NEW DATA"}

crée une nouvelle donnée de type NoisyStr, initialisée à partir de la chaîne spécifiée, mais ne l'associe à aucune variable : il s'agit d'une valeur temporaire✍.
Ce fait est confirmé par l'apparition d'un message construct témoignant de la création de cette nouvelle donnée contenant

"NEW DATA"

✍.
C'est cette valeur temporaire qui est utilisée pour affecter une nouvelle fois la variable n1 ; un message move-assign le confirme.
Maintenant que l'affectation a eu lieu, la valeur temporaire précédente n'a plus d'utilité et un message de destruction destroy nous signale sa disparition.

Cependant, un examen attentif de ce message destroy révèle que cette valeur temporaire ne contient plus la chaîne

"NEW DATA"

dont elle disposait à sa création !
De plus, le message qui témoigne de l'affectation de la valeur temporaire à la variable n1 indique move-assign (et non plus copy-assign comme ce fut le cas en utilisant n3) et montre que la valeur temporaire a déjà perdu la chaîne qu'elle contenait en la confiant à n1.
Il s'agit là du changement le plus marquant dans l'apparition de C++ moderne : le contenu d'une valeur temporaire qui doit être recopiée n'est pas dupliqué vers sa destination mais est déplacé vers cette destination, ce qui prive la valeur temporaire de son contenu initial.
En effet, la valeur temporaire est par essence même vouée à un usage unique, et va être détruite immédiatement après, elle n'a donc pas besoin de conserver son contenu initial.
Le remplacement d'une opération de recopie par une opération de déplacement constitue un levier d'optimisation important lorsqu'on manipule des données volumineuses et fait l'objet de la section suivante✍.

{} Opérations de déplacement

Nous venons de constater que le compilateur décidait spontanément de remplacer une opération de recopie par une opération de déplacement lorsqu'il est question de recopier une valeur temporaire.
La motivation pour un tel comportement concerne principalement les données qui, en interne, mémorisent dynamiquement un volume conséquent d'information.
Pensez par exemple à une très longue chaîne de caractères std::string ou un tableau dynamique std::vector<T> contenant de très nombreux éléments.
La recopie d'une donnée si volumineuse peut s'avérer très coûteuse en temps d'exécution car il s'agit, pour la destination :

d'allouer dynamiquement un espace suffisamment grand pour accueillir un nouvel exemplaire de l'ensemble des informations à recopier,
puis de recopier toutes ces informations vers ce nouvel emplacement.

Illustration : recopie d'un std::vector<T> vers un autre

S'il s'avère que ces informations ne sont finalement plus utiles dans leur emplacement d'origine, parce qu'elles proviennent d'une valeur temporaire qui va immédiatement libérer cet emplacement en disparaissant par exemple, alors cette coûteuse recopie aura été réalisée pour rien !
L'opération de déplacement consiste ainsi à remplacer cette séquence allocation/copie/libération par un simple échange de pointeurs entre les données que l'on cherchait à recopier✍.

Illustration : déplacement d'un std::vector<T> vers un autre

Sur les types élaborés, le déplacement s'avère en général bien plus rapide que la recopie effective, tandis que sur les types de base (entiers, réels...), l'effet est strictement identique à la recopie (il n'y a donc aucun surcoût).

À cette étape, nous cherchons désormais, par une action explicite, à influencer le compilateur pour qu'il minimise le nombre de recopies effectives des données.
Complétez alors le fichier prog.cpp par cette fonction :

void
test_move()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n1;
  NoisyStr n2{"DATA"};
  NoisyStr n3{std::move(n2)};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=std::move(n3);
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=NoisyStr{"NEW DATA"};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

qui sera également appelée depuis la fonction principale.
La fonction test_move() est quasi-identique à la fonction test_copy() si ce n'est que partout où nous constations une recopie effective, nous avons inséré un appel à la fonction std::move()✍ du fichier d'en-tête standard

<utility>

.
(https://en.cppreference.com/w/cpp/utility/move)

Contrairement à ce que son nom suggère, la fonction std::move() n'effectue aucun déplacement par ses propres moyens ; elle permet simplement de fournir au compilateur une indication que seul le programmeur connaît✍ :

“je promets que l'information qui est contenue dans ce qui est passé en paramètre à std::move() ne me sera plus utile après cette opération.”

Pour aider à mieux comprendre cette intention, nous pourrions imaginer que la fonction std::move() s'appelle “give”, c'est-à-dire que nous annonçons que nous “donnons” ce que nous transmettons en paramètre (nous n'avons plus besoin de ses ressources après) :

nous avons “donné” n2 pour initialiser n3 ; n2 ne possède donc plus ses ressources puisque c'est n3 qui les détient désormais,
nous avons “donné” n3 pour affecter n1 ; n3 ne possède donc plus ses ressources puisque c'est n1 qui les détient désormais.

Dans ces conditions, le compilateur remplace la coûteuse opération de recopie de la ressource initiale qu'il était sur le point de générer par son simple déplacement d'une variable à une autre.

Exemple de messages produits

~~~~ enter test_move() ~~~~
construct Noisy@0x7ffd08373290:"" from nothing
move-construct Noisy@0x7ffd083732d0:"DATA"
   ... from (moved) ""
move-construct Noisy@0x7ffd08373350:"DATA"
   ... from (moved) Noisy@0x7ffd083732d0:""
  n1=Noisy@0x7ffd08373290:""
  n2=Noisy@0x7ffd083732d0:""
  n3=Noisy@0x7ffd08373350:"DATA"
move-assign Noisy@0x7ffd08373290:"DATA"
   ... from (moved) Noisy@0x7ffd08373350:""
  n1=Noisy@0x7ffd08373290:"DATA"
  n2=Noisy@0x7ffd083732d0:""
  n3=Noisy@0x7ffd08373350:""
move-construct Noisy@0x7ffd083733d0:"NEW DATA"
   ... from (moved) ""
move-assign Noisy@0x7ffd08373290:"NEW DATA"
   ... from (moved) Noisy@0x7ffd083733d0:""
destroy Noisy@0x7ffd083733d0:""
  n1=Noisy@0x7ffd08373290:"NEW DATA"
  n2=Noisy@0x7ffd083732d0:""
  n3=Noisy@0x7ffd08373350:""
~~~~ leave test_move() ~~~~
destroy Noisy@0x7ffd08373350:""
destroy Noisy@0x7ffd083732d0:""
destroy Noisy@0x7ffd08373290:"NEW DATA"

Reprenez l'examen très attentif des messages générés par l'exécution de ce programme et constatez que désormais il ne subsiste plus une seule opération de recopie effective.
Chaque variable qui reçoit une initialisation ou une affectation obtient pourtant bien la chaîne attendue : celle-ci a été déplacée depuis la valeur fournie.
Vérifiez que les variables n2 et n3 ont bien été dépossédées de leur contenu à cette occasion✍.

Nous retiendrons de cette étape le fait que, lorsque nous savons qu'une donnée de notre programme a une valeur qui ne servira plus après une initialisation ou une affectation, l'usage de std::move() permettra d'économiser une recopie éventuellement coûteuse✍.

{} Renvoi du résultat d'une fonction

Lorsqu'une fonction doit fournir un résultat par sa valeur de retour, il s'agit de faire parvenir au contexte appelant une valeur qui a été produite dans le contexte de la fonction appelée.
De manière intuitive, cette opération s'apparente donc bien à une recopie ; il est, par conséquent, légitime de l'étudier dans le cadre de cette expérimentation.

Ajoutez à vos fichiers de code source un module fnct_call.cpp définissant la fonction suivante :

Noisy<std::string>
produce(std::string msg)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  Noisy<std::string> result{msg+" via "+__func__};
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
  return result;
}

Faites en sorte que cette fonction soit déclarée dans un fichier d'en-tête fnct_call.hpp conventionnel et englobée dans l'espace de noms s4prc (voir la démarche recommandée).
Le fichier prog.cpp doit alors être complété par cette fonction :

void
test_return()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n{s4prc::produce("Ciao")};
  std::cout << "  n=" << n << '\n';
  n=s4prc::produce("Hi");
  std::cout << "  n=" << n << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

qui sera également appelée depuis la fonction principale.
Assurez-vous du fait que le programme se fabrique et s'exécute sans encombre.

Exemple de messages produits

~~~~ enter test_return() ~~~~
~~~~ enter produce() ~~~~
move-construct Noisy@0x7ffd08373310:"Ciao via produce"
   ... from (moved) ""
~~~~ leave produce() ~~~~
  n=Noisy@0x7ffd08373310:"Ciao via produce"
~~~~ enter produce() ~~~~
move-construct Noisy@0x7ffd083733d0:"Hi via produce"
   ... from (moved) ""
~~~~ leave produce() ~~~~
move-assign Noisy@0x7ffd08373310:"Hi via produce"
   ... from (moved) Noisy@0x7ffd083733d0:""
destroy Noisy@0x7ffd083733d0:""
  n=Noisy@0x7ffd08373310:"Hi via produce"
~~~~ leave test_return() ~~~~
destroy Noisy@0x7ffd08373310:"Hi via produce"

À la lecture du code source, nous constatons que la variable result, qui est fabriquée dans s4prc::produce() et renvoyée comme résultat, sert à initialiser la variable n du contexte appelant.
Nous nous attendons donc à observer la création de result, sa recopie vers n puis sa destruction.
L'étude attentive des messages produits à l'exécution montre cependant un scénario bien différent : la variable result locale à s4prc::produce() n'est rien d'autre que la variable n du contexte appelant (les adresses le confirment sans ambiguïté) !
Cette optimisation de la valeur de retour (Return Value Optimisation) relève d'une démarche très agressive entreprise par tous les compilateurs C++ modernes✍.
Elle consiste à fabriquer la valeur qui doit servir de résultat pour une fonction directement dans l'emplacement du contexte appelant qui doit accueillir ce résultat.
Dans le cas présent, le résultat devait servir à initialiser la variable n : le compilateur décide alors que ce résultat est directement la variable n, sans recourir à la moindre recopie, ni même à une opération de déplacement !

En poursuivant la lecture du code source, nous constatons un second appel à s4prc::produce() qui sert cette fois-ci à réaliser une opération d'affectation sur la variable n (qui existe déjà dorénavant).
Les messages produits à cette occasion lors de l'exécution indiquent l'apparition d'une valeur temporaire pour accueillir le résultat de la fonction.
Une opération de déplacement est ensuite réalisée pour affecter cette nouvelle valeur à la variable n, avant la destruction de la valeur temporaire devenue, dès lors, inutile.
Cette valeur temporaire pourrait sembler superflue au premier abord mais il n'en est rien.
En effet, le rôle de la fonction s4prc::produce() est de fournir une nouvelle valeur de type

s4prc::Noisy<std::string>

: soit on s'en contente en l'état comme ce fut le cas lors de la première invocation pour initialiser directement n, soit on réutilise cette nouvelle valeur pour un autre usage comme c'est le cas lors de cette seconde invocation.
Cet autre usage ne concerne en aucune façon la fonction s4prc::produce() ; la valeur renvoyée doit donc exister, éventuellement de manière temporaire, dans le contexte appelant afin que ce dernier en fasse l'usage souhaité (ici la modification de n par une affectation).
Remarquez néanmoins que, puisqu'il s'agit d'une valeur temporaire, le compilateur génère une opération de déplacement et non une véritable recopie.

Comme bilan de cette étape nous constatons que, malgré les apparences à la lecture du code source, renvoyer le résultat d'une fonction n'implique pas la recopie effective de la valeur mais au pire une simple opération de déplacement, voire même aucune opération.
Par conséquent, nous devons privilégier le renvoi par valeur du résultat d'une fonction, y compris pour des types élaborés potentiellement coûteux à recopier, et éviterons d'avoir recours à un passage par adresse pour accueillir ce résultat comme nous le faisions en langage C (voir cette section du cours S3-PRC)✍.

{} Passage de paramètres à une fonction

Toujours à propos des appels de fonctions, le passage de paramètres consiste à initialiser dans le contexte de la fonction appelée un paramètre formel dont la valeur est donnée par celle d'un paramètre effectif du contexte appelant (voir cette section du cours S3-PRC).
Il s'agit à nouveau d'une opération qui s'apparente à une recopie ; il est par conséquent légitime de l'étudier dans le cadre de cette expérimentation.

Ajoutez maintenant cette fonction :

void
consume(Noisy<std::string> param)
{
  std::cout << "~~~~ " << __func__ << '(' << param << ") ~~~~\n";
}

au module fnct_call.cpp et celle-ci :

void
test_params()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n{"DATA"};
  s4prc::consume(n);
  std::cout << "...\n";
  s4prc::consume(NoisyStr{"TEMPORARY"});
  std::cout << "...\n";
  s4prc::consume(std::move(n));
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

au fichier prog.cpp qui l'appellera depuis sa fonction principale.
Assurez-vous du fait que le programme se fabrique et s'exécute sans encombre.

Exemple de messages produits

~~~~ enter test_params() ~~~~
move-construct Noisy@0x7ffd08373290:"DATA"
   ... from (moved) ""
copy-construct Noisy@0x7ffd08373310:"DATA"
   ... from Noisy@0x7ffd08373290:"DATA"
~~~~ consume(Noisy@0x7ffd08373310:"DATA") ~~~~
destroy Noisy@0x7ffd08373310:"DATA"
...
move-construct Noisy@0x7ffd08373390:"TEMPORARY"
   ... from (moved) ""
~~~~ consume(Noisy@0x7ffd08373390:"TEMPORARY") ~~~~
destroy Noisy@0x7ffd08373390:"TEMPORARY"
...
move-construct Noisy@0x7ffd083733d0:"DATA"
   ... from (moved) Noisy@0x7ffd08373290:""
~~~~ consume(Noisy@0x7ffd083733d0:"DATA") ~~~~
destroy Noisy@0x7ffd083733d0:"DATA"
~~~~ leave test_params() ~~~~
destroy Noisy@0x7ffd08373290:""

La lecture du code source nous indique que le paramètre du premier appel à la fonction s4prc::consume() doit être une copie de la variable n.
C'est bien ce que confirment les messages produits à l'exécution ; aucune surprise n'apparaît à ce stade de l'expérimentation.

Pour la deuxième invocation de la fonction s4prc::consume() nous fournissons en paramètre une valeur temporaire.
Les messages obtenus indiquent que le paramètre formel est directement construit comme étant cette valeur temporaire.
Nous aurions pu supposer qu'il fût nécessaire de recopier (ou à tout le moins déplacer) cette valeur temporaire du contexte appelant vers le paramètre formel de la fonction appelée, mais la situation est idéale puisque ce dernier est bien construit sur place.

Le troisième appel à la fonction s4prc::consume() repose sur une connaissance du programmeur, indiquée explicitement par l'usage de std::move(), pour signifier qu'il n'est pas nécessaire de conserver l'état de la variable n après sa transmission en paramètre✍.
Les messages témoignent alors du fait qu'une opération de déplacement est bien générée pour initialiser le paramètre formel de la fonction appelée, ce qui économise une potentiellement coûteuse recopie des données utiles.

Les comportements observés lors des passages de paramètres sont, somme toute, semblables à ceux que nous avions constatés lors de l'initialisation de variables.
En effet, les paramètres formels d'une fonction ne sont finalement rien d'autre que de nouvelles variables créées et initialisées juste pour la durée de l'appel.

Cette expérimentation concernait la recopie de données, que ce soit dans le cadre de l'initialisation ou l'affectation de variables, ou encore dans celui des appels et retours de fonctions✍.
Nous retiendrons principalement que :

les données ont une durée de vie limitée, matérialisée par des opérations de création et de destruction qui permettent notamment aux types élaborés d'allouer et libérer leurs ressources internes,
l'initialisation ou l'affectation d'une donnée élaborée à partir d'une valeur fournie, consiste à dupliquer et recopier entièrement les ressources internes de cette valeur, ce qui peut s'avérer coûteux en temps d'exécution s'il s'agit d'un volume important d'information,
les opérations de déplacement peuvent se substituer avantageusement aux opérations de recopie puisqu'elles reviennent à déposséder la valeur fournie de ses ressources internes pour les attribuer à la donnée de destination,
- la potentiellement coûteuse duplication des ressources internes est ainsi économisée,
- la valeur fournie ne contient alors probablement plus les ressources internes dont elle disposait avant le déplacement,
les valeurs temporaires utilisées pour l'initialisation ou l'affectation d'une donnée sont implicitement soumises aux opérations de déplacement,
le programmeur a tout intérêt à signifier explicitement avec std::move() le fait qu'une donnée, dont il n'est pas nécessaire de conserver l'état, doit être soumise au déplacement,
le renvoi du résultat d'une fonction doit se faire par valeur car, malgré les apparences, l'optimisation de la valeur de retour ne donne lieu qu'à un déplacement dans le pire des cas, et à aucune opération dans le meilleur,
le passage d'un paramètre à une fonction implique une recopie, qui peut néanmoins être substituée par un déplacement dans le cas de l'emploi de std::move(), ou encore être complètement éludée dans le cas d'une valeur temporaire.

Puisque le choix d'utiliser C++ est principalement motivé par le soucis d'économiser les ressources, nous devons dorénavant, dans nos futures réalisations, nous interroger de manière systématique sur l'implication des transmissions de données au regard des informations découvertes lors de cette expérimentation.

Code source de l'expérimentation

Si chaque étape a été respectée scrupuleusement, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier noisy.hpp✎

Contenu du fichier noisy.hpp

//----------------------------------------------------------------------------

#ifndef S4PRC_NOISY_HPP
#define S4PRC_NOISY_HPP

#include <iostream>
#include <string>
#include <vector>

namespace s4prc {

inline
std::ostream &
operator<<(std::ostream &output,
           const std::string &s) // display string within quotes
{
  using std::operator<<;
  output << '"';
  if(const auto sz=size(s); sz>20) // prevent from using too much space
  {
    output << s.substr(0, 10) << "..." << s.substr(sz-10);
  }
  else
  {
    output << s;
  }
  return output << '"';
}

template<typename E>
inline
std::ostream &
operator<<(std::ostream &output,
           const std::vector<E> &v) // display vector within braces
{
  output << '{';
  if(const auto sz=size(v); sz>4) // prevent from using too much space
  {
    output << v[0] << ',' << v[1] << ",...," << v[sz-2] << ',' << v[sz-1];
  }
  else
  {
    int count=0;
    for(const auto &elem: v)
    {
      if(count++)
      {
        output << ',';
      }
      output << elem;
    }
  }
  return output << '}';
}

template<typename T>
struct Noisy : T
{
  Noisy()
  : T{}
  {
    std::cout << "construct " << *this
              << " from nothing\n";
  }

  Noisy(const T &t)
  : T{t}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << t << '\n';
  }

  Noisy(T &&t)
  : T{std::move(t)}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << t << '\n';
  }

  Noisy(const Noisy &n)
  : T{static_cast<const T &>(n)}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << n << '\n';
  }

  Noisy(Noisy &&n) noexcept
  : T{std::move(static_cast<T &&>(n))}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << n << '\n';
  }

  Noisy &
  operator=(const T &t)
  {
    T::operator=(t);
    std::cout << "copy-assign " << *this
              << "\n   ... from " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(T &&t)
  {
    T::operator=(std::move(t));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(const Noisy &n)
  {
    T::operator=(static_cast<const T &>(n));
    std::cout << "copy-assign " << *this
              << "\n   ... from " << n << '\n';
    return *this;
  }

  Noisy &
  operator=(Noisy &&n) noexcept
  {
    T::operator=(std::move(static_cast<T &&>(n)));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << n << '\n';
    return *this;
  }

  ~Noisy()
  {
    std::cout << "destroy " << *this << '\n';
  }

  friend
  std::ostream &
  operator<<(std::ostream &output,
             const Noisy &n)
  {
    return output << "Noisy@" << &n << ":" << static_cast<const T &>(n);
  }
};

} // namespace s4prc

#endif // S4PRC_NOISY_HPP

//----------------------------------------------------------------------------

Fichier fnct_call.hpp✎

Fichier fnct_call.cpp✎

Fichier prog.cpp✎

Contenu du fichier prog.cpp

//----------------------------------------------------------------------------

#include <iostream>
#include "noisy.hpp"
#include "fnct_call.hpp"

using NoisyStr = s4prc::Noisy<std::string>; // ease code writing

void
test_construct_destroy()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n1;
  NoisyStr n2{"DATA"};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

void
test_copy()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n1;
  NoisyStr n2{"DATA"};
  NoisyStr n3{n2};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=n3;
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=NoisyStr{"NEW DATA"};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

void
test_move()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n1;
  NoisyStr n2{"DATA"};
  NoisyStr n3{std::move(n2)};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=std::move(n3);
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  n1=NoisyStr{"NEW DATA"};
  std::cout << "  n1=" << n1 << "\n  n2=" << n2 << "\n  n3=" << n3 << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

void
test_return()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n{s4prc::produce("Ciao")};
  std::cout << "  n=" << n << '\n';
  n=s4prc::produce("Hi");
  std::cout << "  n=" << n << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

void
test_params()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  NoisyStr n{"DATA"};
  s4prc::consume(n);
  std::cout << "...\n";
  s4prc::consume(NoisyStr{"TEMPORARY"});
  std::cout << "...\n";
  s4prc::consume(std::move(n));
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

int
main()
{
  test_construct_destroy();
  test_copy();
  test_move();
  test_return();
  test_params();
  return 0;
}

//----------------------------------------------------------------------------

{} Partage de données volumineuses

Maintenant qu'ont été découverts les mécanismes que le langage propose en matière de recopie et de déplacement de données, il convient de s'intéresser aux implications de leur usage concret sur des données volumineuses (car constituées de nombreux éléments).
L'ambition est d'évaluer le coût d'exécution de ces transmissions et d'aboutir à des recommandations pour suivre une démarche systématique quant au partage efficace de telles données.

{} Mise en place de l'expérimentation

À titre d'exemple et de démonstration, nous nous appuierons sur des tableaux dynamiques contenant de nombreuses chaînes de caractères afin que la recopie fortuite d'un tel volume d'information ne puisse pas être considérée comme ayant un coût d'exécution négligeable.
Cette expérimentation passera par la réalisation d'un nouveau programme.
Créez alors sur votre poste de travail un répertoire de votre choix dans lequel vous placerez le fichier GNUmakefile, un fichier prog.cpp, un module str_vec.hpp/str_vec.cpp et le fichier noisy.hpp✎

Contenu du fichier noisy.hpp

//----------------------------------------------------------------------------

#ifndef S4PRC_NOISY_HPP
#define S4PRC_NOISY_HPP

#include <iostream>
#include <string>
#include <vector>

namespace s4prc {

inline
std::ostream &
operator<<(std::ostream &output,
           const std::string &s) // display string within quotes
{
  using std::operator<<;
  output << '"';
  if(const auto sz=size(s); sz>20) // prevent from using too much space
  {
    output << s.substr(0, 10) << "..." << s.substr(sz-10);
  }
  else
  {
    output << s;
  }
  return output << '"';
}

template<typename E>
inline
std::ostream &
operator<<(std::ostream &output,
           const std::vector<E> &v) // display vector within braces
{
  output << '{';
  if(const auto sz=size(v); sz>4) // prevent from using too much space
  {
    output << v[0] << ',' << v[1] << ",...," << v[sz-2] << ',' << v[sz-1];
  }
  else
  {
    int count=0;
    for(const auto &elem: v)
    {
      if(count++)
      {
        output << ',';
      }
      output << elem;
    }
  }
  return output << '}';
}

template<typename T>
struct Noisy : T
{
  Noisy()
  : T{}
  {
    std::cout << "construct " << *this
              << " from nothing\n";
  }

  Noisy(const T &t)
  : T{t}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << t << '\n';
  }

  Noisy(T &&t)
  : T{std::move(t)}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << t << '\n';
  }

  Noisy(const Noisy &n)
  : T{static_cast<const T &>(n)}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << n << '\n';
  }

  Noisy(Noisy &&n) noexcept
  : T{std::move(static_cast<T &&>(n))}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << n << '\n';
  }

  Noisy &
  operator=(const T &t)
  {
    T::operator=(t);
    std::cout << "copy-assign " << *this
              << "\n   ... from " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(T &&t)
  {
    T::operator=(std::move(t));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(const Noisy &n)
  {
    T::operator=(static_cast<const T &>(n));
    std::cout << "copy-assign " << *this
              << "\n   ... from " << n << '\n';
    return *this;
  }

  Noisy &
  operator=(Noisy &&n) noexcept
  {
    T::operator=(std::move(static_cast<T &&>(n)));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << n << '\n';
    return *this;
  }

  ~Noisy()
  {
    std::cout << "destroy " << *this << '\n';
  }

  friend
  std::ostream &
  operator<<(std::ostream &output,
             const Noisy &n)
  {
    return output << "Noisy@" << &n << ":" << static_cast<const T &>(n);
  }
};

} // namespace s4prc

#endif // S4PRC_NOISY_HPP

//----------------------------------------------------------------------------

(identique à celui de l'expérimentation précédente).
Le fichier d'en-tête str_vec.hpp✎ est fourni ; nous y trouvons notamment l'usage d'une directive using afin que le nom de type s4prc::StrVec représente une facilité d'écriture pour désigner un tableau dynamique de chaînes.

Commencez par définir dans str_vec.cpp la fonction s4prc::make_StrVec().

StrVec
make_StrVec(int count)
{
  StrVec result;
  for(int i=0; i<count; ++i)
  {
    result.emplace_back("str"+std::to_string(i));
  }
  return result;
}

Elle déclare une variable de type StrVec afin de la remplir avec de nombreuses chaînes (ce nombre est contrôlé grâce au paramètre).
Chacune de ces chaînes est ajoutée à cette variable par sa fonction membre emplace_back() recevant "str"+std::to_string(i) (i étant le compteur de boucle) comme paramètre✍.
Le tableau dynamique renseigné ici, bien que contenant probablement beaucoup d'information, est simplement renvoyé par valeur puisque nous avons vu précédemment que ce cas est idéalement optimisé.

Le fichier prog.cpp devra contenir cette fonction test_noisy() :

void
test_noisy()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  s4prc::Noisy<s4prc::StrVec> big=s4prc::make_StrVec(10'000);
  std::cout << ">>> big=" << big << '\n';
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

Elle affiche clairement par des messages son début et sa terminaison (comme nous l'avons fait dans l'expérimentation précédente), et fabrique une variable big de type

s4prc::Noisy<s4prc::StrVec>

initialisée par un appel à s4prc::make_Strvec() réclamant 10'000✍ chaînes.
La valeur de la variable big est alors explicitement affichée✍.

La fonction test_noisy() sera appelée depuis la fonction principale.
Assurez-vous du fait que le programme se fabrique et s'exécute sans encombre, et vérifiez que les messages produits par le type Noisy<T> sont conformes à ce que nous savons depuis l'expérimentation précédente :

création de la variable big à partir d'une valeur,
destruction de la valeur de cette variable à la sortie de la fonction.

{} Utilisation de la recopie et du déplacement

Définissons maintenant dans strVec.cpp la fonction s4prc::change_by_val() qui utilise le type

Noisy<StrVec>

Noisy<StrVec>
change_by_val(Noisy<StrVec> sv,
              std::string s,
              char c)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  sv.emplace_back(std::move(s));
  for(auto &elem: sv)
  {
    elem+=c;
  }
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
  return sv;
}

Elle affiche clairement par des messages son début et sa terminaison (comme nous en avons l'habitude désormais), ajoute au tableau dynamique sv la chaîne s, puis ajoute à chacune de ses chaînes le caractère c, avant de renvoyer sv comme résultat✍.

Dans le fichier prog.cpp, il faut alors compléter la fonction test_noisy() afin qu'elle fasse usage de s4prc::change_by_val().

...
big=s4prc::change_by_val(big, std::to_string(size(big))+'!', 'A');
std::cout << ">>> big=" << big << '\n';
...

Elle reçoit big pour lui ajouter la chaîne std::to_string(size(big))+'!'✍ ainsi que la lettre 'A' à chacune de ces chaînes, puis big est réaffecté avec cette nouvelle valeur.
Nous constatons la modification de cette valeur par un nouvel affichage explicite de la valeur de la variable big.

Assurez-vous du fait que le programme se fabrique et s'exécute sans encombre, et que la variable big est bien dans l'état attendu.
L'observation attentive des messages produits par le type Noisy<T> doit montrer qu'ils sont à nouveau conformes à ce que nous savons depuis l'expérimentation précédente :

création du paramètre effectif par recopie de la variable big,
création de la valeur temporaire résultante par déplacement du paramètre effectif modifié,
affectation à la variable big par déplacement de cette valeur temporaire.

Si le renvoi du résultat très volumineux de la fonction s4prc::change_by_val() n'est absolument pas coûteux en temps d'exécution (grâce aux opérations de déplacement qui sont implicitement utilisées), la recopie utilisée lors de la création de son paramètre effectif est au contraire probablement très pénalisante (nous le constaterons prochainement).
Puisque nous transmettons big à la fonction s4prc::change_by_val() afin qu'elle nous le restitue après modification, il n'est alors pas nécessaire d'en recopier le contenu lors de cet appel.
Par conséquent, nous pouvons explicitement utiliser std::move() sur big lors de l'appel car nous savons que nous allons écraser le contenu de notre variable big avec le résultat de la fonction (elle peut donc être dépossédée de son contenu initial pour le déplacer vers le paramètre sv).

Complétons à nouveau la fonction test_noisy() pour provoquer un tel déplacement.

...
big=s4prc::change_by_val(std::move(big), std::to_string(size(big))+'!', 'B');
std::cout << ">>> big=" << big << '\n';
...

Après une nouvelle fabrication, les messages produits à l'exécution de ce programme doivent montrer qu'il n'y a désormais plus de recopie de ce volumineux tableau dynamique de chaînes lors de ce deuxième appel à la fonction s4prc::changeByVal().

Il n'est pas complètement faux d'affirmer que nous sommes parvenus à nos fins : faire en sorte qu'une fonction puisse modifier une donnée très volumineuse de son contexte appelant sans impliquer de coûteuses copies superflues.
Néanmoins le procédé utilisé ici est très loin d'être satisfaisant car il demande une très grande implication du programmeur qui utilise une telle fonction :

il doit d'une part penser à utiliser std::move() lors de l'appel,
il doit d'autre part penser à réaffecter le résultat dans la variable qu'il a transmise par std::move().

Par conséquent, nous ne retiendrons pas cette solution, ce qui nous conduit à nous tourner vers une autre fonctionnalité du langage C++.

{} Passage par référence

Tout bien considéré, ce que nous cherchons à faire ici correspond exactement au besoin que nous avions déjà exprimé lors de l'introduction des pointeurs en langage C : fournir un moyen de se référer à une donnée qui existe à l'extérieur d'une fonction afin que cette dernière la modifie (voir cette section du cours S3-PRC).
Le langage C++ étant très largement compatible avec le langage C, il serait alors tout à fait possible de décider que la fonction concernée attende un pointeur vers la donnée volumineuse sur laquelle elle opère✍.

Cependant, l'expérience montre que l'usage abusif et mal maîtrisé des pointeurs, que ce soit en C ou en C++, est à l'origine de beaucoup de maladresses de programmation et de dysfonctionnements, et pas seulement chez les programmeurs peu expérimentés !
De plus, les pointeurs peuvent servir une très grande variété de causes (accès à une simple donnée, parcours d'un tableau, allocation dynamique, arithmétique...) qui sont très difficiles à analyser pour un compilateur lorsque ce dernier doit envisager les conséquences d'une optimisation potentielle.
Pour toutes ces raisons, les experts de C++ s'accordent sur le fait qu'il faut éviter autant que possible d'avoir recours aux pointeurs✍.
(voir notamment les pages 31 à 34 de la présentation “C++11 Style: A Touch of Class” par Bjarne Stroustrup à la conférence GoingNative 2012)

Le mécanisme de C++ qui permet d'indiquer explicitement que nous ne voulons pas avoir recours à une recopie ni même à un déplacement repose sur l'usage d'une référence.

Complément : exemple simpliste d'utilisation d'une référence

Cet exemple illustre la forme et la nature d'une référence mais n'est absolument pas représentatif d'un usage utile qu'on pourrait en avoir.

int a=5;
int &b=a; // ``b'' is a reference on ``a''
std::cout << "a=" << a << "  b=" << b << '\n'; // a=5  b=5
++b; // change the value referenced by ``b'' --> this changes ``a''
std::cout << "a=" << a << "  b=" << b << '\n'; // a=6  b=6
++a; // change ``a'' --> this is visible through ``b''
std::cout << "a=" << a << "  b=" << b << '\n'; // a=7  b=7

Une référence utilise le symbole

dans sa déclaration (juste avant son nom, comme le symbole

dans la déclaration d'un pointeur) et est forcément initialisée depuis une donnée existante lors de sa déclaration (elle doit nécessairement référencer quelque chose !).
La référence se manipule ensuite exactement comme la donnée référencée, sans symbole supplémentaire✍.

(https://en.cppreference.com/w/cpp/language/reference)
Coupons tout de suite court aux suppositions : il s'agit bien d'avoir recours, mais de manière dissimulée, à l'adresse de la donnée que nous désignons comme si nous utilisions un pointeur...
Seulement, une telle référence ne sert qu'à désigner une unique donnée forcément existante (il n'y a pas de référence nulle) et qui ne peut pas changer (il n'y a pas de réaffectation ni d'arithmétique des références).
Dans ces conditions, nous nous tenons éloignés de la problématique de l'allocation dynamique✍ et le compilateur à une bien meilleure vision de ce qu'il peut se permettre d'envisager en terme d'optimisation✍.

Contrairement à l'exemple simpliste précédent, une référence trouve une très grande utilité lorsqu'elle sert de paramètre à une fonction : on parle alors de passage par référence.
Il suffit pour ceci d'utiliser le symbole

dans la déclaration du paramètre en question (juste avant son nom, comme le symbole

dans la déclaration d'un pointeur)✍.
Dans ces conditions, le paramètre formel sera une référence vers la donnée utilisée comme paramètre effectif lors de l'appel, il n'y aura donc pas de recopie ni même de déplacement de cette dernière.

À la lumière de ces explications, nous pouvons maintenant définir dans str_vec.cpp la fonction s4prc::change_by_ref() qui utilise le type

Noisy<StrVec> &

void
change_by_ref(Noisy<StrVec> &sv,
              std::string s,
              char c)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  sv.emplace_back(std::move(s));
  for(auto &elem: sv)
  {
    elem+=c;
  }
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

Son code est quasiment identique à celui de la fonction s4prc::changeByVal() si ce n'est qu'il n'est plus nécessaire de renvoyer de résultat.
Remarquez que le paramètre transmis par référence se manipule directement, sans symbole supplémentaire✍.

Complétons alors à nouveau la fonction test_noisy() de prog.cpp afin de faire usage de la fonction s4prc::change_by_ref().

...
s4prc::change_by_ref(big, std::to_string(size(big))+'!', 'C');
std::cout << ">>> big=" << big << '\n';
...

Remarquez que le passage de la variable big comme premier paramètre à la fonction s4prc::change_by_ref() (qui attend une référence) s'exprime le plus naturellement possible, sans symbole supplémentaire✍.
Après une nouvelle fabrication, les messages produits à l'exécution de ce programme doivent montrer qu'il n'y a aucun message issu du type s4prc::Noisy<T> lors de cet appel à la fonction s4prc::change_by_ref().
Pourtant, la nouvelle valeur de la variable big porte bien les effets de cet appel.
Nous sommes donc parvenus, grâce au passage de paramètre par référence, à notre objectif (limiter les coûteuses recopies superflues) tout en conservant cette fois-ci un style d'écriture simple et peu contraignant.

{} Passage par référence constante

Remarquons toutefois que, même si la nécessité du passage par référence nous est apparue dans cette expérimentation comme une réponse au besoin d'utiliser un paramètre d'entrée-sortie (in-out✍), ce mode de passage n'est pas exclusivement réservé à cet usage.
En effet, même dans le cas d'un paramètre d'entrée (in✍), il est important de se prémunir contre le surcoût de la recopie inutile d'une donnée très volumineuse.
De la même façon qu'un pointeur peut être qualifié de const afin de signifier explicitement le fait qu'il ne peut pas servir à modifier la donnée désignée (mais simplement à y accéder sans la recopier, voir cette section et cette section du cours S3-PRC), le mot-clef const peut précéder la déclaration d'une référence afin de signifier la même intention✍.
C'est très utile dans le cas d'un paramètre de fonction : nous parlons d'un passage par référence constante (const-ref).

Si nous voulions réaliser une fonction qui calcule la somme des longueurs des chaînes mémorisées dans un volumineux tableau dynamique, nous pourrions la définir ainsi :

int
total_length(const std::vector<std::string> &sv)
{
  int result=0;
  for(const auto &elem: sv)
  {
    result+=int(size(elem));
  }
  return result;
}

Le passage par référence évite la recopie du tableau dynamique désigné par sv, mais le qualificatif const qui l'accompagne nous interdit toute opération qui tendrait à le modifier (ceci provoquerait une erreur à la compilation).
Nous ne faisons que le consulter pour visiter chacun de ses éléments dans le but de consulter sa taille.
Aucune de ces opérations ne modifie le tableau dynamique ni les chaînes qu'il contient ; seule la variable result est modifiée au cours de ce traitement.
Cette fonction pourrait simplement être invoquée de cette façon :

auto big=s4prc::make_StrVec(10'000);
int length=total_length(big);

sans que cela n'implique de recopie superflue de la valeur de la variable big.

Complément : type de la longueur d'une chaîne

{} Mémorisation de paramètres

Revenons maintenant sur l'usage du paramètre s dans les fonctions s4prc::change_by_val() et s4prc::change_by_ref().
Il s'agit d'une chaîne de caractères qui pourrait potentiellement être très longue.
En première analyse, nous pourrions craindre que son passage par valeur puisse induire une coûteuse recopie inutile.
Puisque nous n'avons pas l'intention de modifier la chaîne qui sert de paramètre effectif, nous pourrions être tentés d'utiliser un passage de paramètre par référence constante.
Ce choix serait parfaitement justifié si nous voulions simplement consulter le paramètre en question ; seulement ici nous souhaitons le mémoriser dans un nouvel emplacement (à la suite du tableau dynamique).

Dans ces nouvelles conditions, il n'est pas suffisant de laisser les données en question dans leur emplacement d'origine : il faut nécessairement les faire parvenir dans l'emplacement où elles doivent être mémorisées.
Il existe alors une stratégie plus avantageuse qui consiste à effectuer un passage par valeur puis à provoquer un déplacement du paramètre formel vers son emplacement de destination.
En voici la justification :

Si nous choisissons un passage par référence constante pour le paramètre qui doit être mémorisé :
- Si le paramètre effectif est une valeur temporaire,
  - le paramètre formel est une référence constante vers la valeur temporaire,
  - nous devons recopier cette valeur temporaire vers son emplacement de destination,
  - bilan : une recopie.
- Si le paramètre effectif est une donnée existante du contexte appelant,
  - le paramètre formel est une référence constante vers cette donnée,
  - nous devons recopier cette donnée vers son emplacement de destination,
  - bilan : une recopie.
Nous constatons que dans tous les cas une recopie doit avoir lieu.
Si nous choisissons un passage par valeur pour le paramètre qui doit être mémorisé :
- Si le paramètre effectif est une valeur temporaire,
  - le paramètre formel est directement le paramètre effectif sans recopie ni déplacement (voir cette section),
  - nous déplaçons explicitement (avec std::move()) le paramètre formel vers son emplacement de destination,
  - bilan : un déplacement.
- Si le paramètre effectif est une donnée existante du contexte appelant que nous souhaitons conserver,
  - le paramètre effectif est recopié implicitement vers le paramètre formel,
  - nous déplaçons explicitement (avec std::move()) le paramètre formel vers son emplacement de destination,
  - bilan : une recopie et un déplacement.
- Si le paramètre effectif est une donnée existante du contexte appelant que nous déplaçons explicitement (avec std::move()),
  - le paramètre effectif est déplacé explicitement (avec std::move()) vers le paramètre formel,
  - nous déplaçons explicitement (avec std::move()) le paramètre formel vers son emplacement de destination,
  - bilan : deux déplacements.
Nous constatons qu'une recopie n'a lieu que lorsqu'elle est absolument nécessaire (nous voulons conserver la donnée originale dans le contexte appelant, ce qui est assez rare en pratique) ; dans tous les autres cas nous n'effectuons qu'un ou deux déplacements.

Lorsqu'un paramètre potentiellement coûteux à recopier doit être mémorisé, il est bénéfique de le transmettre par valeur et de déplacer le paramètre formel vers son emplacement de destination✍.

{} Renvoi de multiples résultats

Souvenons-nous maintenant du prétexte que nous avions utilisé pour l'introduction des pointeurs en langage C : il consistait à pallier le fait qu'une fonction ne pouvait renvoyer qu'un seul résultat.
Nous passions alors autant de pointeurs vers des données du contexte appelant qu'il y avait de résultats à obtenir (voir cette section du cours S3-PRC).
Étant donné les points communs qui existent entre les pointeurs et les références, il semble naturel de chercher à utiliser ces dernières à cette même fin.
D'un point de vue technique, c'est effectivement réalisable, et c'était même une pratique courante en C++ ancien, mais désormais en C++ moderne il est recommandé de procéder autrement.
En effet, nous avons constaté que l'optimisation de la valeur de retour permettait de transmettre sans surcoût un résultat quelconque au contexte appelant lors de l'usage de return✍.
Comme le recommande la règle F.21 des CppCoreGuideLines, ceci nous donne l'opportunité de ne reposer que sur l'instruction return pour fournir tous les résultats d'une fonction, ce qui rend plus explicite le rôle de cette fonction✍.

Afin de renvoyer plusieurs résultats avec une instruction return, il serait envisageable d'inventer une structure dont les membres regrouperaient les différentes valeurs à transmettre.
Il arrive que ce soit le cas lorsque ce groupe de valeur à lui même une signification utile (les coordonnées d'un point, les dimensions d'un rectangle...), mais de manière générale il est très contraignant de définir explicitement de telles structures (ne serait-ce que pour choisir leur nom !).
Le fichier d'en-tête standard

<tuple>

du langage C++ moderne expose le type std::tuple<...> qui représente un ensemble ordonné et fini d'éléments (un t-uplet en français) ; il s'agit en quelque sorte d'une structure anonyme dont les membres sont également anonymes.
Ainsi, le type

std::tuple<int, char, double>

est constitué, dans l'ordre, d'un entier, d'un caractère et d'un réel.
(https://en.cppreference.com/w/cpp/utility/tuple)

La fonction s4prc::many_results() doit consulter le tableau dynamique de chaînes qui lui est passé par référence constante afin de produire une valeur de retour constituée de trois informations.
Définissons alors, dans le fichier str_vec.cpp, cette fonction.

std::tuple<Noisy<std::string>, // even strings
           Noisy<std::string>, // odd strings
           int>                // total length
many_results(const Noisy<StrVec> &sv)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  Noisy<std::string> even, odd;
  int length=0, count=0;
  for(const auto &elem: sv)
  {
    (count++%2 ? odd : even)+=elem;
    length+=int(size(elem));
  }
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
  return {even, odd, length}; // !!! copies involved !!! (will be fixed later)
}

Après avoir déclaré les variables even, odd et length correspondant aux trois informations à renvoyer, elle parcourt le tableau dynamique pour accumuler dans even les chaînes situées aux indices pairs du tableau dynamique, dans odd celles qui sont situées aux indices impairs et dans length les longueurs de toutes ces chaînes.
L'instruction de retour se contente, dans un premier temps, de renvoyer la donnée de type std::tuple<...> attendue, directement fabriquée à partir des trois variables even, odd et length transmises dans cet ordre✍.
Remarquez que le tableau dynamique de chaînes transmis en paramètre ne sert qu'à être consulté ; il est alors transmis par référence constante.

Complétons encore la fonction test_noisy() du fichier prog.cpp de cette façon :

...
const auto [even_str, odd_str, total_length]=s4prc::many_results(big);
std::cout << ">>> even_str=" << even_str << '\n';
std::cout << ">>> odd_str=" << odd_str << '\n';
std::cout << ">>> total_length=" << total_length << '\n';
...

Nous retrouvons l'usage du mot-clef auto dans une nouvelle formulation qui consiste à déclarer plusieurs variables au sein d'une paire de crochets.
Chacune de ces variables désigne simplement un membre du std::tuple<...> obtenu (dans l'ordre de leur énumération)✍.
(https://en.cppreference.com/w/cpp/language/structured_binding)
Ces trois variables sont ensuite très naturellement utilisées pour produire l'affichage de messages explicites.

Après une nouvelle fabrication du programme, vérifiez que son exécution produit bien l'affichage des trois nouveaux résultats attendus.
Toutefois, le type s4prc::Noisy<T> utilisé sur les variables even et odd de la fonction s4prc::many_results() témoigne d'une création par recopie lors de la transmission de chacune d'elles au retour de la fonction.
Ce constat semble contredire l'optimisation de la valeur de retour sur laquelle nous comptons dorénavant !
Il n'en est rien cependant : le renvoi du résultat de type std::tuple<...> n'implique aucune recopie de celui-ci mais ce sont les initialisations de ses trois membres qui impliquent la recopie des variables even, odd et length de la fonction s4prc::many_results().

Intervenez alors sur le retour de la fonction s4prc::many_results() afin d'utiliser std::move() sur chacun de ses trois paramètres comme nous en avons désormais l'habitude✍.

return {std::move(even),    // std::move() prevents from
        std::move(odd),     //   copying existing locals
        std::move(length)}; //     to tuple-members

C'est effectivement une bonne occasion de signifier au compilateur que ces variables n'ont pas besoin de conserver leur état après la construction de ce triplet de valeurs qui est sur le point d'être renvoyé (donc de mettre fin à la fonction).
Les messages produits lors de l'exécution de cette nouvelle version du programme doivent montrer que les créations par recopie superflues que nous constations laissent désormais place à des créations par déplacement.

{} Mesure des performances

L'essentiel de l'argumentation développée dans cette expérimentation repose sur le surcoût prohibitif en temps d'exécution que les recopies superflues des données volumineuses introduisent.
Maintenant que les divers mécanismes de partage d'information ont été présentés, il convient de mesurer et de comparer l'effet de leur mise en œuvre sur le temps d'exécution.

Les nombreux messages que notre programme produit sont très utiles à la bonne compréhension des mécanismes sous-jacents mais vont introduire un biais très important dans nos mesures de performances.
Pour cette raison, il faut commencer par définir, dans le fichier str_vec.cpp, des versions silencieuses des fonctions s4prc::change_by_val(), s4prc::change_by_ref() et s4prc::many_results() qui sont déjà déclarées dans notre fichier d'en-tête stdvec.hpp.
Ce ne sont que des copies presque conformes de celles que nous avons définies précédemment, si ce n'est qu'elles n'utilisent plus les types Noisy<T> et qu'elles n'affichent plus aucun message à leur entrée et à leur sortie.

Afin de vérifier qu'elles se comportent comme attendu, ajoutez la fonction suivante :

Fonction test_silent()

dans le fichier prog.cpp et invoquez là depuis la fonction principale.
Après une nouvelle fabrication, les quelques messages produits à l'exécution de cette nouvelle fonction doivent montrer que la version silencieuse de nos fonctions produit bien le même effet sur la variable big que leur version verbeuse.

Cette vérification préliminaire étant effectuée, nous pouvons aborder la mesure des performances : il s'agit de relever le temps passé pour exécuter un grand nombre de répétitions de chacune des fonctions.
La mesure du temps reposera sur cette fonction :

#include <chrono>

double // seconds (1e-6 precision) since 1970/01/01 00:00:00 UTC
get_time()
{
  const auto now=std::chrono::system_clock::now().time_since_epoch();
  const auto us=std::chrono::duration_cast<std::chrono::microseconds>(now);
  return 1e-6*double(us.count());
}

qui nous donne la date courante exprimée en secondes (avec des décimales allant jusqu'aux microsecondes)✍.
Ajoutez-la au fichier prog.cpp ainsi que celle-ci :

Fonction test_perf()

que vous étudierez et compléterez selon les indications des commentaires✍ avant de l'invoquer depuis la fonction principale.

Pour que les mesures de performances aient du sens, il est nécessaire de produire du code optimisé.
À cette fin, nous devons refabriquer le programme exécutable avec la commande : $ make rebuild opt=1 ↵ La cible rebuild de notre fichier GNUmakefile invoque la cible clean (pour effacer tous les fichiers produits automatiquement, voir cette section du cours S3-PRC) avant de provoquer une nouvelle fabrication du programme exécutable.
L'option opt=1 indique à notre fichier GNUmakefile qu'il doit utiliser des options de compilation pour générer du code exécutable optimisé et non plus instrumenté pour la mise au point (voir cette section du cours S3-PRC).
Dans ces conditions, les durées mesurées et affichées lors de l'exécution de la fonction test_perf() peuvent être comparées de manière significative.

Les trois premières mesures portent sur des traitements qui rendent le même service : l'examen attentif de l'état obtenu sur la variable big montre en effet une similitude parfaite (seuls les caractères 'A', 'B' ou 'C' diffèrent).
La durée reportée pour la première mesure, qui implique une recopie du tableau dynamique de chaînes à chaque invocation, se révèle être extrêmement longue, comme nous le supposions depuis le début de l'expérimentation✍.
Il est très rassurant de constater que les deux mesures suivantes tiennent effectivement leur promesse : les performances de ces deux solutions sont très proches l'une de l'autre et très largement supérieures à celle de la précédente.
La dernière mesure porte sur un traitement différent des précédents, mais la très bonne performance obtenue✍ illustre à nouveau le fait que le passage par référence constante et le renvoi de multiples résultats en éludant les recopies superflues sont parfaitement efficaces.
Les opérations de déplacement, les retours par valeur et les passages par référence ne sont donc pas des optimisations marginales, ni de simples raffinements, mais constituent bel et bien les piliers de toute réalisation décente en C++.

Les investigations que nous avons menées jusqu'alors nous permettent d'établir un ensemble de règles qui nous guideront dans la rédaction du code source pour un usage conventionnel de C++ (sans considérer les problématiques abordées par les experts).
Nous retiendrons principalement que :

les paramètres d'entrée (in) des fonctions,
- pour des données simples et peu volumineuses (types de base, structures dont la taille n'excède pas trois ou quatre fois celle d'un pointeur, chaînes std::string dont nous savons qu'elles sont probablement très courtes,...), doivent être passés par valeur,
- pour des données volumineuses, notamment celles qui utilisent en interne une allocation dynamique de mémoire (tableaux dynamiques std::vector<T>, chaînes std::string dont nous savons qu'elles peuvent être longues,...),
  - doivent être passés par référence constante s'ils ne sont que consultés,
  - doivent être passés par valeur puis déplacés vers leur destination lorsqu'ils doivent être mémorisés,
les paramètres de sortie (out) des fonctions sont systématiquement renvoyés par l'instruction return,
- ce résultat est transmis par valeur sans que cela n'implique de surcoût en temps d'exécution✍
  Il existe des exceptions qui sont si particulières qu'il serait prématuré de les considérer ici.
  (voir la règle F.21 des CppCoreGuideLines)
  ,
- s'il y a plusieurs résultats à transmettre, il faut renvoyer un std::tuple<...> en prenant soin de provoquer le déplacement des données locales qui en initialisent les membres,
les paramètres d'entrée-sortie (in-out) des fonctions,
- pour des données simples et peu volumineuses (voir un peu plus haut), doivent être transformés en paramètres d'entrée (in), passés par valeur en entrée, et renvoyées comme un résultat en sortie, sans prendre de précaution particulière,
- pour des données volumineuses (voir un peu plus haut), doivent être passés par référence (non constante afin de permettre la modification),
les références désignent avec un nouveau nom des données déjà existantes et permettent de les manipuler sans impliquer leur recopie,
il faut éviter, autant que faire se peut✍
Une utilisation très légitime des pointeurs consisterait à désigner un ensemble contigu d'éléments contenus dans une autre donnée.
Par exemple, notre fonction s4prc::many_results() pourrait accepter
```
const std::string *strings
```
et
```
int string_count
```
comme paramètres en lieu et place de
```
const std::vector<std::string> &sv
```
; ceci la rendrait tout aussi bien applicable à une donnée de type
```
std::array<std::string>
```
, ou encore à un sous ensemble d'une donnée de type
```
std::vector<std::string>
```
(si nous l'invoquions avec data(big)+1000 et int(size(big))-5000 par exemple).
Néanmoins, nous verrons ultérieurement qu'il existe un procédé encore plus générique pour parvenir à cette fin.
, d'avoir recours aux pointeurs.

Puisque le choix d'utiliser C++ est principalement motivé par le soucis d'économiser les ressources, nous devons dorénavant, dans nos futures réalisations, nous imposer de manière systématique le respect de ces règles.

Code source de l'expérimentation

Si chaque étape a été respectée scrupuleusement, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier noisy.hpp✎

Contenu du fichier noisy.hpp

//----------------------------------------------------------------------------

#ifndef S4PRC_NOISY_HPP
#define S4PRC_NOISY_HPP

#include <iostream>
#include <string>
#include <vector>

namespace s4prc {

inline
std::ostream &
operator<<(std::ostream &output,
           const std::string &s) // display string within quotes
{
  using std::operator<<;
  output << '"';
  if(const auto sz=size(s); sz>20) // prevent from using too much space
  {
    output << s.substr(0, 10) << "..." << s.substr(sz-10);
  }
  else
  {
    output << s;
  }
  return output << '"';
}

template<typename E>
inline
std::ostream &
operator<<(std::ostream &output,
           const std::vector<E> &v) // display vector within braces
{
  output << '{';
  if(const auto sz=size(v); sz>4) // prevent from using too much space
  {
    output << v[0] << ',' << v[1] << ",...," << v[sz-2] << ',' << v[sz-1];
  }
  else
  {
    int count=0;
    for(const auto &elem: v)
    {
      if(count++)
      {
        output << ',';
      }
      output << elem;
    }
  }
  return output << '}';
}

template<typename T>
struct Noisy : T
{
  Noisy()
  : T{}
  {
    std::cout << "construct " << *this
              << " from nothing\n";
  }

  Noisy(const T &t)
  : T{t}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << t << '\n';
  }

  Noisy(T &&t)
  : T{std::move(t)}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << t << '\n';
  }

  Noisy(const Noisy &n)
  : T{static_cast<const T &>(n)}
  {
    std::cout << "copy-construct " << *this
              << "\n   ... from " << n << '\n';
  }

  Noisy(Noisy &&n) noexcept
  : T{std::move(static_cast<T &&>(n))}
  {
    std::cout << "move-construct " << *this
              << "\n   ... from (moved) " << n << '\n';
  }

  Noisy &
  operator=(const T &t)
  {
    T::operator=(t);
    std::cout << "copy-assign " << *this
              << "\n   ... from " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(T &&t)
  {
    T::operator=(std::move(t));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << t << '\n';
    return *this;
  }

  Noisy &
  operator=(const Noisy &n)
  {
    T::operator=(static_cast<const T &>(n));
    std::cout << "copy-assign " << *this
              << "\n   ... from " << n << '\n';
    return *this;
  }

  Noisy &
  operator=(Noisy &&n) noexcept
  {
    T::operator=(std::move(static_cast<T &&>(n)));
    std::cout << "move-assign " << *this
              << "\n   ... from (moved) " << n << '\n';
    return *this;
  }

  ~Noisy()
  {
    std::cout << "destroy " << *this << '\n';
  }

  friend
  std::ostream &
  operator<<(std::ostream &output,
             const Noisy &n)
  {
    return output << "Noisy@" << &n << ":" << static_cast<const T &>(n);
  }
};

} // namespace s4prc

#endif // S4PRC_NOISY_HPP

//----------------------------------------------------------------------------

Fichier str_vec.hpp✎

Fichier str_vec.cpp✎

Contenu du fichier str_vec.cpp

//----------------------------------------------------------------------------

#include "str_vec.hpp"

namespace s4prc {

StrVec
make_StrVec(int count)
{
  StrVec result;
  for(int i=0; i<count; ++i)
  {
    result.emplace_back("str"+std::to_string(i));
  }
  return result;
}

//---- noisy functions ----

Noisy<StrVec>
change_by_val(Noisy<StrVec> sv,
              std::string s,
              char c)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  sv.emplace_back(std::move(s));
  for(auto &elem: sv)
  {
    elem+=c;
  }
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
  return sv;
}

void
change_by_ref(Noisy<StrVec> &sv,
              std::string s,
              char c)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  sv.emplace_back(std::move(s));
  for(auto &elem: sv)
  {
    elem+=c;
  }
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
}

std::tuple<Noisy<std::string>, // even strings
           Noisy<std::string>, // odd strings
           int>                // total length
many_results(const Noisy<StrVec> &sv)
{
  std::cout << "~~~~ enter " << __func__ << "() ~~~~\n";
  Noisy<std::string> even, odd;
  int length=0, count=0;
  for(const auto &elem: sv)
  {
    (count++%2 ? odd : even)+=elem;
    length+=int(size(elem));
  }
  std::cout << "~~~~ leave " << __func__ << "() ~~~~\n";
#if 0
  return {even, odd, length}; // copies involved!
#else
  return {std::move(even),    // std::move() prevents from
          std::move(odd),     //   copying existing locals
          std::move(length)}; //     to tuple-members
#endif
}

//---- silent functions ----

StrVec
change_by_val(StrVec sv,
              std::string s,
              char c)
{
  sv.emplace_back(std::move(s));
  for(auto &elem: sv)
  {
    elem+=c;
  }
  return sv;
}

void
change_by_ref(StrVec &sv,
              std::string s,
              char c)
{
  sv.emplace_back(std::move(s));
  for(auto &elem: sv)
  {
    elem+=c;
  }
}

std::tuple<std::string, // even strings
           std::string, // odd strings
           int>         // total length
many_results(const StrVec &sv)
{
  std::string even, odd;
  int length=0, count=0;
  for(const auto &elem: sv)
  {
    (count++%2 ? odd : even)+=elem;
    length+=int(size(elem));
  }
  return {std::move(even),    // std::move() prevents from
          std::move(odd),     //   copying existing locals
          std::move(length)}; //     to tuple-members
}

} // namespace s4prc

//----------------------------------------------------------------------------

Fichier prog.cpp✎

Contenu du fichier prog.cpp

//----------------------------------------------------------------------------

#include "str_vec.hpp"
#include <chrono>

double // seconds (1e-6 precision) since 1970/01/01 00:00:00 UTC
get_time()
{
  const auto now=std::chrono::system_clock::now().time_since_epoch();
  const auto us=std::chrono::duration_cast<std::chrono::microseconds>(now);
  return 1e-6*double(us.count());
}

void
test_noisy()
{
  std::cout << "\n~~~~ enter " << __func__ << "() ~~~~\n";
  s4prc::Noisy<s4prc::StrVec> big=s4prc::make_StrVec(10'000);
  std::cout << ">>> big=" << big << '\n';
  big=s4prc::change_by_val(big, std::to_string(size(big))+'!', 'A');
  std::cout << ">>> big=" << big << '\n';
  big=s4prc::change_by_val(std::move(big), std::to_string(size(big))+'!', 'B');
  std::cout << ">>> big=" << big << '\n';
  s4prc::change_by_ref(big, std::to_string(size(big))+'!', 'C');
  std::cout << ">>> big=" << big << '\n';
  const auto [even_str, odd_str, total_length]=s4prc::many_results(big);
  std::cout << ">>> even_str=" << even_str << '\n';
  std::cout << ">>> odd_str=" << odd_str << '\n';
  std::cout << ">>> total_length=" << total_length << '\n';
}

void
test_silent()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  using s4prc::operator<<; // compact display of StrVec and std::string
  auto big=s4prc::make_StrVec(10'000);
  std::cout << ">>> big=" << big << '\n';
  big=s4prc::change_by_val(big, std::to_string(size(big))+'!', 'A');
  std::cout << ">>> big=" << big << '\n';
  big=s4prc::change_by_val(std::move(big), std::to_string(size(big))+'!', 'B');
  std::cout << ">>> big=" << big << '\n';
  s4prc::change_by_ref(big, std::to_string(size(big))+'!', 'C');
  std::cout << ">>> big=" << big << '\n';
  const auto [even_str, odd_str, total_length]=s4prc::many_results(big);
  std::cout << ">>> even_str=" << even_str << '\n';
  std::cout << ">>> odd_str=" << odd_str << '\n';
  std::cout << ">>> total_length=" << total_length << '\n';
}

void
test_perf()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
#if !defined NDEBUG
  std::cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
               "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"
               "  Built for debug purpose at first "
               "(measurements will not be relevant).\n"
               "  For an actual experiment, rebuild with: "
               "   make rebuild opt=1\n"
               "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
               "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
#endif
  using s4prc::operator<<; // compact display of StrVec and std::string
  const int initial_count=10'000;
  const int iter_count=1'000;
  if(1)
  {
    auto big=s4prc::make_StrVec(initial_count);
    const double t0=get_time();
    for(int i=0; i<iter_count; ++i)
    {
      big=s4prc::change_by_val(big,
                               std::to_string(size(big))+'!', 'A');
    }
    const double dt=get_time()-t0;
    std::cout << "change_by_val() takes " << dt << " s\n";
    std::cout << ">>> big=" << big << '\n';
  }
  if(1)
  {
    auto big=s4prc::make_StrVec(initial_count);
    const double t0=get_time();
    for(int i=0; i<iter_count; ++i)
    {
      big=s4prc::change_by_val(std::move(big),
                               std::to_string(size(big))+'!', 'B');
    }
    const double dt=get_time()-t0;
    std::cout << "change_by_val(std::move()) takes " << dt << " s\n";
    std::cout << ">>> big=" << big << '\n';
  }
  if(1)
  {
    auto big=s4prc::make_StrVec(initial_count);
    const double t0=get_time();
    for(int i=0; i<iter_count; ++i)
    {
      s4prc::change_by_ref(big,
                           std::to_string(size(big))+'!', 'C');
    }
    const double dt=get_time()-t0;
    std::cout << "change_by_ref() takes " << dt << " s\n";
    std::cout << ">>> big=" << big << '\n';
  }
  if(1)
  {
    auto big=s4prc::make_StrVec(initial_count);
    std::string even_str;
    std::string odd_str;
    int total_length;
    const double t0=get_time();
    for(int i=0; i<iter_count; ++i)
    {
      std::tie(even_str, odd_str, total_length)=s4prc::many_results(big);
    }
    const double dt=get_time()-t0;
    std::cout << "many_results() takes " << dt << " s\n";
    std::cout << ">>> big=" << big << '\n';
    std::cout << ">>> even_str=" << even_str << '\n';
    std::cout << ">>> odd_str=" << odd_str << '\n';
    std::cout << ">>> total_length=" << total_length << '\n';
  }
}

int
main()
{
  test_noisy();
  test_silent();
  test_perf();
  return 0;
}

//----------------------------------------------------------------------------