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 :

// Le main :

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "Client.h"
#include "ClientAbonne.h"
#include "Oeuvre.h"
#include "Representation.h"
#include "Reservation.h"
#include "ReservationGroupee.h"
#include "Menu.h"

using namespace std;

int main ( void ) 
{
vector<Client *> listeCli;
vector<Oeuvre> listeSpec;
Client * cl  = new Client("scalzo","Loris","rue de test","06400");
Oeuvre sp("les miserables","Victor Hugo");
Oeuvre sp2("l'avare","Moliere");
Representation rp("12/10/2005","16h00");
sp.ajouterRepresentation(&rp);
listeSpec.push_back(sp);
listeSpec.push_back(sp2);
listeCli.push_back(cl);
... // pas besoin du code ici, il s'agit simplement de la gestion d'un menu.
ofstream ecriture("clients_reservations.dat", ios::out );
for ( int i = 0; i < listeCli.size(); i++ )
{
 ecriture << listeCli[i]  // ici il devrait passer dans  
	 // la redefinition
}
return 0;
} 

// le fichier Client.h

#ifndef CLIENT_H
#define CLIENT_H

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "Reservation.h"

using namespace std;

class Client
{
private :
 string nom, prenom, adresse, numtel;
 vector <Reservation *> liste;

public :
 Client();
 Client ( string, string, string, string );
 Client( const Client & );
 ~Client();
 void modifier();
 virtual void affiche();
 virtual void afficheReservation();
 virtual void ajouterReservation(Reservation *);
 virtual void modifierReservation( int, Reservation * );
 virtual void listeReservation();
 int getNombreReservations();
 virtual void supprimerReservation(int );
 virtual ostream & ecriture ( ofstream & );
 const string getNom();
 const string getPrenom();
 const string getAdresse();
 const string getNumtel();
 void setNom(string);
 void setPrenom(string);
 void setAdresse(string);
 void setNumtel(string);
}; 

#endif

// la partie utile de Client.cpp :

ostream & Client::ecriture(ofstream & o )
{
return o << nom << "\t" << prenom << "\t";
} 

ostream & operator<< (ofstream &o,  Client * c )
{
cout << "passage redef";
return o << c->ecriture( o );
}

Si vous avez besoin d'autres partie de code n'hésitez pas.

Edit : Correction du code qui venait d'une mauvaise version.

Edited December 29, 200817 yr by LePhasme

Et comme ça ?

// la partie utile de Client.cpp :
ostream &operator<<(ostream &o,  Client * c ) {
  return o << c->get_nom() << "\t" << c->get_prenom() << "\t";
}

J'avais lu j'sais plus où qu'il fallait pas surcharger les opérateurs des ofstream mais des ostream (classe parente).

J'ai pas bien compris ce que ça pouvait poser comme pb mais bon l'endroit où j'ai lu ça devait être crédible vu que je m'en souviens encore.

Oui mais le problème n'est pas la, c'est que la tout compile mais visiblement pour la signature de la fonction ne lui plait pas pourtant j'ai bien un ofstream/ostream à gauche et un pointeur sur un Client ( listeCli contient des pointeurs sur des Client ) mais il ne passe même pas dans la fonction.

Problème résolu, solution :

// fichier.h 

#ifndef CLIENT_H
#define CLIENT_H

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "Reservation.h"

using namespace std;

class Client
{
private :
 string nom, prenom, adresse, numtel;
 vector <Reservation *> liste;

public :
 virtual void listeReservation(); // avec un petit nettoyage pour que ce soit un peu plus clair
 int getNombreReservations();
 virtual void supprimerReservation(int );
 virtual  ostream & ecriture ( ostream & ) const;

}; 

inline ostream & operator<< (ostream &o, const Client & c )
{
c.ecriture(o);
return o ;
}

#endif

// fichier .cpp

ostream & Client::ecriture(ostream & o ) const
{
return o << nom << "\t" << prenom << "\t" << adresse << "\t" << numtel << "\t" << endl;
} 

// main identique a avant, je reposte juste la partie interessante.

for ( int i = 0; i < listeCli.size(); i++ )
{
 ecriture << *listeCli[i];
}
return 0;
}

Edited December 3, 200520 yr by LePhasme