[Résolu] Redéfinition de l'operateur << pour ofstream

Redéfinition de l'operateur << pour ofstream [Résolu] - C++ - Programmation

Marsh Posté le 03-12-2005 à 20:07:52    

Bonjour, j'ai un problème avec la rédéfinition de l'opérateur << pour un ofstream, tout compile sans problème seulement à l'écriture il ne passe pas dans la redéfinition. Alors que les arguments sont ( me semblent ) corrects.

 

Voici le code :

 
Code :
  1. // Le main :
  3. #include <iostream>
  4. #include <fstream>
  5. #include <string>
  6. #include <vector>
  7. #include "Client.h"
  8. #include "ClientAbonne.h"
  9. #include "Oeuvre.h"
  10. #include "Representation.h"
  11. #include "Reservation.h"
  12. #include "ReservationGroupee.h"
  13. #include "Menu.h"
  15. using namespace std;
  17. int main ( void )
  18. {
  19. vector<Client *> listeCli;
  20. vector<Oeuvre> listeSpec;
  21. Client * cl  = new Client("scalzo","Loris","rue test","06400" );
  22. Oeuvre sp("les miserables","Victor Hugo" );
  23. Oeuvre sp2("l'avare","Moliere" );
  24. Representation rp("12/10/2005","16h00" );
  25. sp.ajouterRepresentation(&rp);
  26. listeSpec.push_back(sp);
  27. listeSpec.push_back(sp2);
  28. listeCli.push_back(cl);
  29. ... // pas besoin du code ici, il s'agit simplement de la gestion d'un menu.
  30. ofstream ecriture("clients_reservations.dat", ios::out );
  31. for ( int i = 0; i < listeCli.size(); i++ )
  32. {
  33.   ecriture << listeCli[i]  // ici il devrait passer dans la redéfinition.
  34. }
  35. return 0;
  36. }
  38. // le fichier Client.h
  40. #ifndef CLIENT_H
  41. #define CLIENT_H
  43. #include <iostream>
  44. #include <fstream>
  45. #include <string>
  46. #include <vector>
  47. #include "Reservation.h"
  49. using namespace std;
  51. class Client
  52. {
  53. private :
  54.   string nom, prenom, adresse, numtel;
  55.   vector <Reservation *> liste;
  56.  
  57. public :
  58.   Client();
  59.   Client ( string, string, string, string );
  60.   Client( const Client & );
  61.   ~Client();
  62.   void modifier();
  63.   virtual void affiche();
  64.   virtual void afficheReservation();
  65.   virtual void ajouterReservation(Reservation *);
  66.   virtual void modifierReservation( int, Reservation * );
  67.   virtual void listeReservation();
  68.   int getNombreReservations();
  69.   virtual void supprimerReservation(int );
  70.   virtual ostream & ecriture ( ofstream & );
  71.   const string getNom();
  72.   const string getPrenom();
  73.   const string getAdresse();
  74.   const string getNumtel();
  75.   void setNom(string);
  76.   void setPrenom(string);
  77.   void setAdresse(string);
  78.   void setNumtel(string);
  79. };
  81. #endif
  83. // la partie utile de Client.cpp :
  85. ostream & Client::ecriture(ofstream & o )
  86. {
  87. return o << nom << "\t" << prenom << "\t";
  88. }
  90. ostream & operator<< (ofstream &o,  Client * c )
  91. {
  92. cout << "passage redef";
  93. return o << c->ecriture( o ) ;
  94. }
 

Si vous pensez avoir besoin d'autres parties de codes n'hésitez pas à me demander.


Message édité par LePhasme le 29-12-2008 à 18:38:36
Reply

Marsh Posté le 03-12-2005 à 20:07:52   

Reply

Marsh Posté le 03-12-2005 à 22:36:11    

la signature doit être
 
ostream& operator<<(ostream&, const T & );

Reply

Marsh Posté le 03-12-2005 à 23:14:22    

En effet, j'ai du rêgler un problème de const suite aux modifs, je ne pensais pas que la forme de cette signature était obligatoire.
 
Merci beaucoup de ton aide.
 
Solution si jamais quelqu'un d'autre est interessé :
 

Code :
  1. // fichier.h  
  3. #ifndef CLIENT_H
  4. #define CLIENT_H
  6. #include <iostream>
  7. #include <fstream>
  8. #include <string>
  9. #include <vector>
  10. #include "Reservation.h"
  12. using namespace std;
  14. class Client
  15. {
  16. private :
  17.   string nom, prenom, adresse, numtel;
  18.   vector <Reservation *> liste;
  19.  
  20. public :
  21.   virtual void listeReservation();
  22.   int getNombreReservations();
  23.   virtual void supprimerReservation(int );
  24.   virtual  ostream & ecriture ( ostream & ) const; // déclarationde la fonction virtuelle
  26. };
  28. inline ostream & operator<< (ostream &o, const Client & c ) // definition de la surcharge
  29. {
  30. c.ecriture(o);
  31. return o ;
  32. }
  34. #endif
  36. // fichier .cpp
  38. ostream & Client::ecriture(ostream & o ) const // définition de la fonction virtuelle
  39. {
  40. return o << nom << "\t" << prenom << "\t" << adresse << "\t" << numtel << "\t" << endl;
  41. }
  43. // main identique a avant, je reposte juste la partie interessante.
  45. for ( int i = 0; i < listeCli.size(); i++ )
  46. {
  47.   ecriture << *listeCli[i];
  48. }
  49. return 0;
  50. }


Message édité par LePhasme le 04-12-2005 à 10:46:16
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed