FAQ C++Consultez toutes les FAQ

Le C++ poss�de une biblioth�que standard (on parle aussi de SL pour Standard Library) qui est compos�e, entre autre, d'une biblioth�que de flux, de la biblioth�que standard du C, de la gestion des exceptions�, et de la STL (Standard Template Library : biblioth�que de mod�les standard). En fait, STL est une appellation historique commun�ment accept�e et comprise. Dans la norme on ne parle que de SL.
Comme son nom l'indique cette biblioth�que utilise fortement les templates C++ et le concept de g�n�ricit�. Elle d�finit ainsi de nombreux mod�les de classes et de fonctions g�n�riques parmi lesquelles les conteneurs (tableau, liste, pile, ensemble�) et les algorithmes (copie, tri, recherche�) les plus courants. Une particularit� importante est son approche orient�e it�rateurs, ce qui permet par exemple d'utiliser ses algorithmes sur d'autres conteneurs que ceux qu'elle fournit.
L'un des avantages de la STL par rapport aux autres biblioth�ques remplissant (plus ou moins) le m�me r�le est qu'elle est standard, et donc th�oriquement portable (cependant les limites de certains compilateurs compliquent la chose). Un autre avantage important est son polymorphisme param�trique qui assure un typage fort sans exigence syntaxique � l'utilisation, c'est-�-dire par exemple que l'on peut tr�s simplement cr�er un tableau de ce que l'on veut sans devoir downcaster depuis un horrible type commun tel que void *.
Utiliser la STL permet donc d'augmenter de mani�re significative sa productivit� en C++ en �crivant du code fiable, performant et portable.

Toute classe surchargeant l'op�rateur d'appel de fonction operator() est qualifi�e de classe foncteur (functor class). Les objets instanci�s d'une telle classe sont appel�s objets fonctionnels (function objects) ou foncteurs (functors). La STL utilise beaucoup ce concept pour personnaliser le comportement de ses classes/fonctions.
Notez qu'on peut tout � fait utiliser des pointeurs sur fonction au lieu de foncteurs (il suffit de pouvoir appliquer l'op�rateur�() � l'objet pass� en param�tre), mais on pr�f�rera les foncteurs car ils offrent plus de performances et de flexibilit�. En effet operator() peut �tre enti�rement inlin�, et on peut passer des param�tres au foncteur via son constructeur pour plus de souplesse.
Voici un exemple typique de foncteurs tir� de la question [Exemple] Comment trier une s�quence selon un crit�re personnalis� ?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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;  
    }  
};

Les pr�dicats (predicate) sont un type particulier de foncteurs qui renvoient un bool�en ou quelque chose de convertible en bool�en ce qui les rend utilisables dans des expressions logiques. Il existe un certain nombre de pr�dicats pr�d�finis dans la STL, en particulier en ce qui concerne les op�rateurs logiques et arithm�tiques �l�mentaires :

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

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

std::bind1st et std::bind2nd sont un type particulier de foncteurs appel�s foncteurs r�ducteurs. Ils permettent de facilement cr�er un pr�dicat unaire (c.a.d acceptant un seul param�tre) � partir d'un pr�dicat binaire (en acceptant deux param�tres). Ceci est fait en figeant la valeur d'un des deux param�tres du pr�dicat binaire (c.a.d. � le remplacer par une valeur fixe).
Soit l'exemple suivant o� le pr�dicat plus_grand_que_10 est cr�� afin de compter gr�ce � std::count_if le nombre de valeurs sup�rieures � 10 dans un conteneur :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>  
#include <vector>  
#include <algorithm>  
  
// 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  
}

1
2
3
4
5
6
7
struct plus_grand_que_10  
{  
    bool operator ()( int N ) const  
    {  
        return 10 < N;  
    }  
};

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>  
#include <vector>  
#include <algorithm>  
#include <functional>  
  
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  
}