#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

using std::cout;

int main()
{
    // créer un tableau d'entiers vide
    std::vector<int> v;
    
    // ajouter l'entier 10 à la fin
    v.push_back( 10 );

    // afficher le premier élément (10)
    cout << v.front() << '\n';

    // afficher le dernier élément (10)
    cout << v.back() << '\n';

    // enlever le dernier élément
    v.pop_back(); // supprime '10'

    // le tableau est vide
    if ( v.empty() )
    {
        cout << "Tout est normal : tableau vide\n";
    }

    // redimensionner le tableau
    // resize() initialise tous les nouveaux entiers à 0
    v.resize( 10 );
    
    // quelle est sa nouvelle taille ?
    cout << v.size() << '\n'; // affiche 10

    // sa taille est de 10 : on peut accéder directement aux
    // 10 premiers éléments
    v[ 9 ] = 5;

    // intitialiser tous les éléments à 100
    std::fill( v.begin(), v.end(), 100 );

    // vider le tableau
    v.clear(); // size() == 0

    // on va insérer 50 éléments
    // réserver (allouer) de la place pour au moins 50 éléments
    v.reserve( 50 );

    // véridier que la taille n'a pas bougé (vide)
    cout << v.size() << '\n';

    // capacité du tableau = nombre d'éléments qu'il peut stocker
    // sans devoir réallouer (modifié grâce à reserve())
    cout << v.capacity() << '\n'; // au moins 50, sûrement plus

    for ( int i = 0; i < 50; ++i )
    {
        // grâce à reserve() on économise de multiples réallocations
        // du fait que le tableau grossit au fur et à mesure
        v.push_back( i );
    }

    // afficher la nouvelle taille
    cout << v.size() << '\n'; // affiche 50

    // rechercher l'élément le plus grand (doit être 49)
    cout << *std::max_element( v.begin(), v.end() ) << '\n';

    // tronquer le tableau à 5 éléments
    v.resize( 5 );

    // les trier par ordre croissant
    std::sort( v.begin(), v.end() );

    // parcourir le tableau
    for ( size_t i = 0, size = v.size(); i < size; ++i )
    {
        // attention : utilisation de l'opérateur []
        // les accès ne sont pas vérifiés, on peut déborder !
        cout << v[ i ] << '\t';        
    }
    cout << '\n';

    // utilisation de at() : les accès sont vérifiés
    try
    {
        v.at( v.size() ) = 10; // accès en dehors des limites !
    }
    catch ( const std::out_of_range & )
    {
        cout << "at() a levé une exception std::out_of_range\n";
    }

    // parcours avec un itérateur en inverse
    for ( std::vector<int>::reverse_iterator i = v.rbegin();
          i != v.rend();
          ++i )
    {
        cout << *i << '\t';
    }
    cout << '\n';

    // on crée un tableau v2 de taille 10
    std::vector<int> v2( 10 );
    v2.at( 9 ) = 5; // correct, le tableau est de taille 10

    // on crée un tableau v3 de 10 éléments initialisés à 20
    std::vector<int> v3( 10, 20 );

    // faire la somme de tous les éléments de v3
    // on doit obtenir 200 (10 * 20)
    cout << std::accumulate( v3.begin(), v3.end(), 0 ) << '\n';

    // on recopie v3 dans v
    v = v3;

    // on vérifie la recopie
    if ( std::equal( v.begin(), v.end(), v3.begin() ) )
    {
        cout << "v est bien une copie conforme de v3\n";
    }
}

#include <vector>

std::vector<int> s;
for (std::vector<int>::iterator it = s.begin(); it != s.end(); )
{
    if (*it == 5)
        it = s.erase(it);
    else
        ++it;
}

#include <string>
#include <vector>
#include <algorithm>

std::string s = "blah blah";
s.erase(std::remove(s.begin(), s.end(), 'h'), s.end());

std::vector v;
v.erase(std::remove_if(v.begin(), v.end(), std::bind2nd(std::greater<int>(), 3)), v.end());

std::list<int> l;
l.remove(5);
l.remove_if(std::bind2nd(std::greater<int>(), 3));

#include <map>
#include <string>

std::map<std::string, int> m;
m.erase("toto");

void Fonction_C(const int* Tableau, unsigned int Taille);

std::vector<int> v;
Fonction_C(&v[0], v.size());

int* Fonction_C(int* Taille); // Renvoie un tableau et sa taille

int Taille = 0;
int* Tableau = Fonction_C(&Taille);

// Méthode 1 : utilisation du constructeur prenant en paramètre une paire d'itérateurs
std::set<int> s(Tableau, Tableau + Taille);

// Méthode 2 : utilisation de la fonction membre assign
std::list<int> l;
l.assign(Tableau, Tableau + Taille);

// Méthode 3 : utilisation de std::copy
std::vector<int> v;
std::copy(Tableau, Tableau + Taille, std::back_inserter(v));

struct A 
{ 
    int Number; 
    std::string String; 
}; 
   
// Définition du foncteur servant à trier nos objets selon le nombre 
struct SortByNumber 
{ 
    bool operator ()( const A & a1, const A & a2 ) const 
    { 
        return a1.Number < a2.Number; 
    } 
}; 

// Définition du foncteur servant à trier nos objets selon la chaîne 
struct SortByString 
{ 
    bool operator ()( const A & a1, const A & a2 ) const 
    { 
        return a1.String < a2.String; 
    } 
};

    int a = 2; 
    if ( std::greater<int>()( a, 1 ) ) 
    { 
        // ce test est vrai car a > 1 
    } 

std::set< std::greater<int> > entiersTriesParOrdreDecroissant;

#include <iostream> 
#include <vector> 

// prédicat personnalisé permettant de tester si un 
// entier est strictement supérieur à 10 
struct plus_grand_que_10 
{ 
    bool operator ()( int N ) const 
    { 
        return N > 10; 
    } 
}; 

int main() 
{ 
    std::vector<int> v; 
    v.push_back( 0 ); 
    v.push_back( 5 ); 
    v.push_back( 10 ); 
    v.push_back( 15 ); 
    v.push_back( 20 ); 

    // compter le nombre de valeurs > 10 
    int n = std::count_if( 
        v.begin(), 
        v.end(), 
        plus_grand_que_10() ); // utilisation de notre prédicat 

    std::cout << n << '\n'; // affiche 2 
} 

struct plus_grand_que_10 
{ 
    bool operator ()( int N ) const 
    { 
        return 10 < N; 
    } 
}; 

<bind>( <foncteur>, <valeur du paramètre à figer> ); 

#include <iostream> 
#include <vector> 

int main() 
{ 
    std::vector<int> v; 
    v.push_back( 0 ); 
    v.push_back( 5 ); 
    v.push_back( 10 ); 
    v.push_back( 15 ); 
    v.push_back( 20 ); 

    // compter le nombre de valeurs > 10 
    
    // méthode 1 : utilisation de bind2nd pour 
    // la création d'un prédicat x > 10 
    int n = std::count_if( 
        v.begin(), 
        v.end(), 
        std::bind2nd( std::greater<int>(), 10 ) ); 

    std::cout << n << '\n'; // affiche 2 

    // méthode 2 : utilisation de bind1st pour 
    // la création d'un prédicat 10 < x 
    n = std::count_if( 
        v.begin(), 
        v.end(), 
        std::bind1st( std::less<int>(), 10 ) );      

    std::cout << n << '\n'; // affiche 2 
} 

#include <vector> 
#include <algorithm> 
#include <iostream> 
#include <string> 
#include <set> 

// Définition de notre structure à trier 
struct A 
{ 
   A(int i, std::string s) : Number(i), String(s) {} 

   int Number; 
   std::string String; 
}; 

// Surcharge de l'opérateur << pour afficher nos A 
std::ostream& operator <<(std::ostream& Stream, const A& a) 
{ 
   return Stream << a.Number << " " << a.String; 
} 
    
// Définition du foncteur servant à trier nos objets selon le nombre 
struct SortByNumber 
{ 
   bool operator ()(const A& a1, const A& a2) const 
   { 
      return a1.Number < a2.Number; 
   } 
}; 

// Définition du foncteur servant à trier nos objets selon la chaîne 
struct SortByString 
{ 
   bool operator ()(const A& a1, const A& a2) const 
   { 
      return a1.String < a2.String; 
   } 
}; 

int main() 
{ 
   // Création d'un tableau de A 
   std::vector<A> v; 
   v.push_back(A(1, "salut")); 
   v.push_back(A(5, "hello")); 
   v.push_back(A(2, "buenos dias")); 

   // Tri selon leur numéro 
   std::sort(v.begin(), v.end(), SortByNumber()); 
   std::copy(v.begin(), v.end(), std::ostream_iterator<A>(std::cout, "\n")); 
   std::cout << std::endl; 

   // Tri selon leur chaîne de caractères 
   std::sort(v.begin(), v.end(), SortByString()); 
   std::copy(v.begin(), v.end(), std::ostream_iterator<A>(std::cout, "\n")); 
   std::cout << std::endl; 

   // On peut également personnaliser le comportement des conteneurs triés 
   std::set<A, SortByString> s; 
   s.insert(A(1, "salut")); 
   s.insert(A(5, "hello")); 
   s.insert(A(2, "buenos dias")); 

   // Les éléments du conteneurs sont automatiquement triés selon leur chaîne grâce à notre foncteur
   std::copy(s.begin(), s.end(), std::ostream_iterator<A>(std::cout, "\n")); 

   return 0; 
}

#include <list> 
#include <algorithm>

// Foncteur servant à libérer un pointeur - applicable à n'importe quel type
struct Delete 
{ 
   template <class T> void operator ()(T*& p) const 
   { 
      delete p;
      p = NULL;
   } 
}; 

int main() 
{ 
   // Création d'une liste de pointeurs 
   std::list<int*> l; 
   l.push_back(new int(5)); 
   l.push_back(new int(0)); 
   l.push_back(new int(1)); 
   l.push_back(new int(6)); 

   // Destruction de la liste : attention il faut bien libérer les pointeurs avant la liste ! 
   std::for_each(l.begin(), l.end(), Delete()); 

   return 0; 
}

std::list<int> mylist;
mylist.sort();
 
// Ou alors, avec un foncteur :
std::list<int> mylist;
mylist.sort(MonFoncteur());

// Copie de la liste dans un nouveau vecteur
std::vector v(mylist.begin(), mylist.end());
 
// Tri du vecteur
std::sort(v.begin(), v.end(), MonFoncteur());
 
// Recopie du vecteur dans la liste originale
mylist.clear();
std::copy(v.begin(), v.end(), std::back_inserter(mylist));