namespace identificateur;

namespace identificateur
{
	// liste des entités regroupées dans l'espace de nommage
};

namespace azedzed
{
	class A
	{
		// définition de la classe A
	};
	const double PI=3.1415927;

	class B
	{
		// définition de la classe B
	};
}

EspNom1::ClasseA *obA;

EspNomExt::EspNomInt::ClasseB *obB;

namespace A
{
	class Erreur // ou tout autre nom courant
	{
	};
}

namespace B
{
	class Erreur // ou taut autre nom courant
	{
	};
}

class Erreur
{
};

int main(int,char**)
{
	Erreur e1; // Pas de probleme quoique ::Erreur e1 eut ete preferable
	A::Erreur e2; // Pas de probleme classe Erreur de l'espace A
	B::Erreur e3; // Pas de probleme classe Erreur de l'espace B

	using namespace A;

	Erreur e4; // Ambiguite entre ::Erreur et A::Erreur

	using namespace B;

	Erreur e5; // ambiguite entre ::Erreur, A::Erreur et B::Erreur

	return 0;
}						

using namespace A; // Ok, délivre la visibilité sur les éléments de A
using namespace B; // ??? est-ce A::B ou bien B?

#include <iostream>

namespace BASE
{						
	class ErreurBase
	{
		public:
		virtual void show(void)=0;
	};
}

namespace A
{
	class Erreur : public BASE::ErreurBase
	{
		public:
			virtual void show(void)
			{
				cout << " A :: Erreur " << endl;
			}
	};
}

class Erreur : public BASE::ErreurBase
{
	public:
		virtual void show(void)
		{
			cout << " :: Erreur " << endl;
		}
};

int main(int, char**)
{
	Erreur e1; // ::Erreur
	A::Erreur e2; // A::Erreur

	using A::Erreur;
	Erreur e3; // A::Erreur masque ::Erreur

	e1.show();
	e2.show();
	e3.show();
	
	return 0;
}

namespace nomAlias = nomEspaceOriginel ;

namespace local = EspaceExterne::EspaceInterne::EspacePlusInterne ;

#include <iostream>
namespace BASE
{
	class ErreurBase
	{
		public:
			virtual void show(void)=0;
	};
}

namespace NomTropLong
{
	class Erreur : public BASE::ErreurBase
	{
		public:
			virtual void show(void)
			{
				cout << "NomTropLong :: Erreur " << endl;
			}
	};
	
	namespace EncorePlusLong
	{
		class Erreur : public BASE::ErreurBase
		{
			public:
			virtual void show(void)
			{
				cout << "NomTropLong :: EncorePlusLong :: Erreur " << endl;
			}
		};
	}
}

class Erreur : public BASE::ErreurBase
{
	public:
		virtual void show(void)
		{
			cout << " :: Erreur " << endl;
		}
};

int main(int, char**)
{
	namespace A = NomTropLong;
	namespace B = A::EncorePlusLong;

	// Etant declares a l'interieur de main les noms d'alias
	// sont locaux et donc non exportes !
	
	Erreur 								e1; // ::Erreur
	NomTropLong::Erreur 				e2;
	NomTropLong::EncorePlusLong::Erreur e3;
	A::Erreur 							e4; // ni ambigue ni fastidieux !
	B::Erreur 							e5; // idem

	e1.show();
	e2.show();
	e3.show();
	e4.show();
	e5.show();
	
	return 0;
}

#ifndef __NameRO_H__
#define __NameRO_H__

// Fichier des déclarations
// Déclare un espace de nommage externe (RO)
// et deux espaces de nommage internes RO::GRAPHES et
// RO::PROGRAMMATION_DYNAMIQUE
// Ainsi que des classes

namespace RO
{
	namespace GRAPHES
	{
			class Graphe
			{
				// code omis
				public:
					void afficher(void);
		};
		
		class AlgorithmePCC
		{
			// code omis
			public:
				void resoudre(void);
		};
	}

	namespace PROGRAMMATION_DYNAMIQUE
	{
		class SacADos
		{
			// code omis
			public:
			void resoudre(void);
		};
	}
}
#endif

// Deuxieme fichier : implemente l'une des classes
// Notez que l'on est oblige de recreer l'imbrication des namespace

#include "NameRO.hxx"

namespace RO
{
	namespace GRAPHES
	{
		void Graphe::afficher(void)
		{
		}
	}
}

// Troisieme fichier : suite de l'implementation des classes
// du package RO::GRAPHES
// Notez que l'on est oblige de recreer l'imbrication des namespace

#include "NameRO.hxx"

namespace RO
{
	namespace GRAPHES
	{
		void AlgorithmePCC::resoudre(void)
		{
		}
	}
}

// Quatrieme fichier : implementation de la classe
// du package RO::PROGRAMMATION_DYNAMIQUE
// Notez que l'on est oblige de recreer l'imbrication des namespace

#include "NameRO.hxx"

namespace RO
{
	namespace PROGRAMMATION_DYNAMIQUE
	{
		void SacADos::resoudre(void)
		{
		}
	}
}

// Dernier fichier : main utilisant des alias de namespace

#include "NameRO.hxx"

int main(int, char **)
{
	namespace GR=RO::GRAPHES;
	namespace DY=RO::PROGRAMMATION_DYNAMIQUE;

	GR::Graphe g;				
	GR::AlgorithmePCC a;
	DY::SacADos s;
	
	g.afficher();
	a.resoudre();
	s.resoudre();
	
	return 0;
}				

string s1; 						// Chaîne vide s1
string s2("Clermont-Ferrand”) 	// Initialisation avec un char *
char tab[]="Auvergne”;
string s3(tab,4); 				// s3==”Auve”
string s4(s2); 					// constructeur par recopie
string s5(s2,8); 				// s5==”Ferrand”
string s6(s2,16); 				// s6==”Clermont-Ferrand”
string s7(s2,18); 				// s7==”Clermont-Ferrand”
string s8(4,'c'); 				// s8==”cccc”

class exception
{
	// code omis
	virtual const char * what () const throw ()
	{
		return << pointeur vers une chaîne quelconque >> ;
	}
};

#include <stdexcept>
#include <iostream>
#include <string>
#include <new>
#include <typeinfo>

class Rationnel
{				
	protected:
		int num;
		int den;
	public:
		explicit Rationnel (int n=0,int d=1) : num(n), den(d) {};
		void setNum(int n)
	{
		num=n;
	}
	void setDen(int d) throw (std::invalid_argument)
	{
		if (d == 0)
			throw std::invalid_argument("Rationnel : passage de denominateur
nul");
	den=d;
	}
	double asDouble () throw (std::range_error)
	{
		if (den == 0)
			throw std::range_error("Rationnel : division par 0");
		return static_cast<double>(num)/den;
	}
};

int main(int, char**)
{
	const unsigned long 	exagerementGrand=10000000;
	int 					nouveauDen;
	Rationnel 				r1;
	Rationnel 				*poolRationnel;

	try
	{
		Rationnel r2(2,0);
		cout << r2.asDouble();
	}
	catch (std::range_error &e)
	{
		cerr << "Exception range_error levee : " << e.what() << endl;
	}
	catch (std::exception &e)
	{
		cerr << "Exception stl levee : " << e.what() << endl;
	}
	catch (...)
	{
		cerr << "Exception inconnue levee : abandon du programme" << endl;
		exit(1);
	}

	do
	{
		cout << "Saisissez un nouveau denominateur" << endl << flush;
		cin >> nouveauDen;
		try
		{
			r1.setDen(nouveauDen);
		}
		catch (std::invalid_argument)
		{
			cerr << "Le denominateur ne doit pas etre nul, recommencez !" <<
endl;				
	continue;
	}
	break;
	} 	while (1);

	try
	{
		poolRationnel = new Rationnel[exagerementGrand];
	}
		catch (std::bad_alloc &e)
	{
		cerr << "Vous avez demande trop de memoire !" << endl;
		poolRationnel=0;
	}
	catch (...)
	{
		cerr << "Erreur inconnue !"<< endl;
		poolRationnel=0;
	}
	delete [] poolRationnel;

	return 0;
}

const type_info &typeid( expression )
const type_info &typeid( nom-type )

#include <iostream>
#include <typeinfo>

class A
{
	public:
		A() {}; // ce constructeur par défaut est nécessaire
				// sinon l'on obtient une erreur uninitialized constant
				// pour la variable aa dans main
};
class B {};
class C : public A {};
class D : public A {};
class E : public C {};

int main(int, char **)
{
	A 			a;
	const A 	aa;
	A 			*pa = new A;
	B 			b;
	C 			c;
	D 			d;
	E 			e;
	
	cout << "Affichage du nom d'une classe "
		 << typeid(A).name() << endl;
	cout << "Affichage du nom de la classe d'un objet "
		 << typeid(a).name() << endl;
	cout << "Affichage du nom de la classe d'un pointeur "
		 << typeid(pa).name() << endl;
	cout << "Affichage du nom de la classe d'une variable via pointeur "
		 << typeid(*pa).name() << endl;
		 
	cout << "Arithmetique sur les types " << endl;
	
	cout << "Variable et *pointeur de meme type "
		 << (typeid(a) == typeid(*pa)) << endl;
	cout << "Variable et const Variable de meme type "
		 << (typeid(a) == typeid(aa)) << endl;
		 
	cout << "Variables de types differents "
		 << (typeid(a) == typeid(b)) << endl;
	cout << "Essai de before " << endl;
	cout << "Variables de classes differentes "
		 << typeid(a).before(typeid(b)) << endl;
	cout << "Classe meme et classe Fille "
		 << typeid(a).before(typeid(c)) << endl;
	cout << "Classe grand meme et classe petite fille "
	 	 << typeid(a).before(typeid(e)) << endl;
	cout << "Classe tante et classe niece "
	     << typeid(d).before(typeid(e)) << endl;

	return 0;
}

// Fichier d'entete Entier.hxx
#ifndef __Entier__
#define __Entier__

class Entier
{
	private:
		static unsigned NbEntiers_;
		static unsigned NbRecopies_;
		
		int 		val_;
	public:
		explicit Entier(int valeur=0) : val_(valeur)
		{
			NbEntiers_++;
		}
		Entier (const Entier &a)
		{
			val_=a.val_;
			NbRecopies_++;
		}
		
		int val(void) const
		{
			return val_;
		}
		
		static int NbEntiers(void)
		{
			return NbEntiers_;
		}

	static int NbRecopies(void)
	{
		return NbRecopies_;
	}
};

class ostream;

ostream &operator<<(ostream &a,const Entier &b);
bool operator==(const Entier &a, const Entier &b);
bool operator<(const Entier &a, const Entier &b);

#endif

// fichier Entier.cpp

#include "Entier.hxx"
#include <iostream>

ostream &operator<<(ostream &a,const Entier &b)
{
	a << b.val();
	return a;
}

bool operator<(const Entier &a, const Entier &b)
{
	return a.val() < b.val();
}

bool operator==(const Entier &a, const Entier &b)
{
	return a.val() == b.val();
}

unsigned int Entier::NbEntiers_=0;
unsigned int Entier::NbRecopies_=0;

operator int (void)
{
return val_;
}

#include <vector>
#include <iostream>
#include "Entier.hxx”

// Permet d'afficher les caracs du vecteur
// et le nombre d'entiers
template <class T>
void affichage(const T &a)
{
	static int numeroLigne=1;
	cout << '(' << numeroLigne++ << ") Capacite " << a.capacity();
	cout << " Taille " << a.size();
	cout << " Nb entiers " << Entier::NbEntiers() << endl << flush;
}

int main(int, char**)
{
	typedef std::vector<Entier> VecInt;
	VecInt v1; 					// Creation d'un vecteur vide
	affichage(v1); 				// (1)
	v1.push_back(Entier(1)); 	// insertion d'un element
	affichage(v1); 				// (2)
	v1.reserve(100); 			// la capacite est portee a 100
	affichage(v1); 				// (3)
	v1.resize(200); 			// capacite et taille portees a 200
	affichage(v1); 				// (4)

	VecInt v2; // Nouveau vecteur vide

	for (int i=0;i<20;i++) // Remplissage avec redimensionnements
	{
		v2.push_back(Entier(i));
		affichage(v2); // (5 -> 24)
	}

	for (int i=0;i<20;i++) // Affichage par indexation (25)
		cout << v2[i] << " ";
	cout << endl;
	
	// Affichage avec parcours d'iterateur (26)
	VecInt::iterator courant=v2.begin();
	while (courant != v2.end())
	{
		cout << *courant << " ";
		++ courant; // Je me souviens du cours de C++ avance
		// utiliser si possible l'operateur prefixe !
	}
	cout << endl;

	// Affichage avec iterateur de flux (27)
	copy(v2.begin(),
		v2.end(),
		ostream_iterator<Entier>(cout," "));
	cout << endl;
	
	return 0;
}

#include <list>
#include <iostream>
#include <algo.h>

#include "Entier.hxx"
#include "Genera.hxx"

// Predicat fonction
bool estPair(const Entier &a)
{
	return ((a.val() % 2) == 0);
}
// Predicat foncteur
class EstImpair
{
	public:
	bool operator()(const Entier &a)
	{
		return ((a.val() % 2) != 0);
	}
};

int main(int, char**)
{
	typedef std::list<Entier> ListEnt;
	typedef ListEnt::iterator ListEntIt;

	ListEnt l1;
	ostream_iterator<Entier> sortie(cout, " ");	

	cout << "Generation aleatoire d'une liste de 10 entiers" << endl;
	l1.resize(10);
	generate(l1.begin(), l1.end(), GenAlea());

	cout << "Affichage de l'ordre initial" << endl;
	copy(l1.begin(),l1.end(),sortie);
	cout << endl;
	
	cout << "Apres tri" << endl;
	l1.sort();
	copy(l1.begin(),l1.end(),sortie);
	cout << endl;

	cout << "Apres renversement" << endl;

	l1.reverse();
	copy(l1.begin(),l1.end(),sortie);
	cout << endl;

	cout << "Generation lineaire des 10 premiers entiers" << endl;

	generate(l1.begin(), l1.end(), GenLin());
	copy(l1.begin(),l1.end(),sortie);
	cout << endl;

	cout << "Obtention de deux iterateurs sur le 3 et sur le 8" << endl;
	cout << "Construction d'une seconde liste puis splice " << endl;

	// notez ici que nous sommes obliges d'utiliser Entier(3) pour chercher le 3
	// cette conversion aurait ete implicite si le constructeur d'entier
	// n'avait pas ete marque explicit
	// je prefere toutefois controler ce que fait mon programme et faire l'effort
	// de l'appel de constructeur moi meme
	ListEntIt gauche=find(l1.begin(),l1.end(),Entier(3));
	ListEntIt droite=find(l1.begin(),l1.end(),Entier(8));

	ListEnt l2;
	l2.splice(l2.begin(),l1,gauche,++droite);

	cout << "Liste initiale : ";
	copy(l1.begin(),l1.end(),sortie);
	cout << endl;

	cout << "Seconde liste : ";
	copy(l2.begin(),l2.end(),sortie);
	cout << endl;

	cout << "Creation d'une liste des elements pairs par suppression des impairs";
	cout << endl;

	l1.resize(10);
	generate(l1.begin(),l1.end(),GenLin());
	l1.remove_if(EstImpair());

	copy(l1.begin(),l1.end(),sortie);
	cout << endl;
	cout << "Creation d'une liste des elements impairs par suppression des pairs";
	cout << endl;
	l2.resize(10);
	generate(l2.begin(),l2.end(),GenLin());
	l2.remove_if(estPair);
	copy(l2.begin(),l2.end(),sortie);
	cout << endl;

	cout << "Apres Merge" << endl;					
	l1.merge(l2);
	copy(l1.begin(),l1.end(),sortie);
	cout << endl;
	
	return 0;
}

#ifndef __Genera_hxx__
#define __Genera_hxx__

#include "Entier.hxx"
	
class GenAlea
{
	private:
		static const unsigned long m=259200UL;
		static const unsigned long a=5141UL;
		static const unsigned long c=73141UL;
	
		unsigned long x;
	
	public:
		explicit GenAlea(unsigned long t=0) : x(t) {};
		Entier operator()(void)
	{
		x=(x*a+c)%m;
		return Entier(x);
	}
};

class GenLin
{
	private:
		int prochain;

	public:
		explicit GenLin(int leProchain=0) : prochain(leProchain) {};
		Entier operator()(void)
	{
		return Entier(prochain++);
	}
};
#endif

l2.splice(l2.begin(),l1,gauche,droite);

l2.splice(l2.begin(),l1,gauche,++droite);

template <class T, class Container = deque<T> >
class queue
{ // etc

template <class T, class Container = deque<T> >
class stack
{ // etc

#include <deque>
#include <queue> // pour les files
#include <stack> // pour les piles
#include <iostream>
#include <algo.h>

#include "Entier.hxx"
#include "Genera.hxx"

int main(int, char**)
{
	const int TAILLE=10;
	Entier i;
	GenAlea g;

	stack<Entier,deque<Entier> > pile;
	queue<Entier,deque<Entier> > file;

	cout << "Ordre d'entree : ";
	for (int j=0;j<TAILLE;j++)
	{
		i=g();
		cout << i << " ";
		pile.push(i);
		file.push(i);
	}

	cout << endl;
	cout << "Ordre de sortie pour la pile : ";
	while (!pile.empty())
	{
		cout << pile.top() << " ";
		pile.pop();
	}					
	cout << endl;

	cout << "Ordre de sortie pour la file : ";
	while (!file.empty())
	{
		cout << file.front() << " ";
		file.pop();
	}

	cout << endl;

	return 0;
}

template <class T,
class Container = vector<T>,
class Compare = less<Container::value_type> >
class priority_queue
{ // etc

explicit priority_queue (const Compare& x = Compare());

template <class InputIterator>
priority_queue (InputIterator first,
InputIterator last,
const Compare& x = Compare());

#include <stdlib.h>
#include <iostream>
#include <queue>
#include <deque>

#include "Entier.hxx"
#include "Genera.hxx"

int main(int argc, char *argv[])
{
	  typedef std::priority_queue<Entier,
							deque<Entier>,
							less<Entier>
							> FilePrioInt;
	FilePrioInt 	fileAlea;
	GenAlea 		generateur(time(0));
	int 			nbAlea=((argc > 1) ? atoi(argv[1]) : 10);

	for (int compteurAlea=0;compteurAlea<nbAlea;compteurAlea++)
	{
		fileAlea.push(generateur());
	}

	while (!fileAlea.empty())
	{
		cout << fileAlea.top() << " ";
		fileAlea.pop();
	}

	cout << endl;
	return 0;
}

template <class T1, class T2>
struct pair
{
	T1 first;
	T2 second;
	pair (const T1& x, const T2& y);
};

template <class T1, class T2>
pair<T1,T2> make_pair (const T1 &a, const T2 &b)
{
	return pair<T1,T2>(a,b);
}

#include <utility>
#include <string>
#include <iostream>

int main(int, char**)
{
	int i=3;
	string s("Chaîne”);
	cout << make_pair(i,s).second << endl;
		// le retour de make_pair de type pair<int,string>
		// l'affichage concernera donc uniquement la chaine
	return 0;
}

itérateurSortie fonction(itérateur debutGauche, itérateur finGauche,
						 itérateur debutDroite, itérateur finDroite)
itérateurSortie fonction(itérateur debutGauche, itérateur finGauche,
						 itérateur debutDroite, itérateur finDroite,
prédicat comp)

#include <string>
#include <map>
#include <iostream>

typedef std::map<int, string, less<int> > MapIntString;
typedef MapIntString::iterator MapIntStringIt;
typedef MapIntString::value_type PairIntString;

ostream &operator<<(ostream &a, const PairIntString &b)
{
	a << "Clef : " << b.first << " Valeur : " << b.second;
	return a;
}

int main(int, char**)
{
	MapIntString map1;
	MapIntStringIt itCourant;

	map1[1]="premier";
	map1[2]="second";
	map1[3]="troisieme";

	cout << " Affichage avec acces indexe" << endl;
	for (int compteur=0;compteur<4;compteur++)
		cout << map1[compteur] << " zz ";

	cout << endl;

	cout << " Affichage avec une paire d'iterateurs " << endl;
	itCourant=map1.begin();
	while (itCourant != map1.end())
		cout << *(itCourant++) << " zz ";

	cout << endl;

	cout << " Affichage avec copy " << endl;
	
	std::copy(map1.begin(),
			 map1.end(),
			 ostream_iterator<PairIntString>(cout, " ZZ "));

	cout << "Tentative d'acces a un element non present : index 17" << endl;
	cout << map1[17] << endl;

	cout << "Affichage : remarquez la presence d'un element fictif sur la
clef 17 insere pas l'operateur []" << endl;

	std::copy(map1.begin(),
			map1.end(),
			ostream_iterator<PairIntString>(cout, " ZZ "));

	cout << endl;

	cout << "Recherche avec find des elements presents " << endl;
	
	cout << "Recherche de la clef 3 : pas de probleme ";
	MapIntString::iterator itRecherche=map1.find(3);

	if (itRecherche != map1.end())
	{
		cout << (*itRecherche).second << endl;
	}
	else
	{
		cout << "Pas trouve" << endl;
	}

	cout << "Recherche de la clef 13 non presente ";
	itRecherche=map1.find(13);

	if (itRecherche != map1.end())
	{
		cout << (*itRecherche).second << endl;
	}
	else
	{
		cout << "Pas trouve" << endl;
	}

	cout << "Autre technique : utilisez count" << endl;

	cout << "Nb de clefs 1 " << map1.count(1) << endl;
	cout << "Nb de clefs 13 " << map1.count(13) << endl;
	cout << "Plus interessant : Nb de clefs 17 " << map1.count(17) << endl;
	cout << "Constatation : le systeme a ajoute des valeurs nulles
(constructeur par defaut) aux emplacements vides" << endl;
	cout << "Moralite : toujours verifier par un appel a find ou count la
presence d'un element" << endl;

	cout << "Effacage de l'element fictif 17" << endl;

	map1.erase(17);
	
	cout << "Affichage pour verifier : " << endl;
	
	std::copy(map1.begin(),
			  map1.end(),
			  ostream_iterator<PairIntString>(cout, " zz "));

	cout << endl;
	cout << "Il a bien disparu !" << endl;

	cout << "Tentative d'insertion d'un element dont la clef est deja
presente " << endl;
	cout << "Tentative de remplacement de (2,second) par (2,zzDeux) " <<
endl;

	map1.insert(MapIntString::value_type(2,"zzDeux"));

	cout << "Affichage pour verifier" << endl;

	std::copy(map1.begin(),
			  map1.end(),
			  ostream_iterator<PairIntString>(cout, " ZZ "));

	cout << endl;

	
		cout << "Comme vous pouvez le voir, ca ne change rien du tout :( " <<
endl;
cout << "En revanche, il est possible d'ajouter ou de modifier une
valeur a l'aide de l'indexation" << endl;

	map1[2]="deuxieme";
	map1[5]="cinquieme";

	copy(map1.begin(), map1.end(),
		ostream_iterator<PairIntString>(cout, " ZZ "));
	
	cout << endl;

	return 0;
}

#include <string>
#include <map>
#include <iostream>

// multi map associant plusieurs chaines (les noms des communes)
// à un entier (le code postal)

typedef std::multimap<int, std::string, std::less<int> > MultiMapIntString;
typedef MultiMapIntString::iterator MultiMapIntStringIt;

typedef MultiMapIntString::value_type PairIntString;
typedef std::pair<MultiMapIntStringIt, MultiMapIntStringIt> PaireIterateurs;

// Opérateur d'affichage d'une paire (entier, chaîne)
ostream &operator<<(ostream &a, const PairIntString &b)
{
	a << "Clef : " << b.first << " Valeur : " << b.second;
return a;
}

// Opérateur d'affichage permettant de "dumper” l'intégralité des valeurs
// comprises entre deux itérateurs
ostream &operator<<(ostream &a, const PaireIterateurs &b)
{
	std::copy(b.first,
			  b.second,
			  ostream_iterator<PairIntString>(a," "));
	return a;
}

int main(int, char**)
{
	MultiMapIntString map1;
	MultiMapIntString::iterator itCourant;
	MultiMapIntString::iterator itFin;
	PaireIterateurs its;

	// Remplissage de la "base”
	map1.insert(MultiMapIntString::value_type(63000,"Clermont Ferrand"));
	map1.insert(MultiMapIntString::value_type(63100,"Montferrand"));
	map1.insert(MultiMapIntString::value_type(63100,"Les Vergnes"));
	map1.insert(MultiMapIntString::value_type(63100,"La Plaine"));
	map1.insert(MultiMapIntString::value_type(63400,"Chamalieres"));
	map1.insert(MultiMapIntString::value_type(63400,"Voie Romaine"));
	map1.insert(MultiMapIntString::value_type(63800,"Cournon d'Auvergne"));
	map1.insert(MultiMapIntString::value_type(63800,"Perignat sur Allier"));
	map1.insert(MultiMapIntString::value_type(63800,"Saint Georges sur Allier"));

	// Affichage de la multimap par une boucle sur les itérateurs
	itCourant=map1.begin();
	itFin=map1.end();

	while (itCourant != itFin)
	{
		cout << (*itCourant).second << " zz ";
		itCourant++;
	}
	
	cout << endl;
	
// Affichage de la multimap par une copie sur itérateur de flux en sortie

	std::copy (map1.begin(),
			map1.end(),
			ostream_iterator<PairIntString>(cout, " zz "));
	cout << endl;
					
	// Recherche du premier élément associé à clef 63800
	cout << "Resultat de find sur la clef 63800" << *(map1.find(63800)) << endl;

	// Recherche de tous les éléments associés à la clef 63800
	cout << "Resultat de equal_range sur la clef 63800 " ;

	cout << map1.equal_range(63800) << endl;

	// Recherche d'un élément avec equal_range
	its=map1.equal_range(3000);
	if (its == PaireIterateurs(map1.end(),map1.end()))
		{
			cout << "Pas Trouve" << endl;
		}

	its=map1.equal_range(63100);
		if (its == PaireIterateurs(map1.end(),map1.end()))
		{
			cout << "Pas Trouve" << endl;
		}
	else
		{
			cout << its << endl;
		}

	// Utilisation de lower et upper bound
	cout << "Tentative de lower/upper bound" << endl;
	its.first=map1.lower_bound(63100);
	its.second=map1.upper_bound(63400);
	cout << its << endl;

	// (lower_bound(i), upper_bound(i)) == equal_range(i)
	cout << "Simulation de equal_range avec lower/upper bound" << endl;

	cout << "Equal range " << map1.equal_range(63400) << endl;
	cout << "Lower/upper " << PaireIterateurs(map1.lower_bound(63400),
											  map1.upper_bound(63400)) << endl;
	return 0;
}

int tab[10];

int *p;
int i=0;
for (p=tab;i<10;i++,p++)
	cout << *p << " " << endl;

int tab[10];				
int *p;
int *borne=tab+10;
for (p=tab;p<borne;p++)
	cout << *p << " " << endl;

vector<int> tab(10);
for (vector<int>::iterator p=tab.begin();p<tab.end();p++)
cout << *p << " " << endl;
et le tour est joué !
Vous voyez c'est pas compliqué d'utiliser un itérateur !

ostream_iterator<TypeAEcrire>(flux_de_sortie,chaineDeSeparateur)

vector<int> v;
// code omis
copy (ostream_iterator<int>(cout,”\n”),v.begin(),v.end());

#include <iostream>
#include <fstream>
#include <deque>

int main(int, char**)
{
	ifstream f("toto");
	deque<int> t;

	istream_iterator<int,ptrdiff_t> entree(f), eof;

	while (entree != eof)
		{
			t.push_back(*entree);
			entree++
		}

	copy(t.begin(),t.end(),ostream_iterator<int>(cout," "));				
	cout << endl;
	f.close();
	return 0;
}

#include <iostream>
#include <fstream>
#include <deque>

int main(int, char**)
{
	ifstream f("toto");

	istream_iterator<int,ptrdiff_t> entree(f), eof;

	copy(entree,eof,ostream_iterator<int>(cout," "));
	cout << endl;
	f.close();
	return 0;
}

#On purge la liste des suffixes
.SUFFIXES:

#On ajoute simplement les extensions dont l'on a besoin
.SUFFIXES: .cpp .o

#Executable
EXEC=princi

#Liste des fichiers objet
OBJETS=Vehicule.o Depannage.o Princi.o RandomGenerator.o \
MarsagliaGenerator.o

#Liste des fichiers source
SOURCES=Vehicule.cpp Depannage.cpp Princi.cpp RandomGenerator.cpp \
MarsagliaGenerator.cpp

# avec GnuMake : SOURCES=${OBJETS:%.o=%.cpp}

#Compilateur et options de compilation
CCPP=g++
CCFLAGS=-g -Wall -ansi -pedantic

#Regle explicite de construction de l'executable
${EXEC}:${OBJETS} makefile
	${CCPP} -o ${EXEC} ${OBJETS}
			
#Regle implicite de construction des fichiers objet à partir
#des fichiers .cpp
.cpp.o:
	${CCPP} -c ${CCFLAGS} $< -o $@
	
# avec GnuMake
# %.o : %.cpp
# ${CCPP} -c ${CCFLAGS} $< -o $@

#gestion des dépendances
depend:
	sed -e "/^#DEPENDANCIES/,$$ d" makefile > dependances
	echo "#DEPENDANCIES" >> dependances
	${CCPP} -MM ${SOURCES} >> dependances
	cat dependances > makefile
	rm dependances
	
#DEPENDANCIES
Depannage.o: Depannage.cpp Depannage.hxx
MarsagliaGenerator.o: MarsagliaGenerator.cpp MarsagliaGenerator.hxx \
 RandomGenerator.hxx
Princi.o: Princi.cpp Voiture.hxx Vehicule.hxx Camion.hxx Parc.hxx \
 Adapter.hxx Helico.hxx MarsagliaGenerator.hxx RandomGenerator.hxx
 RandomGenerator.o: RandomGenerator.cpp RandomGenerator.hxx
Vehicule.o: Vehicule.cpp Vehicule.hxx Depannage.hxx \
 RandomGenerator.hxx