// declaración de una función dum1 que toma una referencia hacia una instancia de UnaClase en parámetro.
void dum1(UnaClase & objet); 

// clase UnaClase que posee una función miembro dum2
class UnaClase
{
public :
void dum2();
};

// un vector de UnaClase
std::vector<UnaClase> v1; 

// un vector de punteros sobre UnaClase
std::vector<UnaClase*> v2;

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

for_each( v1.begin(), v1.end(), &UnaClase::dum2 ); // no vale

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

bool IsValid(const UnaClase* object);

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

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

// comenzamos por definir un functor que va permitir a nosotros construir un contenedor rápido
struct Identity
{
	Identity():count_(0){}
	int operator () () { return count_++; }
	int count_;
};

// también definimos un predicado binario que compara 2 enteros
bool IsSup(int a, int b) {return a>b;}

// declaramos un vector de enteros de 5 elementos
std::vector<int> v(5);

// así como un iterador que va permitir a nosotros trabajar en nuestro vector
std::vector<int>::iterator it ;

// y finalmente, rellenado nuestro vector gracias al algoritmo generate() y nuestro functor
std::generate( v.begin(), v.end(), Identity() );
// ahora tenemos:  v = {0,1,2,3,4}

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

it = std::find_if( v.begin(), v.end(), std::bind2nd( std::ptr_fun( IsSup ) , 2 ) ); //vale
// el resultado de esta línea es que it apunta sobre 3 (el primer valor superior a 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 ) );
//resultado: it apunta sobre 0, ya que es el primer elemento del array que sea inferior a 2.

// la primera función gen1() que efectúa un boucle for simple y utiliza el iterador correspondiente al contenedor
void gen1()
{
	MyIterator end = container.end();
	int i = -1;
	for (MyIterator it = container.begin(); it != end; ++it)
		*it = ++i;
}

// la segunda función gen2() que utiliza a un puntero para recorrer 
// el contenedor. Atención, este método funciona sólo si todos los elementos del 
// contenedor utilizado son asegurados de ser adyacentes en memoria.
void gen2()
{
	int i = -1;
	int * end = &container[c_size-1];
	for(int * it = &container[0]-1; it != end;)
		*++it = ++i;
}

// la tercera función gen3() que utiliza el algoritmo generate() y una functor 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:
	// constructores, "getter" y otros
private:
	Artist			artist_; // un objeto de tipo Artist 
	std::string		title_; // titulo del álbum
	unsigned short	year_; // fecha de salida del álbum
	unsigned short	nbTracks_; // número de pistas en el álbum
};

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);

// Sobrecarga del operador de indireccion
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;
}

// Fija un álbum en la salida estándar utilizando el operador de indireccion definido encima
void PrintAlbum(const Album & album)
{
	std::cout << album;
}

// Fija una lista de álbums en la salida estándar
void PrintAlbumList(std::vector<Album> albums)
{
	std::for_each( albums.begin(), albums.end(), PrintAlbum );
}

std::string artistName = "un artista" ;

// tmpStrVect_ es un vector de string que contiene nombres de artistas
// El código siguiente añade a un nuevo artista en tmpStrVect_ si este artista no está ya presente en este vector
if ( std::find(tmpStrVect_.begin(), tmpStrVect_.end(), artistName ) == tmpStrVect_.end() )
{
	tmpStrVect_.push_back( artistName );
}

// HaveSameTitle ss un predicado que devuelve true si el título pasado en parámetro es lo mismo que el álbum
bool Album::HaveSameTitle(std::string title) const { return title_ == title; }

// Esta función recobra un álbum con arreglo a su título
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} ; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {6, 7, 8}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator result = std::find_end( v1.begin(), v1.end(), v2.begin(), v2.end() ); 
//Devuelve un iterateur apuntando sobre el 6° elemento de v1

// Esta función construye un vector con los álbumes que son comunes de dos vectores de álbumes
bool AlbumManager::GetCommonAlbums(std::vector<Album> & albums)
{
	// empezamos por vaciar el vector el resultado
	std::vector<Album>().swap( albums );

	// declaramos varios iteradores que necesitamos en el bucle
	std::vector<Album>::iterator begin = main_list_.begin();
	std::vector<Album>::iterator end = main_list_.end();
	std::vector<Album>::iterator it;
	
	// A cada iteración, buscamos el primer álbum común de las 2 listas, luego, si se hemos encontrado uno,
	// resituamos begin con el fin de empezar de nuevo el bucle ignorando la parte de main_list_ que
	// ya ha sido tratada.
	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, esto significa que se encontró nada, entonces podemos parar

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

// búsqueda de doblones en un vector.
// efectuamos un bucle sobre el vector fusionado, y cada vez
// que que encontramos un doblón, lo añadimos al vector resultado (result)
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} ; // no compila (cf. capítulo 2.0)
int count = std::count(v.begin(), v.end(), 2) ; //devuelve 3

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

std::string artistName = "un artista";
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}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {3,4,6,8}; // no compila (cf. capítulo 2.0)
// v1.size() = v2.size()  -> vale

typedef std::vector<int>::iterator IntIt;
std::pair<IntIt, IntIt> result = std::mismatch( v1.begin(), v1.end(), v2.begin() );
//resultado: *(result.first) = 5, *(result.second) = 6

std::vector<int> v1 = {1,2,3}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {1,2,3}; // no compila (cf. capítulo 2.0)
std::vector<int> v3 = {1,2,4}; // no compila (cf. capítulo 2.0)
bool b = std::equal(v1.begin(), v1.end(), v2.begin() ); //résultado: b = true
b = std::equal(v1.begin(), v1.end(), v3.begin() ); //résultado: b = false

std::vector<int> v1 = {2, 3, 4, 6, 7, 8}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {6, 7, 8}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator result = std::search( v1.begin(), v1.end(), v2.begin(), v2.end() ); 
// devuelve un iterador que despunta sobre el 4° elemento de v1

std::vector<int> v = {2,3,4,4,4,2}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator result = std::search_n( v.begin(), v.end(), 3, 4); 
// devuelve un iterador que despunta sobre el 3° elemento de v

std::vector<int> v = {0,1,2,3,4}; // no compila (cf. capítulo 2.0)
std::copy( v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
// fija "0 1 2 3 4" en la salida estándar

std::vector<int> v2( v1.size());
std::copy_backward( v1.begin(), v1.end(), v2.end() );
// résultado: v2 = {0,1,2,3,4};

std::vector<int> v1 = {1,2,3,7}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {4,5,6}; // no compila (cf. capítulo 2.0)
std::swap( v1, v2 );
// resultado: v1 = {4,5,6}, v2 = {1,2,3,7}

std::vector<int> v1 = {1,2,3,7}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {4,5,6}; // no compila (cf. capítulo 2.0)
std::swap_ranges( v1.begin(), v1.begin() + v2.size(), v2.begin() );
// resultado: v1 = {4,5,6,7}, v2 = {1,2,3}

// "getter" que recupera el número de pista sobre un álbum
unsigned short GetNbTracks() const { return nbTracks_;}

// creamos un vector que va a contener sólo el número de pistas
std::vector<unsigned short> tracks( main_list_.size() );
std::transform( main_list_.begin(), main_list_.end(), tracks.begin(), std::mem_fun_ref( &Album::GetNbTracks ) );

std::vector<int> v = {1,4,3,4,1}; // no compila (cf. capítulo 2.0)
std::replace( v.begin(), v.end(), 4, 2);
// resultado: v = {1,2,3,2,1}

// IsOdd es un predicado que determina si un número es impar
	bool IsOdd(int number){	return number&1;}
	
	std::vector<int> v = {1,4,3,4,1}; // no compila (cf. capítulo 2.0)
	std::replace_if( v.begin(), v.end(), IsOdd, 0); // reemplaza todos los números impares de v1 por 0
	// resultado: v = {0,4,0,4,0}
	

std::vector<int> v1 = {1,4,3,4,1}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::replace_copy( v1.begin(), v1.end(), v2.begin(), 1, 0);
// resultado: v2 = {0,4,3,4,0}

// IsOdd es un predicado que determina si un número es impar
bool IsOdd(int number){	return number&1;}

std::vector<int> v1 = {1,4,3,4,1}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::replace_copy_if( v1.begin(), v1.end(), v2.begin(), IsOdd, 0); 
//copia v1 en v2 reemplazando todos los números impares de v1 por 0
//resultado : v2 = {0,4,0,4,0}

std::vector<int> v = {1,2,3,7}; // no compila (cf. capítulo 2.0)
std::fill( v.begin(), v1.end(), 5 );
//resultado: v = {5,5,5,5};

std::vector<int> v = {1,2,3,7}; // no compila (cf. capítulo 2.0)
std::fill( v.begin(), 2, 5 );
//resultado: v = {5,5,3,7};

int count = 0;
int MyGenerate(){ return count++; }

std::vector<int> v(5);
std::generate( v.begin(), v.end(), MyGenerate );
//resultado: v = {0,1,2,3,4}

int count = 0;
int MyGenerate(){ return count++; }

std::vector<int> v(5, 0); // aqui v = {0,0,0,0,0}
std::generate_n( v.begin(), 3, MyGenerate );
//resultado: v = {0,1,2,0,0}

std::vector<int> v1 = {1,2,3,4}; // no compila (cf. capítulo 2.0)

std::remove( v1.begin(), v1.end(), 3); //resultado: v1 = {1,2,4,4}; en effet:
std::copy( v1.begin(), v1.end(), std::ostream_iterator<int>(std::cout, " "));
// fijara 1 2 4 4

std::vector<int> v1 = {1,2,3,4}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator it = std::remove( v1.begin(), v1.end(), 3);
std::copy( v1.begin(), it, std::ostream_iterator<int>(std::cout, " "));
// fijara 1 2 4

// IsOdd es un predicado que determina si un nombre es impar
bool IsOdd(int number){	return number&1;}

std::vector<int> v1 = {1,2,3,4,5,6,7}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator it = std::remove_if( v1.begin(), v1.end(), IsOdd);
std::copy( v1.begin(), it, std::ostream_iterator<int>(std::cout, " "));
// fijara: 1 3 5 7

std::vector<int> v1 = {1,2,3,4,3,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::vector<int>::iterator it = std::remove_copy( v1.begin(), v1.end(), v2.begin(), 3);
std::copy( v2.begin(), it, std::ostream_iterator<int>(std::cout, " "));
// fijara: 1 2 4 6

// IsOdd es un predicado que determina si un nombre es impar
bool IsOdd(int number){	return number&1;}

std::vector<int> v1 = {1,2,3,4,3,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::vector<int>::iterator it = std::remove_copy_if( v1.begin(), v1.end(), v2.begin(), IsOdd);
std::copy( v2.begin(), it, std::ostream_iterator<int>(std::cout, " "));
// fijara: 2 4 6

std::vector<int> v = {3,1,1,2,4}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator it = std::unique( v.begin(), v.end() );
std::copy( v.begin(), it, std::ostream_iterator<int>(std::cout, " "));
// va afficher : 3 2 1 4

std::vector<int> v1 = {1,2,2,3,4,4,3,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2;
std::unique_copy(v1.begin(), v1.end(), std::back_inserter(v2) );
// resultado: v2 = {1,2,3,4,3,6}

std::vector<int> v = {1,2,3,4,5} ; // no compila (cf. capítulo 2.0)
std::reverse( v1.begin(), v1.end() );
// resultado : v = {5,4,3,2,1}

std::vector<int> v1 = {1,2,3,4,5}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::reverse_copy( v1.begin(), v1.end(), v2.begin() );
//resultado: v2 = {5,4,3,2,1}

std::vector<int> v = {1,2,3,4,5,6}; // no compila (cf. capítulo 2.0)
std::rotate( v.begin(), v.begin()+2, v.end() );
// resultado: v = {3,4,5,6,1,2}

std::vector<int> v1 = {1,2,3,4,5,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::rotate( v1.begin(), v1.begin()+2, v1.end(), v2.begin() );
// resultado: v2 = {3,4,5,6,1,2}

bool GetRandomAlbum( Album & album )
{
	// si la lista esta vacia, devolvemos false
	if ( main_list_.size() == 0 )
		return false;

	// Generación de la semilla
	srand( clock() );	

	// modificación, de modo aleatorio, el orden de main_list_ 
	std::random_shuffle( main_list_.begin(), main_list_.end() );

	// copia del primero elemento de main_list_ en el resultado
	album = main_list_[0];
	return true;
}

// HaveSameArtist es un predicado que devuelve true si el nombre del artista
// en parametro sea el mismo.
bool Album::HaveSameArtist(std::string artist)	const { return artist_.GetName() == artist; }

// un nombre de artista
std::string artistName = "le nom d'un artiste";

// hacemos una partición de main_list_ en 2 partes: al principio, los discos de los que el artista corresponde 
// en nombre del artista buscado, los otros después.
AlbumList::iterator cut =
	std::partition( main_list_.begin(), 
main_list_.end(), 
std::bind2nd( std::mem_fun_ref<bool, Album, std::string>(&Album::HaveSameArtist ), artistName) );

// IsOdd es un predicado que deter,ina si un nombre es impa
bool IsOdd(int number){	return number&1;}

std::vector<int> v1 = {5,3,1,4,2,8,7,6}; // no compila (cf. capítulo 2.0)
std::stable_partition( v1.begin(), v1.end(), IsOdd );
// resultado : v1 = {5,3,1,7,4,2,8,6}
// con el algoritmo partition(), habría dado : v1 = {5,3,1,7,2,8,4,6}

std::vector<int> v = {3,2,4,1,5}; // no compila (cf. capítulo 2.0)
std::sort( v.begin(), v.end() );
// resultado: v = {1,2,3,4,5}

// Predicado que compara dos char sin tomar cuenta de la caja
bool CompareNoCase(char c1, char c2) { return std::toupper(c1) < std::toupper(c2); }

std::vector<char> s1 = { d,B,b,C,A,D,a,c } ; // no compila (cf. capítulo 2.0)
std::stable_sort(s1.begin(), s1.end(), CompareNoCase );
// resultado: s1 = {A,a,B,b,C,c,d,D}

std::vector<int> v1 = {5,3,1,4,2,8,7,6}; // no compila (cf. capítulo 2.0)
std::partial_sort( v1.begin(), v1.begin() + 4, v1.end() );
// resultado: v1 = {1,2,3,4,5,8,7,6}

std::vector<int> v1 = {5,3,1,4,2,8,7,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2(4);
std::partial_sort_copy( v1.begin(), v1.begin() + 4, v2.begin(), v2.end() );
// resultado: v2 = {1,3,4,5}

std::vector<int> v1 = {5,3,1,4,2,8,7,6}; // no compila (cf. capítulo 2.0)
std::nth_element( v.begin(), v.begin()+3, v.end() );
// resultado : v1 = {1,2,3,4,5,6,7,8}

std::vector<int> v = {1,2,4,6,9}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator it = std::lower_bound( v.begin(), v.end(), 4 );
// resultado: it apunta en el tercero elemento de v (4)

std::vector<int> v = {1,2,4,6,9}; // no compila (cf. capítulo 2.0)
std::vector<int>::iterator it = std::upper_bound( v.begin(), v.end(), 4 );
// resultado: it apunta en le cuarto elemento de v (6)

std::vector<int> v = {1,2,4,4,6,7}; // no compila (cf. capítulo 2.0)
std::pair<std::vector<int>::iterator, std::vector<int>::iterator> newRange ;
newRange = std::equal_range(v.begin(), v.end(), 4) ;
// resultado : r.first apunta en al tercero elemento de v, f.second apunta en el quinto elemento de v (6)

std::vector<int> v1 = {1,2,4,6}; // no compila (cf. capítulo 2.0)
bool b = std::binary_search( v1.begin(), v1.end(), 9 );
// resultado: b = false

std::vector<int> v1 = {1,4,5,7}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,3,6,8}; // no compila (cf. capítulo 2.0)
std::vector v3; // Contenedor en el cual vamos a fusionar v1 y v2
std::merge( v1.begin(), v1.begin(), v2.begin(), v2.end(), back_inserter(v3) );
// resultado: v3 = {1,2,3,4,5,6,7,8}

std::vector<int> v = {1,3,5,2,4,5,6}; // no compila (cf. capítulo 2.0)
std::inplace_merge( v.begin(), v.begin()+3, v.end() );
// resultado: v = {1,2,3,4,5,5,6}

// Verificamos si una lista es incluida en la otra, a en cuyo caso, 
// basta con devolver la que incluye el otro
if ( std::includes( main_list_.begin(), main_list_.end(), second_list_.begin(), second_list_.end() ) )
{
	return main_list_;
}
if ( std::includes( second_list_.begin(), second_list_.end(), main_list_.begin(), main_list_.end() ) )
{
	return second_list_;
}

std::vector<int> v1 = {1,2,2,3,3,4,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,2,6,6,8}; // no compila (cf. capítulo 2.0)
std::vector<int> v3;
std::set_union( v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v3) );
//resultado: v3 = {1,2,2,3,3,4,4,6,6,8}

std::vector<int> v1 = {1,2,2,3,3,4,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,2,6,6,8}; // no compila (cf. capítulo 2.0)
std::vector<int> v3;
std::set_intersection( v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v3) );
//resultado: v3 = {2,2,6}

std::vector<int> v1 = {1,2,2,3,3,4,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,2,6,6,8}; // no compila (cf. capítulo 2.0)
std::vector<int> v3;
std::set_difference( v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v3) );
//resultado: v3 = {1,3,3,4,4}

std::vector<int> v1 = {1,2,2,3,3,4,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,2,6,6,8}; // no compila (cf. capítulo 2.0)
std::vector<int> v3;
std::set_symetric_difference( v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v3) );
//resultado: v3 = {1,3,3,4,4,6,8}

std::vector<int> v = {3,4,5,1,4,3,8}; // no compila (cf. capítulo 2.0)
std::make_heap( v.begin(), v.end() );
//resultado: v = {8,4,6,4,3,1,3}

std::vector<int> v = {8,4,6,4,3,1,3}; // no compila (cf. capítulo 2.0)
v.push_back(9);
std::push_heap( v.begin(), v.end() );
//resultado: v = {9,8,6,4,3,1,3,4}

std::vector<int> v = {9,8,6,4,3,1,3,4}; // no compila (cf. capítulo 2.0)
std::pop_heap( v.begin(), v.end() );
//resultado: v = {8,4,6,4,3,1,3,9}

std::vector<int> v = {9,8,6,4,3,1,3,4}; // no compila (cf. capítulo 2.0)
std::sort_heap( v.begin(), v.end() );
//resultado: v = {1,3,3,4,4,6,8,9}

int num = std::min(3, 4);
//resultado: num = 3;

int num = std::max(3, 4);
//resultado: num = 4;

// IsNewerThan es un predicado que devuelve true si el año de salida del disco pasado en parametro
// es inferior al del álbum.
bool Album::IsNewerThan(const Album & other) const { return year_ < other.GetYear(); }

Album GetOldest()
{
	AlbumList::const_iterator oldest = 
		std::min_element( main_list_.begin(), main_list_.end(), std::mem_fun_ref( &Album::IsNewerThan ) );

	return Album(*oldest);
}

// IsNewerThan es un predicado que devuelve true si el año de salida del disco pasado en parametro
// es inferior al del álbum.
bool Album::IsNewerThan(const Album & other) const { return year_ < other.GetYear(); }

Album GetMostRecent()
{
	AlbumList::const_iterator mostRecent = 
		std::max_element( main_list_.begin(), main_list_.end(), std::mem_fun_ref( &Album::IsNewerThan ) );

	return Album(*mostRecent);
}

std::vector<int> v1 = {1,3,4,5}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,3,4,5}; // no compila (cf. capítulo 2.0)
std::lexicographical_compare( v1.begin(), v1.end(), v2.begin(), v2.end() ); // devuelve true

std::vector<int> v1 = {5,3,1,4,2}; // no compila (cf. capítulo 2.0)
std::next_permutation( v1.begin(), v1.end() );
// resultado : v1 = {5,3,2,1,4}

std::vector<int> v1 = {5,3,1,4,2}; // no compila (cf. capítulo 2.0)
std::prev_permutation( v1.begin(), v1.end() );
// resultado : v1 = {5,3,1,2,4}

// utilización de accumulate() sin función binaria
std::vector<int> v = {1,2,3,4,5}; // no compila (cf. capítulo 2.0)
int r = std::accumulate( v.begin(), v.end(), 0 ); // Aquí 0 corresponde al valor inicial
// resultado: r = 0 + 1 + 2 + 3 + 4 + 5 = 15

// Mult es una función binaria que multiplica dos enteros y devuelve el resultado de esta multiplicación:
int Mult(const int a, const int b){ return a*b; }

// utilización de accumulate() con una función binaria:
r = std::accumulate( v.begin(), v.end(), 1, Mult ); // Aquí 1 corresponde al valor inicial
// Si este valor hubiera sido 0, el resultado habría sido 0.
// resultado: r = 1 * 1 * 2 * 3 * 4 * 5 = 120

std::vector<int> v1 = {1,2,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2 = {2,1,2,-1}; // no compila (cf. capítulo 2.0)
int r = std::inner_product( v1.begin(), v1.end(), v2.begin(), 0 ); // Aquí 1 corresponde al valor inicial
// resultado : r = 0 + 1*2 + 2*1 + 4*2 + 6*-1 = 

std::vector<int> v1 = {1,2,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() );
std::adjacent_difference( v1.begin(), v1.end(), v2.begin() );
// resultado : v2 = {1,1,2,2}

std::vector<int> v1 = {1,2,4,6}; // no compila (cf. capítulo 2.0)
std::vector<int> v2( v1.size() ) ;
std::adjacent_difference( v1.begin(), v1.end(), v2.begin() );
// resultado : v2 = {1,3,7,13}

// estructura Coche
struct Coche 
{
	int GetNbRuedas() const {return 4 ;}
};

// un array de coches
std::vector<Coche> v;

// Una implementación posible para recuperar el número total de ruedas:
int ComputeWheelNumber()
{
	// Creamos un vector que contiene el número de rueda de cada coche
	std::vector<int> nbRuedas( v.size() );
	std::transform( v.begin(), v.end(), nbRuedas.begin(), std::mem_fun_ref( &Coche::GetNbRuedas ) );

	// Devolvemos la suma de todos los elementos de este vector
	return std::accumulate( nbRuedas.begin(), nbRuedas.end(), 0 );
}

clase Vehiculo
{
public:
	virtual int GetNbRuedas() const = 0 ;
};

class Coche : public Vehiculo
{
public:
	int GetNbRuedas() const {return 4 ;}
};

Class Motocicleta : public Vehiculo
{
public:
	int GetNbRuedas() const {return 2 ;}
};

std::vector<Vehiculo*> v;

int ComputeWheelNumber()
{
	// Creamos un vector que contiene el número de rueda de cada coche
	std::vector<int> nbRuedas( v.size() );
	std::transform( v.begin(), v.end(), nbRuedas.begin(), std::mem_fun( & Vehicule::GetNbRuedas ) );

	// Devolvemos la suma de todos los elementos de este vector
	return std::accumulate( nbRuedas.begin(), nbRuedas.end(), 0 );
}