Vue d’ensemble et philosophie de la STL
Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 70 sur 104.
La Standard Template Library (STL) est un ensemble de classes et de fonctions basées sur des modèles qui fournissent des structures de données et des algorithmes courants. Fondée sur les concepts de modèles que tu as appris, la STL incarne une philosophie de conception puissante : séparer le stockage des données de leur manipulation.
La STL s’articule autour de trois composants essentiels qui fonctionnent ensemble :
| Composant | Objectif | Exemples |
|---|---|---|
| Conteneurs | Stocker des collections d’objets | vector, map, set |
| Itérateurs | Fournir un accès aux éléments des conteneurs | Entrée, sortie, accès aléatoire |
| Algorithmes | Effectuer des opérations sur les données | sort, find, transform |
L’idée essentielle, c’est que les algorithmes ne connaissent pas directement les conteneurs : ils fonctionnent grâce aux itérateurs. Cela signifie qu’un même algorithme sort fonctionne avec les vecteurs, les tableaux et tout conteneur qui fournit le type d’itérateur approprié :
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
std::vector<int> nums = {5, 2, 8, 1, 9};
std::sort(nums.begin(), nums.end());
for (int n : nums) {
std::cout << n << " ";
}
// Sortie : 1 2 5 8 9
}Cette séparation signifie que tu peux combiner les éléments à ta guise : utiliser n’importe quel algorithme avec n’importe quel conteneur compatible sans écrire de nouveau code. La STL fournit des implémentations éprouvées et optimisées, afin que tu puisses te concentrer sur la résolution de problèmes plutôt que de réinventer des structures de données courantes.
Défi
FacileConstruisons un système simple de traitement des données qui illustre la philosophie de la STL, qui consiste à séparer les conteneurs, les itérateurs et les algorithmes. Tu vas créer un module utilitaire qui fonctionne avec les composants de la STL et un programme principal qui montre comment ces éléments s’articulent.
Tu vas créer deux fichiers :
DataProcessor.h: définis des fonctions utilitaires qui fonctionnent avec les conteneurs de la STL au moyen d’itérateurs, illustrant ainsi la philosophie de conception de la STL.Crée une fonction appelée
printVectorqui prend unstd::vector<int>&et affiche tous ses éléments séparés par des espaces, puis passe à la ligne. Utilise des itérateurs (begin()etend()) pour parcourir le conteneur.Crée une fonction appelée
sortAndPrintqui prend unstd::vector<int>&, le trie à l’aide destd::sort, puis affiche les éléments triés séparés par des espaces et passe à la ligne.Crée une fonction appelée
findElementqui prend unstd::vector<int>&et une valeurintà rechercher. Utilisestd::findpour trouver l’élément. S’il est trouvé, afficheFound: <value>. Sinon, afficheNot found: <value>.Crée une fonction appelée
getSumqui prend unstd::vector<int>&et renvoie la somme de tous ses éléments. Tu peux utiliser une simple boucle avec des itérateurs pour cela.main.cpp: lis les entrées et montre comment les composants de la STL fonctionnent ensemble.Lis cinq entrées (chacune sur une ligne distincte) :
- Premier entier
- Deuxième entier
- Troisième entier
- Quatrième entier
- Une valeur à rechercher
Crée un
std::vector<int>et ajoute-y les quatre premiers entiers. Montre ensuite la philosophie de la STL en :- Affichant
Original:, puis en appelantprintVector - Affichant
Sorted:, puis en appelantsortAndPrint - Appelant
findElementavec la valeur à rechercher - Affichant
Sum: <result>à l’aide degetSum
Par exemple, avec les entrées 5, 2, 8, 1 et 8 :
Original: 5 2 8 1
Sorted: 1 2 5 8
Found: 8
Sum: 16Avec les entrées 10, 30, 20, 40 et 15 :
Original: 10 30 20 40
Sorted: 10 20 30 40
Not found: 15
Sum: 100Remarque comment tes fonctions travaillent avec le vecteur au moyen d’itérateurs, et comment std::sort et std::find fonctionnent avec n’importe quel conteneur qui fournit le type d’itérateur approprié. C’est là toute la puissance de la conception de la STL : les algorithmes sont découplés des conteneurs et ne sont reliés à eux que par des itérateurs.
Essayez vous-même
#include <iostream>
#include <vector>
#include "DataProcessor.h"
using namespace std;
int main() {
// Lire cinq entiers depuis l'entrée
int num1, num2, num3, num4, searchValue;
cin >> num1;
cin >> num2;
cin >> num3;
cin >> num4;
cin >> searchValue;
// TODO: Créer un vecteur et y ajouter les quatre premiers entiers
// TODO: Afficher "Original: " et appeler printVector
// TODO: Afficher "Sorted: " et appeler sortAndPrint
// TODO: Appeler findElement avec la valeur recherchée
// TODO: Afficher "Sum: " suivi du résultat de getSum
return 0;
}
Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.
Toutes les leçons de Programmation Orientée Objet
1Fondamentaux de la POO
Fichiers externesGénération et compilation en C++Fichiers d’en-tête et fichiers sourceEspaces de noms et portéeIntroduction à la POO en C++Classes et objetsLe pointeur « this »Méthodes (fonctions membres)Attributs (membres de données)Bases des constructeurs et destructeursRécapitulatif - Calculatrice simple4Propriétés de classe
Membres d’instance et statiquesAccesseurs et mutateursFonctions membres constMot-clé mutableMéthodes et variables statiquesFonctions et classes amiesRécapitulatif - Gestionnaire de compte bancaire7Héritage
Héritage de baseNiveaux d’accès de l’héritageOrdre d’appel des constructeurs et destructeursRedéfinition des méthodesFonctions virtuelles et VTableHéritage multipleHéritage virtuelRécapitulatif : hiérarchie des employés10Vue d’ensemble de la STL
Vue d’ensemble et philosophie de la STLConteneurs de la STLItérateursAlgorithmes de la STLFoncteurs et expressions lambdaRécapitulatif - fréquence des mots13Modèles de conception, partie 1
Introduction aux modèles de conceptionModèle SingletonFabrique et fabrique abstraiteModèle BuilderModèle ObserverModèle Strategy2Gestion de la mémoire
Mémoire de pile ou de tasPointeurs et référencesMémoire dynamique (new/delete)Pointeurs intelligents en C++RAII en C++Récapitulatif - Gestionnaire de tableaux dynamiques5Encapsulation
Spécificateurs d’accès en C++Spécificateurs d’accès en profondeurMasquage de l’informationStruct vs classeClasses imbriquées et internesRécapitulatif - Système de gestion des dossiers étudiants8Polymorphisme
Polymorphisme à la compilation vs à l’exécutionSurcharge de fonctionsRetour sur les fonctions virtuellesFonctions virtuelles puresClasses abstraitesConception d’interfaces en C++Conversion dynamique et RTTIRécapitulatif - Calculateur de formes3Constructeurs et destructeurs
Constructeur par défautConstructeur paramétréConstructeur de copieConstructeur de déplacementListes d’initialisation des constructeursConstructeurs déléguésApprofondissement des destructeursRègle des trois / cinq / zéroRécapitulatif - Classe String6Surcharge des opérateurs
Introduction à la surcharge des opérateursSurcharge des opérateurs arithmétiquesSurcharge des opérateurs de comparaisonOpérateurs de fluxSurcharge de l’opérateur d’affectationSurcharge des opérateurs [] et ()Opérateurs de conversion de typeRécapitulatif – Classe Matrix9Templates
Templates de fonctionsTemplates de classesSpécialisation des templatesTemplates variadiquesBases de SFINAE et des traits de typesRécapitulatif - Conteneur génériqueEntraînez-vous par vous-même : Compilateur C++ en ligne