// déclaration d'une fonction dum1 qui prend une référence vers une instance de UneClasse en paramètre.
void dum1(UneClasse & objet) ; 

// classe UneClasse qui possède une fonction membre dum2
class UneClasse
{
public :
void dum2() ;
};

// un vecteur de UneClasse
std::vector<UneClasse> v1; 

// un vecteur de pointeurs sur UneClasse
std::vector<UneCLasse*> v2;

for_each( v1.begin(), v1.end(), dum1 ) ; // ok

for_each( v1.begin(), v1.end(), &UneClasse::dum2 ); // ko

std::for_each(v1.begin(), v1.end(), mem_fun_ref( &UneClasse::dum2 ) ); //ok
std::for_each( v2.begin(), v2.end(), mem_fun( &UneClasse::dum2 ) ); //ok

bool IsValid(const UneClasse* object);

std::vector<UneClasse*>::iterator i = std::find_if( v2.begin(), v2.end(), std::not1( IsValid ) ); //ko

std::vector<UneClasse*>::iterator i = std::find_if( v2.begin(), v2.end(), std::not1( std::ptr_fun( IsValid ) ) ); //ok

// on commence par définir un foncteur qui va nous permettre de construire un conteneur rapidement
struct Identity
{
	Identity():count_(0){}
	int operator () () { return count_++; }
	int count_;
};

// on défini également un prédicat binaire qui compare 2 entiers
bool IsSup(int a, int b) {return a>b;}

// on déclare un vecteur d'entiers de 5 éléments
std::vector<int> v(5);

// ainsi qu'un itérateur qui va nous permettre de travailler sur notre vecteur
std::vector<int>::iterator it ;

// et enfin, on rempli notre vecteur grâce à l'algorithme generate() et notre foncteur
std::generate( v.begin(), v.end(), Identity() );
// nous avons maintenant  v = {0,1,2,3,4}

it = std::find_if( v.begin(), v.end(), IsSup(2) ); //ko

it = std::find_if( v.begin(), v.end(), std::bind2nd( std::ptr_fun( IsSup ) , 2 ) ); //ok
// le résultat de cette ligne est que it pointe sur 3 (la première valeur supérieure à 2)

Bool IsSup( std::vector<int>::iterator it ){ return (*it)>2; }

IntIt it = std::find_if( v.begin(), v.end(), std::bind1st( std::ptr_fun( IsSup ), 2 ) );
//résultat: it pointe sur 0, puisque c'est le premier élément du tableau qui soit inférieur à 2.

// une première fonction gen1() qui effectue une boucle for simple et utilise l'itérateur correspondant au conteneur
void gen1()
{
	MyIterator end = container.end();
	int i = -1;
	for (MyIterator it = container.begin(); it != end; ++it)
		*it = ++i;
}

// une deuxième fonction gen2() qui utilise un pointeur pour parcourir le conteneur
// attention, cette méthode ne fonctionne que si tous les éléments du conteneur utilisé sont assurés d'être contigüs 
// en mémoire.
void gen2()
{
	int i = -1;
	int * end = & container [c_size-1];
	for(int * it = & container [0]-1; it != end;)
		*++it = ++i;
}

// une troisième fonction gen3() qui utilise l'algorithme generate() et un foncteur MyGenerate
struct MyGenerate
{
	explicit MyGenerate() : count_(0) {}
	int operator () () { return ++count_; }

private:
	int count_;
};

void gen3()
{
	std::generate( container.begin(), container.end(), MyGenerate() );
}

std::vector<int> container;
const int c_size = 5000000;
typedef std::vector<int>::iterator MyIterator;

std::deque<int> container;
const int c_size = 500000;
typedef std::deque<int>::iterator MyIterator;

struct Synchro
{
	Synchro( const StringVector & artists )
		: artists_( artists )
	{
		std::vector<AlbumList>( artists_.size() ).swap( albums_ );
		StringPairs().swap( result_ );
		current_ = albums_.begin();
	}

	void operator () (const std::string & str)
	{
		AlbumManager::FindAllAlbumsOf( str, *current_ );
		std::sort( (*current_).begin(), (*current_).end() );
		std::for_each( albums_.begin(), current_, Synchro::Compare );
		current_++;
	}	

	static void GetResult(StringPairs & result){ result = result_; }

private:
	std::vector<AlbumList> albums_;
	const StringVector & artists_;
	static std::vector<AlbumList>::iterator current_;
	static StringPairs result_;

	static void Compare(const AlbumList & list)
	{
		if ( current_->size() == list.size()
				&& std::equal(	current_->begin(), 
						current_->end(), 
						list.begin(), 
						std::mem_fun_ref( &Album::ReleasedSameYear ) ) )
			{
				result_.push_back( StringPair( (*current_)[0].GetArtist().GetName(), list[0].GetArtist().GetName() ) );
			}
	}
};

class SynchroCompare
{
public:
	SynchroCompare(Synchro* synchro) : synchro_(synchro){}

	void operator () (const std::string & str)
	{
		synchro_->operator()(str);
	}
}

private:
	Synchro* synchro_;
};

class Album
{
public:
	// constructeurs, accesseurs et autres
private:
	Artist		artist_; // un objet de type Artist qui définit notamment le nom de l'artiste
	std::string		title_; // titre le l'album
	unsigned short	year_; //année de sortie de l'album
	unsigned short	nbTracks_; //nombre de pistes sur l'album
};

std::vector<int> v = {1,2,3,4};

std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);

// surcharge de l'opérateur d'indirection
std::ostream & operator <<(std::ostream & stream, const Album & album)
{
	stream << album.title_ << ", " << album.artist_.GetName() << ", " << album.year_;
	stream << ", nb tracks: " << album.nbTracks_ << std::endl;
	return stream;
}

// affiche un album sur la sortie standard en utilisant l'opérateur d'indirection défini au dessus
void PrintAlbum(const Album & album)
{
	std::cout << album;
}

// affiche une liste d'albums sur la sortie standard
void PrintAlbumList(std::vector<Album> albums)
{
	std::for_each( albums.begin(), albums.end(), PrintAlbum );
}

std::string artistName = "un artiste" ;

// tmpStrVect_ est un vecteur de string qui contient des noms d'artistes
// le code suivant rajoute un nouvel artiste dans tmpStrVect_ si cet artiste n'est pas déjà présent dans ce vecteur
if ( std::find(tmpStrVect_.begin(), tmpStrVect_.end(), artistName ) == tmpStrVect_.end() )
{
	tmpStrVect_.push_back( artistName );
}

// HaveSameTitle est un prédicat qui retourne true si le titre passé en paramètre est le même que celui de l'album
bool Album::HaveSameTitle(std::string title) const { return title_ == title; }

// cette fonction retrouve un album en fonction de son titre
bool FindByTitle(const std::string & title, Album & album)
{
	AlbumList::iterator searched = 
		std::find_if( main_list_.begin(), 
				main_list_.end(), 
				std::bind2nd ( std::mem_fun_ref<bool, Album, std::string>(&Album::HaveSameTitle), title) );

	if ( searched == main_list_.end() )
		return false;
	
	album = *searched;
	return true;
}

std::vector<int> v1 = {2, 6, 7, 8, 4, 6, 7, 8, 3} ; // ne compile pas (cf. chapitre 2.0)
std::vector<int> v2 = {6, 7, 8}; // ne compile pas (cf. chapitre 2.0)
std::vector<int>::iterator result = std::find_end( v1.begin(), v1.end(), v2.begin(), v2.end() ); 
//retourne un iterateur pointant sur le 6eme élément de v1

// Cette fonction créé un vecteur avec les albums qui sont communs à deux vecteurs d'albums
bool AlbumManager::GetCommonAlbums(std::vector<Album> & albums)
{
	// on commence par vider le vecteur résultat
	std::vector<Album>().swap( albums );

	// on déclare plusieurs itérateurs dont nous avons besoin dans la boucle
	std::vector<Album>::iterator begin = main_list_.begin();
	std::vector<Album>::iterator end = main_list_.end();
	std::vector<Album>::iterator it;
	
// A chaque itération, nous recherchons le premier album commun aux 2 listes, puis, si on a trouvé un,
	// on repositionne begin afin de recommencer la boucle en ignorant la partie de main_list_ qui
	// a déjà été traitée.
	do
	{
		it = std::find_first_of( begin, main_list_.end(), second_list_.begin(), second_list_.end() );
		if ( it != end )
		{
			albums.push_back( *it );
			begin = it + 1;
		}
	}
	while ( it != end ); // si it == end, ça signifie que l'on a rien trouvé, on peut donc arêter

	return ( albums.size() == 0 ) ? false : true;
}

// recherche des doublons dans un vecteur.
// on boucle sur le vecteur fusionné, et à chaque fois 
// qu'on tombe sur un doublon, on le rajoute au vecteur resultat
std::vector<Album>::iterator found = mergedList.begin();
do
{
	found = std::adjacent_find( found, mergedList.end() );
	if ( found != mergedList.end() )
	{
		result.push_back( *found );
		found++;
	}
} while ( found != mergedList.end() );

Std ::vector <int> v = {2,3,4,2,4,2} ; // ne compile pas (cf. chapitre 2.0)
int count = std::count(v.begin(), v.end(), 2) ; //retourne 3

bool Album::HaveSameArtist(std::string artist)	const { return artist_.GetName() == artist; }

std::string artistName = "un artiste";
int nbAlbums = (int) std::count_if( main_list_.begin(), 
		cut, 
		std::bind2nd( std::mem_fun_ref<bool, Album, std::string>( &Album::HaveSameArtist ), artistName) );

std::vector<int> v1 = {3,4,5,8}; // ne compile pas (cf. chapitre 2.0)
std::vector<int> v2 = {3,4,6,8}; // ne compile pas (cf. chapitre 2.0)
// v1.size()</