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 une collection 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 vous avez appris, la STL incarne une philosophie de conception puissante : séparer le stockage des données de leur manipulation.

La STL est organisée 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 du conteneur	Accès en entrée, en sortie et aléatoire
Algorithmes	Effectuer des opérations sur les données	`sort`, `find`, `transform`

L’idée clé est que les algorithmes ne connaissent pas directement les conteneurs : ils fonctionnent par l’intermédiaire d’itérateurs. Cela signifie qu’un seul algorithme sort fonctionne avec des vecteurs, des 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 vous pouvez combiner librement les éléments : 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 vous puissiez vous concentrer sur la résolution des problèmes plutôt que de réinventer des structures de données courantes.

Défi

Facile

Construisons un système simple de traitement des données qui illustre la philosophie de la STL consistant à séparer les conteneurs, les itérateurs et les algorithmes. Vous allez créer un module utilitaire qui fonctionne avec les composants de la STL, ainsi qu’un programme principal montrant comment ces éléments s’assemblent.

Vous allez créer deux fichiers :

DataProcessor.h : définissez des fonctions utilitaires qui fonctionnent avec les conteneurs de la STL באמצעות des itérateurs, illustrant la philosophie de conception de la STL.
Créez une fonction appelée printVector qui prend un std::vector<int>& et affiche tous les éléments séparés par des espaces, suivis d’un retour à la ligne. Utilisez des itérateurs (begin() et end()) pour parcourir le conteneur.

Créez une fonction appelée sortAndPrint qui prend un std::vector<int>&, le trie à l’aide de std::sort, puis affiche les éléments triés séparés par des espaces, suivis d’un retour à la ligne.

Créez une fonction appelée findElement qui prend un std::vector<int>& et une valeur de type int à rechercher. Utilisez std::find pour localiser l’élément. S’il est trouvé, affichez Found: <value>. S’il n’est pas trouvé, affichez Not found: <value>.

Créez une fonction appelée getSum qui prend un std::vector<int>& et renvoie la somme de tous les éléments. Vous pouvez utiliser une simple boucle avec des itérateurs pour cela.
main.cpp : lisez les entrées et montrez comment les composants de la STL fonctionnent ensemble.
Lisez cinq entrées (chacune sur une ligne distincte) :
1. Premier entier
2. Deuxième entier
3. Troisième entier
4. Quatrième entier
5. Une valeur à rechercher
Créez un std::vector<int> et ajoutez-y les quatre premiers entiers. Montrez ensuite la philosophie de la STL en :
1. affichant Original:, puis en appelant printVector
2. affichant Sorted:, puis en appelant sortAndPrint
3. appelant findElement avec la valeur recherchée
4. affichant Sum: <result> à l’aide de getSum

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: 16

Avec les entrées 10, 30, 20, 40 et 15 :

Original: 10 30 20 40 
Sorted: 10 20 30 40 
Not found: 15
Sum: 100

Remarquez comment vos fonctions travaillent avec le vecteur באמצעות des itérateurs, et comment std::sort et std::find opèrent sur tout 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 reliés uniquement par l’intermédiaire 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 de recherche
    
    // TODO: Afficher "Sum: " suivi du résultat de getSum
    
    return 0;
}