ENIB LANG-CPP Ex_0103 - Utilisation de tableaux dynamiques

Connaissances requises pour cet exercice

Créer une donnée de type std::vector<T> en lui donnant un contenu initial ou non.
- Énumérer entre { et } les éléments initiaux.
Déterminer (avec size()) la taille d'un tel tableau dynamique.
Tester (avec empty()) s'il est vide.
Consulter (avec back()) son dernier élément.
Retirer (avec pop_back()) son dernier élément.
Lui ajouter (avec emplace_back()) un nouvel élément (à la fin).
Parcourir les éléments qu'il contient avec une boucle range-for.
- Distinguer le cas de la consultation (const auto &elem) de celui de la modification (auto &elem).

{1} Première variante

Il faut réaliser, dans le fichier prog_ex0103.cpp, cette fonction :

void
test_reverse()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  // ...
}

qui sera appelée depuis la fonction main().

Il s'agit de la compléter en respectant la démarche suivante :

Une variable v1, dont le type est un tableau dynamique de chaînes de caractères, doit être déclarée comme contenant initialement les chaînes "uno", "due", "tre", "quattro", "cinque", "sei", "sette", "otto".
Une seconde variable v2 de même type sera initialement vide.
Tant que v1 n'est pas vide :
1. Ajouter à la fin de v2 le dernier élément de v1.
2. Retirer le dernier élément de v1.
Afficher tous les éléments de v2 à l'aide d'une boucle range-for de consultation.

Indications :

Vous devriez constater un affichage semblable à v2: otto sette sei cinque quattro tre due uno.
Documentation de std::string.
Documentation de std::vector<T>.
Documentation de std::empty().

{2} Deuxième variante

Il faut réaliser, dans le fichier prog_ex0103.cpp, cette fonction :

void
test_balance()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  // ...
}

qui sera appelée depuis la fonction main().

Il s'agit de la compléter en respectant la démarche suivante :

Une variable v1, dont le type est un tableau dynamique de chaînes de caractères, doit être déclarée comme contenant initialement les chaînes "one", "two", "three", "four", "five", "six", "seven", "eight".
Une seconde variable v2 de même type sera initialement vide.
Tant que le nombre d'éléments de v1 est supérieur à celui de v2 :
1. Ajouter à la fin de v2 le dernier élément de v1.
2. Retirer le dernier élément de v1.
Afficher tous les éléments de v1 puis de v2 à l'aide de deux boucles range-for de consultation.

Indications :

Vous devriez constater un affichage semblable à v1: one two three four et v2: eight seven six five.
Documentation de std::string.
Documentation de std::vector<T>.
Documentation de std::size().

{3} Troisième variante

Il faut réaliser, dans le fichier prog_ex0103.cpp, cette fonction :

void
test_merge()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  // ...
}

qui sera appelée depuis la fonction main().

Il s'agit de la compléter en respectant la démarche suivante :

Une variable v1, dont le type est un tableau dynamique de chaînes de caractères, doit être déclarée comme contenant initialement les chaînes "five", "four", "three", "two", "one".
Une autre variable v2, dont le type est un tableau dynamique de chaînes de caractères, doit être déclarée comme contenant initialement les chaînes "cinque", "quattro", "tre", "due", "uno".
Une troisième variable v3 de même type sera initialement vide.
Tant que v1 n'est pas vide et que v2 n'est pas vide :
1. Ajouter à la fin de v3 la chaîne constituée ainsi : le dernier élément de v1, plus le caractères '/', plus le dernier élément de v2.
2. Retirer le dernier élément de v1.
3. Retirer le dernier élément de v2.
Afficher tous les éléments de v3 à l'aide d'une boucle range-for de consultation.

Indications :

Vous devriez constater un affichage semblable à v3: one/uno two/due three/tre four/quattro five/cinque.
Documentation de std::string.
Documentation de std::vector<T>.
Documentation de std::empty().

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
(#ifndef..., espaces de noms, fichiers d'en-tête, programmation modulaire...)
L'usage des opérations conventionnelles pour exploiter les tableaux dynamiques constitue l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent.

Lors d'une épreuve, au moment de livrer le travail, il sera impératif de s'assurer du fait que la fabrication du programme exécutable se produit sans le moindre message d'erreur ni d'avertissement✍
Que ce soit dans le cadre de cet enseignement ou dans un contexte professionnel, toute livraison de code qui ne respecte pas ce critère n'est tout simplement pas recevable.
.

Code source résultant

Si vous suivez scrupuleusement les énoncés et les consignes, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier prog_ex0103.cpp✎

Contenu du fichier prog_ex0103.cpp

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

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

void
test_reverse()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  std::vector<std::string> v1={"uno", "due", "tre", "quattro",
                               "cinque", "sei", "sette", "otto"};
  std::vector<std::string> v2;
  while(!empty(v1))
  {
    v2.emplace_back(v1.back());
    v1.pop_back();
  }
  std::cout << "v2:";
  for(const auto &elem: v2)
  {
    std::cout << ' ' << elem;
  }
  std::cout << '\n';
}

void
test_balance()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  std::vector<std::string> v1={"one", "two", "three", "four",
                               "five", "six", "seven", "eight"};
  std::vector<std::string> v2;
  while(size(v1)>size(v2))
  {
    v2.emplace_back(v1.back());
    v1.pop_back();
  }
  std::cout << "v1:";
  for(const auto &elem: v1)
  {
    std::cout << ' ' << elem;
  }
  std::cout << '\n';
  std::cout << "v2:";
  for(const auto &elem: v2)
  {
    std::cout << ' ' << elem;
  }
  std::cout << '\n';
}

void
test_merge()
{
  std::cout << "\n~~~~ " << __func__ << "() ~~~~\n";
  std::vector<std::string> v1={"five", "four", "three", "two", "one"};
  std::vector<std::string> v2={"cinque", "quattro", "tre", "due", "uno"};
  std::vector<std::string> v3;
  while(!empty(v1)&&!empty(v2))
  {
    v3.emplace_back(v1.back()+'/'+v2.back());
    v1.pop_back();
    v2.pop_back();
  }
  std::cout << "v3:";
  for(const auto &elem: v3)
  {
    std::cout << ' ' << elem;
  }
  std::cout << '\n';
}

int
main()
{
  test_reverse();
  test_balance();
  test_merge();
  return 0;
}

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