C++ Tutoriel STL

La bibliothèque de modèles standard C++ (STL) est un puissant ensemble de classes et de fonctions de modèles C++ qui fournit une série d'algorithmes et de structures de données génériques et réutilisables.

La conception de la STL est basée sur la programmation générique, ce qui signifie que les modèles peuvent être utilisés pour écrire du code indépendant de tout type de données spécifique.

La STL est divisée en plusieurs composants, notamment les conteneurs, les itérateurs, les algorithmes, les objets fonction et les adaptateurs, etc.

Avantages de l'utilisation de la STL :

  • Réutilisation du code: la STL fournit un grand nombre de structures de données et d'algorithmes génériques, ce qui réduit le travail d'écriture de code répétitif.
  • 性能优化：STL 中的算法和数据结构经过优化，以提供最佳性能。
  • 泛型编程：STL 使用模板支持泛型编程，使算法和数据结构能够应用于任何数据类型。
  • 易于维护：STL 的设计使代码更加模块化，更易于阅读和维护。

C++ 标准模板库的核心包括以下重要组件：

Composants Description
Conteneurs

容器是 STL 中最基本的组件之一。它们提供各种数据结构，包括 vector、list、queue、stack、set、map 等。这些容器具有不同的特性和用途，因此你可以根据实际需求选择合适的容器。
算法 STL 提供了大量算法，用于对容器中的元素执行各种操作，包括排序、查找、复制、移动、变换等。使用这些算法时，无需关心容器的具体类型；只需指定要操作的范围。
迭代器 迭代器用于遍历容器中的元素，使元素能够以统一的方式访问，而无需担心容器的内部实现细节。STL 提供了多种类型的迭代器，包括随机访问迭代器、双向迭代器、前向迭代器以及输入/输出迭代器等。
函数对象 函数对象是可以像函数一样被调用的对象，可用于算法中的各种操作。STL 提供了多种函数对象，包括一元函数对象、二元函数对象、谓词等，以满足不同需求。
适配器 Les adaptateurs servent à adapter un conteneur ou un itérateur en un autre conteneur ou itérateur afin de répondre à des besoins spécifiques. STL fournit une variété d’adaptateurs, notamment l’adaptateur de pile, l’adaptateur de file d’attente et l’adaptateur de file de priorité, entre autres.

Ces composants sont tous livrés avec un riche ensemble de fonctions prédéfinies, nous aidant à gérer des tâches complexes de manière simple.

Conteneur

Les conteneurs sont des séquences utilisées pour stocker des données, et ils offrent différentes méthodes de stockage et modes d’accès.

Les conteneurs dans STL peuvent être divisés en trois catégories :

1. Conteneurs de séquence : stockent des séquences d’éléments et permettent un parcours bidirectionnel.

  • std::vector : tableau dynamique, prend en charge un accès aléatoire rapide.
  • std::deque : file à double extrémité, prend en charge une insertion et une suppression rapides.
  • std::list : liste chaînée, prend en charge une insertion et une suppression rapides, mais ne prend pas en charge l’accès aléatoire.

2. Conteneurs associatifs : stockent des paires clé-valeur. Chaque élément possède une clé et une valeur, et les éléments sont organisés par clés.

  • std::set : ensemble, les éléments en double ne sont pas autorisés.
  • std::multiset : multiensemble, permet à plusieurs éléments d’avoir la même clé.
  • std::map : table associative, chaque clé est associée à une valeur.
  • std::multimap : multimap, stocke des paires clé-valeur (pair), où les clés ne sont pas uniques et les valeurs peuvent être répétées, ce qui permet à une clé de correspondre à plusieurs valeurs.

3. Conteneurs non ordonnés (introduits en C++11) : tables de hachage, permettant une recherche, une insertion et une suppression rapides.

  • std::unordered_set : ensemble non ordonné.
  • std::unordered_multiset : multiensemble non ordonné.
  • std::unordered_map : table associative non ordonnée.
  • std::unordered_multimap : multimap non ordonnée.

Le programme suivant illustre le conteneur vector (un modèle standard C++), qui est très similaire à un tableau. La seule différence est que lorsque le vector doit agrandir sa taille, il gère automatiquement ses propres besoins de stockage :

Exemple

#include <iostream> #include <vector> using namespace std; int main() { // Créer un vector pour stocker des int vector<int> vec; int i; // Afficher la taille d'origine de vec cout << "taille du vector = " << vec.size() << endl; // Ajouter 5 valeurs dans le vector for(i = 0; i < 5; i++){ vec.push_back(i); } // Afficher la taille de vec après agrandissement cout << "taille étendue du vecteur = " << vec.size() << endl; // Accéder aux 5 valeurs du vecteur for(i = 0; i < 5; i++){ cout << "valeur de vec [" << i << "] = " << vec[i] << endl; } // Utiliser un itérateur pour accéder aux valeurs vector<int>::iterator v = vec.begin(); while( v != vec.end()) { cout << "valeur de v = " << *v << endl; v++; } return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

vector size = 0
extended vector size = 5
value of vec [0] = 0
value of vec [1] = 1
value of vec [2] = 2
value of vec [3] = 3
value of vec [4] = 4
value of v = 0
value of v = 1
value of v = 2
value of v = 3
value of v = 4

Concernant les différentes fonctions utilisées dans l'exemple ci-dessus, il y a quelques points à noter :

  • La fonction membre push_back( ) insère une valeur à la fin du vecteur, en augmentant la taille du vecteur si nécessaire.
  • La fonction size( ) affiche la taille du vecteur.
  • La fonction begin( ) renvoie un itérateur pointant vers le début du vecteur.
  • La fonction end( ) renvoie un itérateur pointant vers la fin du vecteur.

STL est une partie indispensable de la programmation C++. Elle élargit considérablement les fonctionnalités de C++, permettant aux programmeurs d'écrire du code plus efficace et plus lisible.

Maîtriser l'utilisation de la STL est très important pour tout programmeur C++.

autres extensions