modif du tp3 de Cpp

Algo/tp/Cpp/1_tp/src/test.cpp

@@ -52,14 +52,14 @@ void testValgrind(void){
     monstre[1] = new Monstre();
     monstre[2]->rugir("RAOOO pas content !!!");
     // monstre[10]->rugir("Mais ca va aller");
-    delete[] monstre;
+    // delete[] monstre;
 }
 
 int main(void){
     // test();
     // testChevalier();
     // testP4();
-    // testP5();
-    testValgrind();
+    testP5();
+    // testValgrind();
     return 0;
 }

Algo/tp/Cpp/3_tp/src/passager.cpp

@@ -1,5 +1,6 @@
 #include "passager.hpp"
 #include "wagon.hpp"
+
 #include <iostream>
 #include <string>
 
@@ -9,12 +10,11 @@ Passager::Passager(string nom, string prenom)
     :nom{nom}, prenom{prenom}, wagonActuel{nullptr}
 {}
 
-Wagon Passager::getWagonActuel() const {
-    return *wagonActuel;
+Wagon* Passager::getWagonActuel() const {
+  return wagonActuel;          ///// comme ça
 }
 
 ostream &operator<<(ostream &s, const Passager &p) {
     s << "Passager : " << p.nom << " " << p.prenom << endl; 
     return s;
-}
-
+}

Algo/tp/Cpp/3_tp/src/passager.hpp

@@ -2,6 +2,9 @@
 #define PASSAGER_HPP
 
 #include <string>
+#include <iostream>
+
+#include "train.hpp"   //// pour que l'on connaisse les méthode de train
 
 class Wagon;
 
@@ -17,7 +20,12 @@ public :
 
     Passager(std::string nom, std::string prenom);
 
-    Wagon getWagonActuel() const;
+    Wagon* getWagonActuel() const;
+
+    friend int Train::monterDansLeTrain(int numeroWagon, Passager& lePassager);         ///// ne pas oublier Train::
+    friend int Train::descendreDuTrain(Passager& lePassager);                           ///// idem
+    friend int Train::deplacerAuWagonSuivant(Passager& lePassager);                     ///// idem
+    friend int Train::deplacerAuWagonPrecedent(Passager& lePassager);                   ///// idem
 
     friend std::ostream &operator<<(std::ostream &s, const Passager &p);
     

Algo/tp/Cpp/3_tp/src/passagerOld.hpp.txt

@@ -1,29 +0,0 @@
-#ifndef PASSAGER_HPP
-#define PASSAGER_HPP
-
-#include <string>
-
-class Wagon;
-
-class Passager {
-private :
-    
-    std::string nom;
-    std::string prenom;
-
-    Wagon *wagonActuel;
-
-public :
-
-    Passager(std::string nom, std::string prenom);
-
-    Wagon getWagonActuel() const;
-
-    friend std::ostream &operator<<(std::ostream &s, const Passager &p);
-    
-    
-    ~Passager();
-};
-
-
-#endif // PASSAGER_HPP

Algo/tp/Cpp/3_tp/src/test.cpp.txt

@@ -22,19 +22,33 @@ void testWagon(void) {
     w1.ajouter(lePassager);
     w1.ajouter(lePassager2);
     w3.ajouter(lePassager3);
+    w1.enlever(lePassager2);
+    cout << lePassager3 << endl;
     cout << w1 << endl;
     cout << w2 << endl;
     cout << w3 << endl;
 }
 
 void testTrain(void) {
-    Train leTrain(1);
+    Train leTrain(3);
+    Passager lePassager("Maurice", "Mitchel");
+    Passager lePassager2("Pierre", "Roberts");
+    Passager lePassager3("Jean", "Dupont");
+    Passager lePassager4("Paul", "Dupond");
+    Passager lePassager5("Jacques", "Dupont");
+    leTrain.monterDansLeTrain(1,lePassager);
+    leTrain.monterDansLeTrain(1,lePassager2);
+    leTrain.monterDansLeTrain(3,lePassager3);
+    leTrain.deplacerAuWagonSuivant(lePassager);
+    leTrain.descendreDuTrain(lePassager2);
+    leTrain.deplacerAuWagonPrecedent(lePassager3);
+    leTrain.monterDansLeTrainAPartirDe(2,lePassager4);
     cout << leTrain << endl;
 }
 
 int main() {
     // testPassager();
-    testWagon();
-    //testTrain();
+    // testWagon();
+    testTrain();
     return 0;
 }

Algo/tp/Cpp/3_tp/src/testTP3.cpp

@@ -0,0 +1,354 @@
+#include "passager.hpp"
+#include "train.hpp"
+#include <cassert>
+#include <iostream>
+
+using namespace std;
+
+void testMonterDansTrain(void){
+  Passager p1("Dupont", "Pierre");
+  Train t(3);
+  int codeRetour;
+
+  //cout<< "-----------------------\n";
+  //cout << t << endl;
+  //cout << "----------------------\n";
+
+  cout << "vérif si impossible de monter dans un train qui roule :";
+  t.demarrer();
+  codeRetour=t.monterDansLeTrain(1,p1);
+  if(codeRetour == -1) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  cout << "vérif si impossible de monter si num de wagon non existant :"; 
+  t.arreter();
+  codeRetour=t.monterDansLeTrain(4,p1);
+  if(codeRetour == -2) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+
+  cout << "vérif si possible de monter dans wagon existant, non complet et train arrêté : ";
+  Passager* tab[20];
+  int tlog;
+  for(tlog=0; tlog<20; tlog++){
+    tab[tlog]=new Passager("Pierre", "Nom"+to_string(tlog+1));
+    codeRetour=t.monterDansLeTrain(1,*tab[tlog]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << tlog+1 << "eme passager( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+  if(codeRetour==0) cout << " OK\n";
+  else cout << "ERREUR (CodeRetour = " << codeRetour << ")\n";
+  
+  cout << "vérif si impossible de monter dans le wagon si déjà complet : ";
+  codeRetour=t.monterDansLeTrain(1,p1);
+  if (codeRetour == -3) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+
+  cout << "vérif si le passager sait qu'il est monté dans un wagon : ";
+  Wagon* w = tab[0]->getWagonActuel();
+  if(w==nullptr) cout << "ERREUR : il ne connait pas son wagon\n";
+  else cout << "OK\n"; // il sait être dans un wagon
+
+  
+  // libération des passagers
+  for(int i=0; i<tlog; i++){
+    delete tab[i];
+  }
+}
+
+
+void testDescendreDuTrain(void){
+  Passager p1("Dupont", "Pierre");
+  Passager p2("Durand", "Paul");
+  Train t(3);
+  int codeRetour;
+
+  //cout<< "--------Pierre monte dans le wagon 1 ---------------\n";
+  t.monterDansLeTrain(1,p1);
+  //cout << t << endl;
+  //cout << "----------------------\n";
+
+  
+  cout << "vérif si impossible de descendre du train qui roule :";
+  t.demarrer();
+  codeRetour=t.descendreDuTrain(p1);
+  if(codeRetour == -1) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  cout<< "--------Paul n'est pas dans le train (ne connait pas son wagon) ---------------\n";
+  cout << "vérif si impossible de descendre si le passager ne connaît pas son wagon (il n'est sûrement pas dans le train)  :"; 
+  t.arreter();
+  codeRetour=t.descendreDuTrain(p2);
+  if(codeRetour == -2) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+
+  cout << "vérif si possible de descendre du wagon existant et train arrêté : ";
+  codeRetour=t.descendreDuTrain(p1);
+  if(codeRetour==0) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+    
+  cout << "vérif si le passager a bien conscience de ne plus être dans le train : ";
+  if(p1.getWagonActuel()==nullptr) cout << "OK\n";
+  else{
+    cout << "ERREUR ( il croit être dans le wagon : ";
+    cout << p1.getWagonActuel() << ")\n";
+  }
+}
+
+void testDeplacerAuWagonSuivant(){
+  Passager p0("Dups", "Alice");
+  Passager p1("Dupont", "Pierre");
+  Passager p2("Durand", "Paul");
+  Passager p3("Dumont", "Marie");
+  Train t(3);
+  int codeRetour;
+
+  t.monterDansLeTrain(1,p1);
+  t.monterDansLeTrain(2,p2);
+  t.monterDansLeTrain(3,p3);
+
+  /*
+  cout<< "-----------------------\n";
+  cout << t << endl;
+  cout << "----------------------\n";
+  */
+  
+  codeRetour=t.deplacerAuWagonSuivant(p0);
+  cout << "vérif si impossible car le passager n'est pas dans le train : ";
+  if(codeRetour == -1) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  codeRetour=t.deplacerAuWagonSuivant(p3);
+  cout << "vérif si impossible car est déjà dans le dernier wagon :"; 
+  if(codeRetour == -2) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+
+  Passager* tab[19];
+  int tlog;
+  for(tlog=0; tlog<19; tlog++){
+    tab[tlog]=new Passager("Pierre", "Nom"+to_string(tlog+1));
+    codeRetour=t.monterDansLeTrain(3,*tab[tlog]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << tlog+1 << "eme passager n'a pas pu monter( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+
+  codeRetour=t.deplacerAuWagonSuivant(p2);
+  cout << "vérif si impossible car wagon déjà complet : ";
+  if (codeRetour == -3) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  codeRetour=t.deplacerAuWagonSuivant(p1);
+  cout << "vérif si possible  de passer au wagon suivant (pas de pb) : ";
+  if (codeRetour == 0) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  Wagon* w = p1.getWagonActuel();
+  cout << "vérif si le passager sait qu'il est dans un wagon : ";
+  if(w==nullptr) cout << "ERREUR : il ne connait pas son wagon\n";
+  else cout << "OK\n"; // il sait être dans un wagon
+
+  codeRetour=t.descendreDuTrain(p1);
+  cout << "vérif si le passager est dans le bon wagon => il peut en descendre : ";
+  if(codeRetour == 0) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+  
+  // libération des passagers qu'on a mis pour remplir le wagon 3
+  for(int i=0; i<tlog; i++){
+    delete tab[i];
+  }
+}
+
+
+void testDeplacerAuWagonPrecedent(){
+  Passager p0("Dups", "Alice");
+  Passager p1("Dupont", "Pierre");
+  Passager p2("Durand", "Paul");
+  Passager p3("Dumont", "Marie");
+  Train t(3);
+  int codeRetour;
+
+  t.monterDansLeTrain(1,p1);
+  t.monterDansLeTrain(2,p2);
+  t.monterDansLeTrain(3,p3);
+
+  /*
+  cout<< "-----------------------\n";
+  cout << t << endl;
+  cout << "----------------------\n";
+  */
+  codeRetour=t.deplacerAuWagonPrecedent(p0);
+  cout << "vérif si impossible car le passager n'est pas dans le train : ";
+  if(codeRetour == -1) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  codeRetour=t.deplacerAuWagonPrecedent(p1);
+  cout << "vérif si impossible car est déjà dans le premier wagon :"; 
+  if(codeRetour == -2) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+
+  Passager* tab[19];
+  int tlog;
+  for(tlog=0; tlog<19; tlog++){
+    tab[tlog]=new Passager("Pierre", "Nom"+to_string(tlog+1));
+    codeRetour=t.monterDansLeTrain(1,*tab[tlog]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << tlog+1 << "eme passager n'a pas pu monter( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+
+  codeRetour=t.deplacerAuWagonPrecedent(p2);
+  cout << "vérif si impossible car wagon déjà complet : ";
+  if (codeRetour == -3) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  codeRetour=t.deplacerAuWagonPrecedent(p3);
+  cout << "vérif si possible  de passer au wagon précédent (pas de pb) : ";
+  if (codeRetour == 0) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  Wagon* w = p3.getWagonActuel();
+  cout << "vérif si le passager sait qu'il est dans un wagon : ";
+  if(w==nullptr) cout << "ERREUR : il ne connait pas son wagon\n";
+  else cout << "OK\n"; // il sait être dans un wagon
+
+  codeRetour=t.descendreDuTrain(p3);
+  cout << "vérif si le passager est dans le bon wagon => il peut en descendre : ";
+  if(codeRetour == 0) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+  
+  // libération des passagers qu'on a mis pour remplir le wagon 1
+  for(int i=0; i<tlog; i++){
+    delete tab[i];
+  }
+}
+
+
+void testMonterDansLeTrainAPartirDe(){
+  Passager p0("Dups", "Alice");
+  Passager p1("Dupont", "Pierre");
+  Passager p2("Durand", "Paul");
+  Passager p3("Dumont", "Marie");
+  Train t(3);
+  int codeRetour;
+
+  codeRetour = t.monterDansLeTrainAPartirDe(4,p1);
+  cout << "vérif si impossible de monter à partir d'un numero de wagon non existant :";
+  if(codeRetour == -2) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+  
+  
+  t.demarrer();
+  codeRetour = t.monterDansLeTrainAPartirDe(1,p1);
+  cout << "vérif si impossible de monter dans le train qui roule :";
+  if(codeRetour == -1) cout << " OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  
+  // on remplit tous les wagons
+  t.arreter();
+  Passager* tab1[20];
+  int tlog1;
+  for(tlog1=0; tlog1<20; tlog1++){
+    tab1[tlog1]=new Passager("Pierre", "Nom"+to_string(tlog1+1));
+    codeRetour=t.monterDansLeTrain(1,*tab1[tlog1]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << tlog1+1 << "eme passager n'a pas pu monter( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+  Passager* tab2[20];
+  int tlog2;
+  for(tlog2=0; tlog2<20; tlog2++){
+    tab2[tlog2]=new Passager("Paul", "Nom"+to_string(tlog2+1));
+    codeRetour=t.monterDansLeTrain(2,*tab2[tlog2]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << tlog2+1 << "eme passager n'a pas pu monter( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+  Passager* tab3[20];
+  int tlog3;
+  for(tlog3=0; tlog3<20; tlog3++){
+    tab3[tlog3]=new Passager("Jacques", "Nom"+to_string(tlog3+1));
+    codeRetour=t.monterDansLeTrain(3,*tab3[tlog3]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << tlog3+1 << "eme passager n'a pas pu monter( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+  cout << "----------********train rempli*********-------------\n";
+  cout << t;
+  cout << "----------*****************-------------\n";
+  codeRetour = t.monterDansLeTrainAPartirDe(1,p1);
+  cout << "vérif si impossible car le train est complet : ";
+  if (codeRetour == -3) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+
+  cout << "---------- on vide le wagon 1-------------------\n";
+  for(int i=0; i<tlog1; i++){
+    codeRetour=t.descendreDuTrain(*tab1[i]);
+    if(codeRetour != 0){
+      cout << "ERREUR pour " << i+1 << "eme passager n'a pas pu descendre( CodeRetour = " << codeRetour << ")\n";
+      break;
+    }
+  }
+  cout << "----------*****************-------------\n";
+  cout << t;
+  cout << "----------*****************-------------\n";
+
+  codeRetour = t.monterDansLeTrainAPartirDe(2,p1);
+  if(codeRetour>0)
+    cout << " OK, il est monté dans le wagon " << codeRetour << "\n";
+  else
+    cout << "ERREUR (CodeRetour = " << codeRetour << ")\n";  
+  
+  cout << "vérif si le passager est dans le bon wagon => il peut en descendre : ";
+  codeRetour = t.descendreDuTrain(p1);
+  if(codeRetour == 0) cout << "OK\n";
+  else cout << "ERREUR ( CodeRetour = " << codeRetour << ")\n";
+
+  
+  // libération des passagers qu'on a mis pour remplir le wagon 1
+  for(int i=0; i<tlog1; i++){
+    delete tab1[i];
+  }
+  for(int i=0; i<tlog2; i++){
+    delete tab2[i];
+  }
+  for(int i=0; i<tlog3; i++){
+    delete tab3[i];
+  }
+}
+
+
+
+
+int main(){
+  cout<< "---------- TEST MONTER DANS LE TRAIN ------------\n";
+  // testMonterDansTrain();
+
+  cout << "---------- TEST DESCENDRE DU TRAIN ------------\n";
+  //testDescendreDuTrain();
+
+  cout << "---------- TEST DEPLACER AU WAGON SUIVANT ------------\n";
+  //testDeplacerAuWagonSuivant();
+
+  cout << "---------- TEST DEPLACER AU WAGON PRECEDENT ------------\n";
+  //testDeplacerAuWagonPrecedent();
+
+  cout<< "---------- TEST MONTER DANS LE TRAIN A PARTIR DE ------------\n";
+  testMonterDansLeTrainAPartirDe();
+  
+  return 0;
+}
+

Algo/tp/Cpp/3_tp/src/train.cpp

@@ -1,4 +1,7 @@
 #include "train.hpp"
+#include "wagon.hpp"  // nécessaire pour connaitre tout (seulement ce qui est public) ce qui compose un wagon
+#include "passager.hpp"
+
 #include <iostream>
 #include <string>
 #include <list>
@@ -6,9 +9,10 @@
 using namespace std;
 
 Train::Train(int nbWagons)
-	: lesWagons{} {
+  : roule{false}                ////////////// comme ça !!!
+{                
 	for (int i = 1; i <= nbWagons; ++i) {
-		lesWagons.push_back(new Wagon(i));
+	       lesWagons.push_back(Wagon{i});
 	}
 }
 
@@ -24,16 +28,188 @@ bool Train::isRoule() const {
 	return roule;
 }
 
+int Train::monterDansLeTrain(int numeroWagon, Passager& lePassager) {
+	if (roule) {
+		return -1;
+	}
+        if (numeroWagon < 1 || numeroWagon > (int)lesWagons.size()) {
+		return -2;
+	}
+
+	//////	if (lesWagons[numeroWagon - 1].ajouter(lePassager) == -1) {          //// non
+	Wagon& w = lesWagons.at(numeroWagon-1);
+ 	if (w.ajouter(lePassager) == 0) {       ///// c'est comme ça vu le code de ajouter dans wagon !!!
+		return -3;
+	}
+	lePassager.wagonActuel = & w;        //// sans oublier cette ligne !!!
+	
+	return 0;
+}
+
+int Train::descendreDuTrain(Passager &lePassager) {
+	if (roule) {
+		return -1;
+	}
+
+	///////////////////  NON pas comme ça, ne veut rien dire
+	/* 
+	if (lePassager.getWagonActuel().getNumero() < 1 || lePassager.getWagonActuel().getNumero() > lesWagons.size()) {
+		return -2;
+	}
+	*/
+	Wagon* w  = lePassager.getWagonActuel();           ////// comme ça
+	if(w==nullptr) return -2;
+	
+	if (w->enlever(lePassager) == 0) {
+		return -3;
+	}
+	lePassager.wagonActuel=nullptr;   /////// et on n'oublie pas cette ligne !!!!
+	return 0;
+}
+/*
+int Train::deplacerAuWagonSuivant(Passager &lePassager) {
+	if (lePassager.getWagonActuel().getNumero() < 1 || lePassager.getWagonActuel().getNumero() > lesWagons.size()) {
+		return -1;
+	}
+	if (lePassager.getWagonActuel().getNumero() == lesWagons.size()) {
+		return -2;
+	}
+	// if (lePassager.getWagonActuel().enlever(lePassager) == -1) { Pas besoins si on l'ajout après ???!!!
+	// 	return -4;
+	// }
+	if (lesWagons[lePassager.getWagonActuel().getNumero()].ajouter(lePassager) == -1) {
+		return -3;
+	}
+	return 0;
+}
+*/
+
+///// pour cette fonction on peut faire ainsi : 
+int Train::deplacerAuWagonSuivant(Passager &lePassager) {
+  Wagon* w = lePassager.getWagonActuel();        ///// comme ça on va éviter de faire plusieurs fois le même appel
+
+  if(w==nullptr){
+    return -1 ; //n'a pas de wagon => pas dans le train
+  }
+
+  unsigned int num = w->getNumero(); //! unsigned permet d'avoir que des nombres positifs !
+  if(num == lesWagons.size())     return -2;
+
+  // on tente de faire passer le passager au wagon suivant (num+1) qui est dans la case num
+  int fait = lesWagons[num].ajouter(lePassager);
+  if(fait == 0) return-3;         // il n'y avait plus de place
+
+  // il ne nous reste plus qu'à l'enlever du wagon num
+  lesWagons[num-1].enlever(lePassager); //! une fois ajouter dans le prochain wagon, ne pas oublier de l'enlever du wagon actuel !
+
+  // et on met à jour l'attribut wagonActuel du passager
+  lePassager.wagonActuel = & lesWagons[num]; 
+  return 0;
+  
+}
+
+
+
+/*
+int Train::deplacerAuWagonPrecedent(Passager &lePassager) {
+	if (lePassager.getWagonActuel().getNumero() < 1 || lePassager.getWagonActuel().getNumero() > lesWagons.size()) {
+		return -1;
+	}
+	if (lePassager.getWagonActuel().getNumero() == 1) {
+		return -2;
+	}
+	// if (lePassager.getWagonActuel().enlever(lePassager) == -1) { Pareil ici que l.66 ??!!
+	// 	return -4;
+	// }
+	if (lesWagons[lePassager.getWagonActuel().getNumero() - 2].ajouter(lePassager) == -1) {
+		return -3;
+	}
+	return 0;
+}
+*/
+
+int Train::deplacerAuWagonPrecedent(Passager &lePassager) {
+ Wagon* w = lePassager.getWagonActuel();
+  if(w==nullptr){
+    return -1 ; //n'a pas de wagon => pas dans le train
+  }
+  
+  unsigned num = w->getNumero();
+  if (num==1) return -2; //* le wagon 1 n'a pas de wagon précédent
+
+  // on tente de faire passer le passager au wagon précédent (num-1)
+  int fait = lesWagons[num-2].ajouter(lePassager);
+  if(fait == 0) return-3;
+
+  // il ne nous reste plus qu'à l'enlever du wagon num
+  lesWagons[num-1].enlever(lePassager);
+
+  // et on met à jour l'attribut wagonActuel du passager
+  lePassager.wagonActuel = & lesWagons[num-2];
+  return 0;
+
+}
+
+/*
+int Train::monterDansLeTrainAPartirDe(int numeroWagon, Passager &lePassager) {
+	int i;
+	if (numeroWagon < 1 || numeroWagon > lesWagons.size()) {
+		return -2;
+	}
+	if (roule) {
+		return -1;
+	}
+	for (i = numeroWagon - 1; i < lesWagons.size() && lesWagons[i].ajouter(lePassager) == 0; ++i) {
+		return -3;
+	}
+	return i--;
+}
+*/
+
+int Train::monterDansLeTrainAPartirDe(int numeroWagon, Passager& lePassager){
+  int codeErreur;
+  
+  codeErreur = monterDansLeTrain(numeroWagon,lePassager);
+  if(codeErreur==-1) return -1;
+  if(codeErreur==0) return numeroWagon; //! Pas oublier de rajouter ça ??!!
+
+  unsigned taille = lesWagons.size(); //! unsigned permet d'avoir que des nombres positifs !
+  										//? Que se passe-t-il si on a un nombre négatif ???
+										//? Pourquoi on le declare pas en int ???
+
+  if(numeroWagon <=0 || numeroWagon > (int)taille) return -2; //? Pk on met le int ici ???
+  
+  for(unsigned i = numeroWagon+1; i<=taille; i++){ //? Pourquoi on le declare pas en int ???
+    codeErreur = monterDansLeTrain(i,lePassager);
+    if(codeErreur==0) return i;
+    
+  }
+  for(unsigned i = numeroWagon-1; i>0; i--){  //* A revoir les utilisation des for ici ==> on monte d'abord en + puis en -
+    codeErreur = monterDansLeTrain(i,lePassager);
+    if(codeErreur==0) return i;
+  }
+  return -3; 
+}
+
+
+
 ostream &operator<<(ostream &s, const Train &t) {
 	s << "Train : " << t.lesWagons.size() << " wagon(s)." << endl;
 	s << "Liste des wagons :\n";
-	for (Wagon* w : t.lesWagons)
-	{	
+
+	/*        NON pas comme ça
+	for (Wagon* w : t.lesWagons){	
 		s << "\t" << "Wagon n°" << w->numero << " : " << w->lesPassagers.size() << " passager(s)." << endl;
 		s << "\t" << "Reste " << w->capacite - w->lesPassagers.size() << " places(s)." << endl;
 		s << "\t" << "Liste des passagers :\n";
 		for (Passager* p : w->lesPassagers)
 			s << "\t\t" << *p << endl;
-	}	
+	}
+	*/
+	
+	// comme ça : 
+	for (const Wagon & w : t.lesWagons){
+	  cout << w << endl;             //// on utilise l'operator<< des wagons !!!!
+	}
 	return s;                                                     
-}
+}

Algo/tp/Cpp/3_tp/src/train.hpp

@@ -2,15 +2,19 @@
 #define TRAIN_HPP
 
 #include <string>
+#include <vector>
 
 #include "wagon.hpp"
 
+class Passager;   //// nécessaire pour pouvoir en prendre par ref en param des méthodes
+
 class Train {
 private :
     
     bool roule;
 
-    std::list<Wagon*> lesWagons;
+  //     std::list<Wagon*> lesWagons;
+  std::vector<Wagon> lesWagons;          //// on avait dit en tp que ce serait un vector de wagon
 
 public :
         
@@ -27,11 +31,11 @@ public :
 
         int monterDansLeTrainAPartirDe(int numeroWagon, Passager& lePassager);
 
-        
+        friend std::ostream &operator<<(std::ostream &s, const Train &t);       /// ne pas oublier cette ligne !!!
         ~Train() = default;
 };
 
 
 
 
-#endif // TRAIN_HPP
+#endif // TRAIN_HPP

Algo/tp/Cpp/3_tp/src/wagon.cpp

@@ -2,6 +2,7 @@
 #include "passager.hpp"
 #include <iostream>
 #include <string>
+#include <algorithm>          // pour que find soit connu
 
 using namespace std;
 
@@ -9,20 +10,24 @@ Wagon::Wagon(int numero)
     :numero{numero}, lesPassagers{}
 {}
 
+int Wagon::getNumero() const {
+    return numero;
+}
+
 int Wagon::ajouter(Passager& lePassager) {
     if(lesPassagers.size() >= capacite) {
-        return -1;
+        return 0;
     }
     lesPassagers.push_back(&lePassager);
-    return 0;
+    return 1;
 }
 
-// int Wagon::enlever(const Passager& lePassager) {
-//     list<Passager*>::iterator it = find(lesPassagers.begin(), lesPassagers.end(), &lePassager);
-//     if(it == lesPassagers.end()) return 0;
-//     lesPassagers.remove(it);
-//     return 1;
-// }
+int Wagon::enlever(const Passager& lePassager) {
+    list<Passager*>::iterator it = find(lesPassagers.begin(), lesPassagers.end(), &lePassager);
+    if(it == lesPassagers.end()) return 0;
+    lesPassagers.erase(it);
+    return 1;
+}
 
 ostream &operator<<(ostream &s, const Wagon &w) {
     s << "Wagon n° " << w.numero << " : " << w.lesPassagers.size() << " passager(s)." << endl;

Algo/tp/Cpp/3_tp/src/wagon.hpp

@@ -3,6 +3,7 @@
 
 #include <string>
 #include <list>
+#include <iostream>
 
 class Passager;
 
@@ -19,9 +20,11 @@ public :
     static const int capacite = 20;
 
     Wagon(int numero);
+
+    int getNumero() const;
     
     int ajouter(Passager& lePassager);
-    int enlever(Passager& lePassager);
+    int enlever(const Passager& lePassager);
 
     friend std::ostream &operator<<(std::ostream &s, const Wagon &w);
 
@@ -29,4 +32,4 @@ public :
 };
 
 
-#endif // WAGON_HPP
+#endif // WAGON_HPP

Algo/tp/Cpp/3_tp/src/wagonOld.cpp.txt

@@ -1,32 +0,0 @@
-#include "wagon.hpp"
-#include "passager.hpp"
-#include <iostream>
-#include <string>
-
-using namespace std;
-
-Wagon::Wagon(int numero)
-    :numero{numero}, lesPassagers{}
-{}
-
-int Wagon::ajouter(Passager& lePassager) {
-    if(lesPassagers.size() >= capacite) {
-        return -1;
-    }
-    lesPassagers.push_back(&lePassager);
-    return 0;
-}
-
-// int Wagon::enlever(const Passager& lePassager) {
-//     list<Passager*>::iterator it = find(lesPassagers.begin(), lesPassagers.end(), &lePassager);
-//     if(it == lesPassagers.end()) return 0;
-//     lesPassagers.remove(it);
-//     return 1;
-// }
-
-ostream &operator<<(ostream &s, const Wagon &w) {
-    s << "Wagon n° " << w.numero << " : " << w.lesPassagers.size() << " passager(s)." << endl;
-    s << "Reste " << w.capacite - w.lesPassagers.size() << " places(s)." << endl;
-    s << "Liste des passagers :\n" << w.lesPassagers << endl;
-    return s;
-}

Algo/tp/Cpp/tp4/src/Wagon.h

@@ -6,7 +6,6 @@
 class Wagon {
 private:
 	constexpr static int capacite = 20;
-	int size;
 	int numero;
 	std::list<const Passager*> lesPassagers;
 public: