change

Tp5/tp5.cpp

@@ -57,14 +57,122 @@ void affiche(t_cellule* pdeb){
     cout << endl;
 }
 
+/*----------------------------------------------
+rôle : procédure récursive qui désalloue toutes les cases mémoires qui ont été allouées dynamiquement */
+void desaloue(t_cellule* pdeb){
+    t_cellule* pcel;
+    t_cellule* next;
+    pcel = pdeb;
+    if (pcel != nullptr){
+        next = pcel->suivant;
+        delete pcel;
+        desaloue(next);
+    }
+}
+
+/*----------------------------------------------
+rôle : procédure qui crée un chaînage a partir d'une chaine de caractère*/
+t_cellule * creationChainage(string chaine){
+    t_cellule* pcel;
+    t_cellule* next;
+    for (int i = chaine.size()-1; i > -1; i--){
+        if (i == chaine.size() - 1){
+            pcel = new t_cellule;
+            pcel->info = chaine[i];
+            pcel->suivant = nullptr;
+            next = pcel;
+        } else {
+            pcel = new t_cellule;
+            pcel->info = chaine[i];
+            pcel->suivant = next;
+            next = pcel;
+        }
+    }
+    return pcel;
+}
+
+
 //-----------------------------------------------
 // programme principal
 //
 int main(){
+    /*
+    pour question 1 a 3 :
     t_cellule* pcel;
     pcel = enregistrement();
     affiche(pcel);
+    desaloue(pcel);
+    */
+    // pour question 4 :
+    t_cellule* pcel;
+    string ch;
+    cout << "entrer une chaine de caractère : " ;
+    getline(cin,ch);
+    pcel = creationChainage(ch);
+    affiche(pcel);
+    desaloue(pcel);
     return -1;
 }
 
-/* exercice 3 : */
\ No newline at end of file
+/* exercice 3 : 
+
+a) Réponse : 
+Il reste 6 cases mémoirs allouées dynamiquement , 
+ces cases mémoirs ont été allouées dynamiquement lors de l'éxution de la fonction enregistrement(), 
+la fonction main() et la fonction affiche() n'alloue pas de case mémoirs dynamiquement.
+
+démonstration :
+main() ----------------------------------------------------------------------------------------------------
+ligne   |   pcel       | remarque/affichage     
+debut        
+1           @1              pcel <- enregistrement()
+2                           "salut."
+fin
+conclusion : le main n'alloue pas de case en mémoirs dynamiquement.
+
+enregistrement() ------------------------------------------------------------------------------------------
+ligne | lettre | pcel | psuiv | tete | @1                   | @2                           | affichage/remarque 
+debut                      
+1                                                                                           une lettre ? (un point pour terminer):
+2       s
+3               @1
+4                               @1
+5                                                                                           s != '.' vrai
+6                                     info : s,suivant : ?
+7                       @2
+8                                     info : s,suivant : @2
+9                                                                                           une lettre ? (un point pour terminer):
+10      a
+11              @2
+12                                                                                          s != '.' vrai
+6                                                               info : a,suivant : ?
+7                       @3
+8                                                               info : a,suivant : @3
+9                                                                                           une lettre ? (un point pour terminer):
+10      l
+11              @3
+12                                                                                          l != '.' vrai
+
+conclusion : on s'arrête ici pour des raison de place, on se rend compte qu'il y a ( taille du mot(. non compris) + 1 ) allocation de mémoirs 
+lors de l'éxécution de la fonction enregistrement, en effet il y a une allocation au debut ligne 3,
+puis une allocation par tour de boucle while ligne 7, or il y a n=taille du mot tour de boucle while.
+Pour le mot "Salut." enregistrement va allouer 6 case mémoirs lors de son éxécution.
+
+On ne test pas la procédure affiche car elle n'a pas d'allocation dynamique et c'est ce qui nous intérèsse ici.
+
+b)
+
+//----------------------------------------------
+//rôle : procédure récursive qui désalloue toutes les cases mémoires qui ont été allouées dynamiquement 
+void desaloue(t_cellule* pdeb){
+    t_cellule* pcel;
+    t_cellule* next;
+    pcel = pdeb;
+    if (pcel != nullptr){
+        next = pcel->suivant;
+        delete pcel;
+        desaloue(next);
+    }
+}
+
+*/
\ No newline at end of file