ENIB LANG-CPP Tr_02 - Entraînement sur le chapitre 02

{1} Mémoriser des informations

Réalisez un module int_set : il sera constitué d'un fichier d'en-tête (extension .hpp) et d'un fichier de code source (extension .cpp).
Ce module doit fournir, dans un espace de noms de votre choix, une structure nommée IntSet dont la vocation est de représenter un ensemble (potentiellement grand) d'entiers auquel on aura donné un nom.
Cette structure sera composée de deux membres :

name : une chaîne de caractères C++,
values : un tableau dynamique d'entiers.

Elle sera accompagnée d'une fonction make_IntSet() déclarée et définie dans les fichiers prévus à cet effet.
Le rôle de cette fonction est de fournir au contexte appelant une donnée de type IntSet dont les membres auront été initialisés en mémorisant les deux paramètres correspondants qui lui auront été transmis.

Le programme principal prog_tr02.cpp doit définir et invoquer une fonction test_IntSet() qui affiche son nom et déclare une variable de type IntSet qui sera initialisée grâce à votre fonction make_IntSet().
Les deux informations à transmettre lors de l'initialisation (le nom et les valeurs entières à mémoriser) ne serviront qu'à ce propos : elles n'ont plus besoin d'être utilisées dans la fonction test_IntSet() (puisqu'elles seront désormais mémorisées dans la variable que vous venez de déclarer).
Il est impératif de vous assurer du fait qu'aucune recopie de telles données potentiellement volumineuses (la chaîne, le tableau dynamique d'entiers, la donnée de type IntSet) n'ait lieu.

Le type utilitaire déjà utilisé dans nos expérimentations pourra faciliter cette démarche.

Utilisation du type s4prc::Noisy<T>

Vous aurez besoin du 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

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

.
Dans la définition de votre structure IntSet, vous pouvez par exemple utiliser cette directive de compilation conditionnelle :

#if 1
  s4prc::Noisy<std::vector<int>> values;
#else
  std::vector<int> values;
#endif

En alternant l'usage de #if 1 et #if 0 vous ferez en sorte que dans un cas le membre values de la structure utilise le type s4prc::Noisy<T> et dans l'autre non.

Lorsque cet outil est employé, vous devez constater qu'un message indique la création du membre values par déplacement de la donnée fournie, puis un autre reporte sa destruction.

Consignes :

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
Le fait de prendre des mesures, afin qu'il n'y ait pas de recopies superflues de données, fait partie intégrante de l'exercice.

Aide pour l'entraînement

{2} Consulter des informations

Le module int_set sera étendu avec une fonction to_string() déclarée et définie dans les fichiers prévus à cet effet.
Son rôle est de fournir au contexte appelant une chaîne de caractères décrivant lisiblement une donnée de type IntSet qui lui aura été transmise.
La chaîne obtenue aura par exemple ce format name={value₀, value₁, ...}.
Remarquez que cette fonction ne doit en aucun cas modifier la donnée qu'elle cherche à représenter.

Ce module accueillera une fonction contains() déclarée et définie dans les mêmes conditions que la précédente.
Son rôle est de fournir un résultat booléen qui indique si une donnée de type IntSet qui lui aura été transmise en premier paramètre contient la valeur entière fournie comme second paramètre.
Remarquez que cette fonction ne doit en aucun cas modifier la donnée qu'elle inspecte.

Complétez alors la fonction test_IntSet() en provoquant un affichage de la chaîne produite par la fonction to_string() que vous venez de réaliser.
Il faudra également vérifier le bon fonctionnement de votre fonction contains() en choisissant deux situations contradictoires (une valeur doit être contenue, l'autre non).
Il est impératif de vous assurer du fait qu'aucune recopie de données potentiellement volumineuses n'ait lieu✍.
Bien que le langage ne l'impose pas✍, efforcez-vous d'utiliser la facilité ADL partout où elle s'applique.

Consignes :

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
Le fait de prendre des mesures, afin qu'il n'y ait pas de recopies superflues de données, fait partie intégrante de l'exercice.
La facilité ADL devra être exploitée là où elle s'applique.

Aide pour l'entraînement

{3} Modifier des informations

Ajoutez au module int_set un opérateur += concernant le type IntSet, déclaré et défini dans les fichiers prévus à cet effet.
Lorsqu'il concerne les types de base de C/C++, les propriétés d'associativité de cet opérateur assurent le fait que la notation a+=b+=c; est équivalente à a+=(b+=c); qui est elle même équivalente à b+=c; a+=b;.
Lors de la réalisation d'un tel opérateur en C++, il est important de respecter la sémantique de cette associativité✍.
Cela signifie que :

l'opérande droit n'est accédé que pour être consulté,
l'opérande gauche est accédé dans le but d'être modifié,
le résultat ne fait que désigner l'opérande gauche, après qu'il ait été modifié, afin de permettre l'enchaînement des appels comme indiqué plus haut.

Nous considérerons que cet opérateur matérialise l'union des ensembles désignés.
Concernant le membre name, la nouvelle valeur pour l'opérande gauche (que nous modifions) sera une paire de parenthèses rassemblant les noms des deux opérandes joints par le texte littéral

<U>

pour symboliser l'union.
En ce qui concerne le membre values, il suffit d'ajouter à l'opérande gauche (que nous modifions) les éléments de l'opérande droit (que nous consultons) qu'il ne contient pas déjà✍.
Par exemple, si l'opérande gauche est initialement représenté par

v1={1, 2, 3}

et l'opérande droit par

v2={2, 4, 6}

, alors, après l'opération +=, l'opérande gauche sera représenté par

(v1<U>v2)={1, 2, 3, 4, 6}

.

Il est usuel, lorsqu'un opérateur += est réalisé, de fournir également un opérateur +.
La manière de procéder est très systématique, quel que soit le contexte :

les opérandes gauche et droit ne sont accédés que pour être consultés (aucun des deux ne sera modifié),
nous créons une nouvelle variable qui est une copie de l'opérande gauche,
nous appliquons à cette dernière l'opérateur += afin de la modifier selon l'opérande droit,
nous renvoyons cette variable comme résultat.

Il s'agit donc bien de créer une toute nouvelle donnée à partir de deux autres qui restent inchangées.
Complétez alors le module int_set à cette occasion selon la démarche habituelle.

Pour tester ces nouvelles fonctionnalités, vous devez compléter la fonction test_IntSet().
Vous déclarerez une deuxième variable de type IntSet initialisée par un appel à votre fonction make_IntSet() et une troisième variable de type IntSet initialisée par le résultat de l'opérateur + appliqué aux deux précédentes variables.
Vous afficherez les représentations que votre fonction to_string() donne de ces variables✍.
Il est impératif de vous assurer du fait qu'aucune recopie superflue de données potentiellement volumineuses n'ait lieu✍.
La seule recopie qui soit légitime est celle qu'il nous a fallu provoquer explicitement au sein de l'opérateur +.

Consignes :

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
Il est impératif de respecter les recommandations sur l'usage qui est attendu des opérateurs réalisés (opérandes modifiés ou non, résultat...).
Le fait de prendre des mesures, afin qu'il n'y ait pas de recopies superflues de données, fait partie intégrante de l'exercice.

Aide pour l'entraînement

{4} Renvoyer de multiples résultats

Le module int_set disposera enfin d'une fonction intersect() déclarée et définie dans les fichiers prévus à cet effet.
Son rôle est de fournir au contexte appelant à la fois l'intersection et la différence symétrique de deux données de type IntSet qui lui auront été transmises.
Remarquez que cette fonction ne doit en aucun cas modifier ses paramètres.

Deux variables de type IntSet seront déclarées à l'intérieur de cette fonction : une pour chacun des deux résultats à fournir.
Leur membre name sera composé d'une paire de parenthèses rassemblant les noms des deux paramètres joints par le texte littéral

<I>

ou

<D>

, selon le cas, pour symboliser l'intersection ou la différence symétrique.
Les membres values de ces deux variables, qui sont initialement vides, seront complétés de la façon suivante✍ :

pour chaque valeur du premier paramètre,
- si elle est contenue dans le second paramètre, il faut l'ajouter à l'intersection,
- sinon, il faut l'ajouter à la différence symétrique,
pour chaque valeur du second paramètre,
- si elle n'est pas contenue dans le premier paramètre, il faut l'ajouter à la différence symétrique.

Par exemple, si l'opérande gauche est initialement représenté par

v1={1, 2, 3}

et l'opérande droit par

v2={2, 4, 6}

, alors l'intersection sera représentée par

(v1<I>v2)={2}

et la différence symétrique par

(v1<D>v2)={1, 3, 4, 6}

.
Le résultat de la fonction intersect() doit fournir les deux ensembles ainsi constitués.

Pour tester cette nouvelle fonctionnalité, vous devez compléter la fonction test_IntSet() en désignant par deux variables distinctes les résultats de votre fonction intersect() appliquée à deux de vos variables précédentes.
Vous afficherez les représentations que votre fonction to_string() donne de ces deux variables✍.
Il est impératif de vous assurer du fait qu'aucune recopie de données potentiellement volumineuses n'ait lieu✍.
Bien que le langage ne l'impose pas✍, efforcez-vous d'utiliser la facilité ADL partout où elle s'applique.

Consignes :

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
Le fait de prendre des mesures, afin qu'il n'y ait pas de recopies superflues de données, fait partie intégrante de l'exercice.
La facilité ADL devra être exploitée là où elle s'applique.

Aide pour l'entraînement