ajout tp3

Tp3/tp3.cpp

+#include <iostream>
+#include <string> // permet l'utilisation du type string.
+#include <vector> // permet d'utiliser des tableaux dynamiques.
+using namespace std;
+/*
+Auger-Dubois benoit et Atalla Fadia groupe 385K
+*/
+
+/* 
+Explication d'élément du code :
+1) Nous allons utilisé le type string plutôt que le tableau de caractères
+pour pouvoir utiliser la fonction getline, afin d'utiliser des espaces lors d'une saisie.
+2) On utilisera la fonction free() pour désallouer un pointeur.
+3) On utilisera les vector comme tableaux dynamique.
+ */
+
+// type t_etudiante représentant ces informations personnelles et son binome.
+struct t_etudiante {
+    int nu_etu; // numéro de l'étudiant.
+    string nom_prenom;
+    t_etudiante* binome; // pointeur vers l'étudiant binôme.
+    bool isBinome; // vrai quand l'étudiant possède un binome faux sinon, permet de gérer l'affectation des binomes efficacement.
+}
+
+// fonction qui demande a l'utilisateur d'entrer le nom de l'étudiante puis l'assigne a la structure.
+void changeEtuName (t_etudiante &etu){
+    cout << "Entrer le nom et le prénom de l'étudiante." << endl;
+    getline(cin,etu.nom_prenom); // utilisation de getline pour prendre en compte les espaces.
+}
+
+/* forme un binome de 2 étudiantes a l'aide de pointeurs, on part du principe qu'un étudianr peut avoir 1 seul binome
+et qu'il n'est pas en binôme avec lui même. */
+
+void formBinome (t_etudiante &etu1 , t_etudiante &etu2){
+    if (*etu1 != *etu2){ // verifie si les pointeurs ont des références mémoirs différentes.
+        if (etu1.isBinome == false){ // vérifie si etu1 n'a pas de binome
+            if (etu2.isBinome == false ){ // vérifie si etu2 n'a pas de binome
+                // aucun des étudiant n'avait de binome cas simple.
+                etu1.binome = *etu2;
+                etu2.binome = *etu1;
+            } else {
+                // etu2 avait un binome il faut désallouer le pointeur de son binome.
+                etu1.binome = *etu2;
+                etu2.binome->binome = free(); // permet d'éviter que 2 étudiant soit en binome avec etu2 en même temps.
+                etu2.binome = *etu1;
+            }
+        } else {
+            // etu1 avait un binome il faut désallouer le pointeur de son binome.
+            if (etu2.isBinome == false){
+                // etu 2 n'avait pas de binome.
+                etu2.binome = *etu1;
+                etu1.binome->binome = free(); // permet d'éviter que 2 étudiant soit en binome avec etu1 en même temps.
+                etu1.binome = *etu2;
+            } else {
+                // etu2 et etu1 avait un binome il faut désallouer le pointeur de son binome.
+                etu1.binome->binome = free();
+                etu2.binome->binome = free();
+                etu1.binome = *etu2;
+                etu2.binome = *etu1;
+            }
+        }
+
+    } else {
+        cout << "Ces étudiants sont identiques, on ne peut pas avoir un binome avec un seul étudiant ! " << endl;
+    }
+
+}
+
+
+void affBinome (t_etudiante etu){
+    if ( etu.isBinome == true){
+    cout << "Binôme : " << etu.nom_prenom << " est avec : " << 
+    etu.binome->nom_prenom << endl;
+    } else {
+        cout << " Sans binôme : " << etu.nom_prenom << endl;
+    }
+}
+
+// désalouer les pointeurs des étudiants du binome.
+void breakBinome (t_etudiante &etu){
+    if (etu.isBinome){
+        etu.binome->binome = free();
+        etu.binome = free();
+    }
+}
+
+/* compte le nombre d'occurence d'un entier dans un tableau dynamique d'entier
+utile pour ne pas afficher 2 fois le même binome dans le main. */ 
+int countInTab(int test, vector<int> tab){
+    int count = 0;
+    for (int i = 0 ; i <= tab.size() ; i++){
+        if ( tab[i] == test){
+            count ++;
+        }
+    }
+    return count;
+}
+
+// affiche les binomes sans doublons d'un groupe d'étudiants contenu dans un tableau dynamique
+void affTabEtu (t_etudiante etu){
+    vector<int> tabMemorize2; // tableau utile pour l'affichage des binomes sans doublons, mémorize les numéros étudiants deja affichés.
+        for (int y = 0; y < etu.size() ; y++){
+            tabMemorize2.push_back(etu[y].nu_etu); // la place dans le tableau est arbitraire, seuls les valeurs nu.etu m'intérèsse.
+            tabMemorize2.push_back(etu[y].binome->nu_etu);
+            // évite d'afficher 2 fois le même binome
+            if (countInTab(tabEtu[y].nu_etu, tabMemorize2) < 2 &&  countInTab(tabEtu[y].binome->nu_etu, tabMemorize2) < 2){
+            affBinome(tabEtu[y]);
+            }
+        }
+}
+
+// permet a l'utilisateur d'ajouter le numéro de l'étudiant, vérifie si le numéro est valide.
+void addNumEtu (t_etudiante &etu, vector <int> memo){
+    int temp;
+    cout << "entrer le numéro de l'étudiant : " << endl;
+    cin >> temp;
+    if (temp > 0 && countInTab(temp,memo) == 0){
+        etu.nu_etu = temp;
+    } else {
+        cout << "Ce numéro est invalide, un numéro valide est supérieur a 0 et unique " << endl;
+    }
+}
+
+int main(){
+    int const numberOfStudents;
+    cout << "Entrer le nombres d'étudiant du groupe" << endl;
+    cin >> numberOfStudents;
+    if (numberOfStudents > 0){
+    vector<t_etudiante> tabEtu (numberOfStudents); // création du tableau dynamique aussi appelée vector.
+    vector<int> tabMemorize; // mémorize les numéros étudiants deja affichés.
+        for (int i = 0; i < tabEtu.size() ; i++){ // remplis le tableaux d'étudiants d'information sur les étudiants.
+            addNumEtu(tabEtu[i],tabMemorize);
+            changeEtuName(tabEtu[i]);
+        }
+        if ( tab.Etu.size() > 1){ // verifie que l'on peux former au moins 1 binome.
+            int etuT1,etuT2 = 0;
+            while (etuT1 != -1 && etuT2 != -1)){
+                    cout << "entrer le numéro du premier étudiant du binome, ou -1 pour arrêter " << endl;
+                    cin >> etuT1;
+                    cout << "entrer le numéro du deuxième étudiant du binome, ou -1 pour arrêter " << endl;
+                    cin >> etuT2;
+                    // vérifie que les numéros éxiste dans le groupe d'étudiant
+                    if (countInTab(etuT1,tabMemorize) > 0 && countInTab(etuT2,tabMemorize) > 0){
+                    formBinome(etuT1,etuT2);
+                    } else {
+                        cout << "c'est numéro ne sont pas dans le groupe" << endl;
+                    }
+            }
+        } else {
+            cout << "il n'y a qu'un étudiant, on ne peux pas former de binome" << endl;
+          }
+        //affiche les binomes du groupe sans doublons.
+        affTabEtu(tabEtu);
+
+        // détruit tous les binome existant en désallouant les pointeurs.
+        for (int y = 0; y < tabEtu.size() ; y++){
+            if (tabEtu[y].isBinome == true){
+                tabEtu[y].binome->binome == free(); // désaloue le pointeur du binome.
+                tabEtu[y].binome = free(); // désaloue le pointeur de l'étudiant.
+            }
+        }
+
+        //affiche les binomes du groupe sans doublons.
+        affTabEtu(tabEtu);
+
+    } else { // si nombre d'étudiants <= 0.
+        cout << "Il doit avoir au moins 1 étudiants ! " << endl;
+      }
+    return 0;
+}
+