INITIALISATION D'OBJET VIA UN STREAM

/*
//======= SAMPLE DU FICHIER DE CONFIGURATION =============
* bla bla bla
* bla bla
chab01		0x0000		16777000
dball39		0		16776999
hour26		0x0015		16776992
erfe27		0x001a		16777000
//=============== Fin Du sample ============
//=============== debut du code =========== */

/*	***********************************************
				class BDU
				BDU.Cpp
*************************************************** */

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;
class Bdu{
	// Ces deux methodes sont déclarées en friend car elle accèdent directement
	//,notemment la deuxième, au membre privée de la classe, une autre solution
	// est possible mais je ne la connais pas.
	friend ostream& operator<<(ostream &,const Bdu &);
	friend istream& operator>>(istream &, Bdu &);
	
	public:
//		constructeur
		Bdu(){};			
		Bdu(int bouq,const string room_nb, unsigned add);
								
//		services
		int get_bouquet			();	
		unsigned get_addr		();
		string& get_room_nbr	();
		void set_bouquet	(int b);
		void set_addr		(unsigned a);
		void set_room_nbr	(string st);
		
//		Méthode statique		
		static int set_fileconf(string ouf);
		static string& get_fileconf();
		static void cree_fromFile(string&);	// Rempli le vector avec les Bdu
											// trouvé dans un fichier
// 		variable statique
		static vector<Bdu> myVect;			// Vector<Bdu> contenant tout les
	private:								// Bdu initialisés lors du prog
		string room_nbr;
		int bouquet;
		unsigned addr;
		static string conf_file;	

};
// Les Membres static doivent etre déclaré en dehor de la classe
// Un peu comme une varible globale ( c'est un peu leur rôle)
string Bdu::conf_file="TVconfig.txt"; // Nom du fichier de configuraiton en dur.
vector<Bdu> Bdu::myVect(0);

Bdu::Bdu(int bouq,const string room_nb, unsigned add){
			set_bouquet(bouq);			
			set_addr(add);
			set_room_nbr(room_nb);
			myVect.push_back(*this); //"pousse" le nouveau Bdu en fin de vector
		};
			

void Bdu::cree_fromFile(string &temp=Bdu::get_fileconf()){
	// La Méthode ouvre un flux sur un fichier passé en paramètre
	// Si il n'y en a pas on prend celui par défaut
	ifstream myStreamIn( temp.c_str() );	// ouverture du ifstream
					// c_str() car les string en c++ ne se termine pas par '\0'
	if (myStreamIn.fail()){					
	  cerr <<"Erreur Impossible d'ouvrir le fichier"<<Bdu::get_fileconf()<<endl;
	} else {
 		string line;
		 while( getline( myStreamIn, line/*,char delimiter='\n' est omis*/ ) ){
											// parcqu'implicite selon MSDN
			if (line[0] == '*' ) continue; 	// Si la ligne commence par *
											// on passse a la suivante
		Bdu bdu;
		istringstream iss(line);// Création d'un InputStream, d'apres une chaine
	
		iss >> bdu;				// Opération possible grace à la surcharge de 
								// >>, voir l'implémentation
		if (iss)				// <- une idée ?
			myVect.push_back(bdu); //On metle Bdu tout frais dans Le vector<Bdu>
		}						   // inhérent à la classe
	}
	
}

// GETTER		permet de lire les membres privés
int 	Bdu::get_bouquet()	{	return bouquet;	}	
unsigned 	Bdu::get_addr()	{	return addr;	}
string& Bdu::get_room_nbr()	{ 	return room_nbr;}
string& Bdu::get_fileconf()	{ 	return conf_file;}

// SETTER		permet de changer les membres privés
void Bdu::set_bouquet		(int b)	{ 	bouquet=b;}
void Bdu::set_addr		(unsigned a){	addr=a;	}
void Bdu::set_room_nbr	(string st)	{	room_nbr = st;}
int  Bdu::set_fileconf	(string ouf){ 	conf_file=ouf; 	return (1);}


// SURCHARGE D'OPERATEUR 
ostream & operator<<(ostream &flux,Bdu &bdu){
	// Une merveille de l'orienté objet :D
	// Cette méthode est appellé à chaque fois qu'une instance de Bdu
	//  se trouve à droite de l'opérateur <<, qui pointe vers un flux de sortie
	flux <<  bdu.get_room_nbr() << "\t\t " << hex << bdu.get_bouquet() \
									<< dec << "\t\t " << bdu.get_addr();
			// rajoute la valeur des membres aux flux
	
	return flux; // retourne le flux ainsi modifié pour qu'il poursuive.
}

istream & operator>>(istream &flux, Bdu &bdu){
	// De meme que pour l'operateur >>
	// Je l'ai déclaré en friend car elle modifie directement les membres
	// Je crois qu'il aurait était difficile de mettre les "setter" à la place
	flux >> bdu.room_nbr >> hex >> bdu.bouquet >> dec >> bdu.addr;
			// Au passage on convertit bouquet(Le deuxieme champ) en héxadécimal
			// sinon il y une erreur à cause du x. Dans ce cas le flux n'est 
			// plus valide d'ou le if (istream&) ligne 88 (AMHA)
	return flux; 
}



int main(){
	string erf = "chambre.txt"; // 
	Bdu::cree_fromFile(erf);
	for (int i(0);i<Bdu::myVect.size();i++){ cout << Bdu::myVect[i] << endl; }
				// Bdu::myVect[i] est interpréter comme une référence à un
				// Bdu, cela est due au template de la classe Vector 
				// voire ligne 44
	Bdu aCree;
	cin >> aCree;	// toujour grace a la méthode ligne 120, cin est un istream
	cout << aCree << endl; // de même on pourrais aisément enregistrer un Bdu
						   // dans un fichier
	cout << __FILE__ << endl;	// ch'tite macro prédéfinie renvoie le nom				
	return (0);					// du fichier compile.
}