Cet article définit les concepts de base de la bibliothèque C ++ standard. Il est donné afin d'y faire référence à l'avenir.
La plus grande partie de la bibliothèque standard C ++ est la STL (bibliothèque de modèles standard). La bibliothèque STL contient cinq principaux types de composants:
- conteneur : contrôle un ensemble d'objets en mémoire.
- itérateur : fournit un algorithme permettant à l'algorithme d'accéder au contenu du conteneur.
- algorithme : définit une procédure de calcul.
- objet fonction : encapsule une fonction dans un objet pour une utilisation par d'autres composants.
- adaptateur : adapte un composant pour fournir une interface différente.
Tous les composants répondent à un certain nombre d'exigences et sont donc en bon accord les uns avec les autres.
De la définition du conteneur, il s'ensuit que toute structure de données utilisateur est un conteneur. Dans notre cas, les
conteneurs ont des structures de données standard , telles qu'une liste, un vecteur, un dictionnaire et bien d'autres. Les exigences formelles pour les conteneurs sont assez étendues, mais la règle de base est l'accès aux éléments. L'accès aux éléments du conteneur se fait par le biais d'objets spéciaux -
itérateurs (voir ci-dessous). Vous ne savez peut-être pas comment les éléments du conteneur sont situés en mémoire, mais vous savez à coup sûr que les itérateurs peuvent être itérés de manière séquentielle, et chacun d'eux donnera accès à l'élément. Un itérateur pointant vers le premier élément peut être obtenu en utilisant la méthode
begin () de l'
itérateur; conteneur. Un itérateur pointant
vers le dernier élément peut être obtenu en utilisant la méthode
itérateur end (); conteneur. En d'autres termes, les itérateurs sont situés dans un
demi-intervalle (ou
demi- segment), qui peut être formellement écrit comme [début, fin]. Exemple de déclaration de conteneur:
struct a_container { struct an_iterator; an_iterator begin(); an_iterator end(); };
La norme C ++ 20 attendue suggère d'utiliser une structure qui encapsule les demi- plages - plages
Un itérateur est un objet qui donne accès aux éléments du conteneur et permet de les trier. Un itérateur est une propriété du conteneur. Dans les premières implémentations de la bibliothèque standard C ++, un itérateur a été implémenté comme pointeur vers un élément conteneur. Dans les implémentations modernes, il s'agit d'une classe qui encapsule un pointeur sur un objet conteneur.
Les principales exigences pour les itérateurs sont la présence d'opérateurs de déréférencement et d'incrémentation. Vous trouverez ci-dessous une déclaration de conteneur avec un itérateur.
template<typename TYPE> struct a_container { struct an_iterator { void operator++(); TYPE& operator*(); }; an_iterator begin(); an_iterator end(); };
Je ne peux pas donner une meilleure définition de l’algorithme que l’algorithme standard: un
algorithme est une séquence d’actions conduisant au résultat souhaité en un nombre fini d’étapes .
Dans le cas de STL, les algorithmes sont implémentés par des fonctions de modèle qui prennent des demi-intervalles d'itérateurs comme paramètres d'entrée. La signature générale de ces algorithmes est décrite comme suit:
template<typename ITERATOR, typename RESULT> RESULT an_algorithm(ITERATOR first, ITERATOR last, ...);
Dans une déclaration de classe, vous pouvez remplacer l'opérateur (). Si cet opérateur est substitué dans une classe, les objets de cette classe reçoivent les propriétés des fonctions (ils peuvent être utilisés comme fonctions). Ces objets sont appelés fonctionnels ou
foncteurs . Il est pratique d'utiliser des foncteurs lorsqu'une fonction doit avoir une "mémoire", ainsi que de remplacer des pointeurs vers des fonctions.
À partir de la norme C ++ 11, il est possible de noter brièvement les foncteurs - fonctions lambda.
Il n'y a pas d'exigences particulières pour les foncteurs. Sauf si parfois l'héritage de la
fonction foncteur peut être requis (jusqu'à la norme C ++ 11 - unary_function ou binary_function). Un petit exemple d'implémentation d'un foncteur:
template<typename TYPE> struct plus{ TYPE operator ()(const TYPE& p1, const TYPE& p2) const{ return p1 + p2; } };
STL propose également un certain nombre de classes et de fonctions (fonctions) qui transforment l'interface en la bonne. En particulier, il existe un adaptateur de pile qui implémente une pile basée sur des conteneurs. À titre d'exemple, nous pouvons considérer l'adaptateur d'une fonction binaire à une fonction unaire (pour le moment cette fonction est déconseillée dans la norme C ++):
template<typename BIDIRECTIONAL_FUNCTION, typename TYPE> class bind1st { BIDIRECTIONAL_FUNCTION _bf; TYPE _first; public: bind1st(BIDIRECTIONAL_FUNCTION bf, TYPE first): _bf(bf), _first(first) {} TYPE operator()(const TYPE& p) const { return _bf(_first, p); } };
Pour une lecture indépendante
- Brouillon C ++ 20 sur github
- Référence C ++
- Développement d'applications C ++
- Gamme-v3, proposition de standard