La Standard Template Library (STL) est une composante logicielle essentielle du langage C++. Elle fournit un ensemble de structures de données et d'algorithmes génériques hautement optimisés. L'architecture de la STL repose sur plusieurs piliers fondamentaux :

• Conteneurs : Structures de données pour stocker des objets.
• Itérateurs : Ponts entre les conteneurs et les algorithmes.
• Algorithmes : Procédures de traitement (tri, recherche, etc.).
• Adapteurs : Modification de l'interface d'un conteneur (piles, files).
• Foncteurs (Objets focntions) : Classes surchargeant l'opérateur d'appel.

1. Le conteneur dynamique : std::vector

Le std::vector est probablement le conteneur le plus utilisé. Il s'agit d'un tableau dynamique capable de se redimensionner automatiquement lors de l'ajout d'éléments. Contrairement aux tableaux statiques, sa taille n'a pas besoin d'être connue à la compilation.

Définition et initialisation

#include <vector>
#include <string>

// Déclaration d'un vecteur d'entiers
std::vector<int> liste_id;

// Vecteur de vecteurs (matrice dynamique)
std::vector<std::vector<float>> matrice;

Accès et manipulation des données

On peut accéder aux éléments via l'opérateur d'indexation ou via des itérateurs pour une approche plus générique.

#include <iostream>
#include <vector>

int main() {
   std::vector<int> donnees;
   
   // Ajout d'éléments
   for(int i = 1; i <= 5; ++i) {
       donnees.push_back(i * 10);
   }

   // Accès par index
   std::cout << "Premier élément : " << donnees[0] << std::endl;

   // Parcours via itérateur moderne (C++11+)
   for(auto it = donnees.begin(); it != donnees.end(); ++it) {
       std::cout << *it << " ";
   }

   return 0;
}

2. Gestion des chaînes de caractères : std::string

La classe std::string simplifie radicalement la manipulation du texte par rapport aux tableaux de char du langage C. Elle gère automatiquement la mémoire et propose de nombreuses méthodes utilitaires.

Exemple d'utilisation pratique

#include <iostream>
#include <string>

int main() {
   std::string message = "Initialisation";
   
   // Modification de caractères
   message[0] = 'i';
   
   // Concaténation simple
   std::string suffixe = " terminée";
   std::string complet = message + suffixe;

   std::cout << "Texte : " << complet << " (Taille : " << complet.size() << ")" << std::endl;

   return 0;
}

3. Conteneurs associatifs : std::set

Le std::set est un conteneur qui stocke des éléments uniques selon un ordre spécifique (généralement croissant). Il est idéal pour éliminer les doublons ou vérifier l'existence d'une valeur avec une complexité logarithmique.

Propriétés et syntaxe

L'insertion dans un set garantit que l'élément n'existe pas déjà. Si vous tentez d'insérer une valeur déjà présente, l'opération est ignorée.

#include <iostream>
#include <set>

int main() {
   std::set<int> ensemble_points;

   // Insertion de valeurs dans le désordre
   ensemble_points.insert(42);
   ensemble_points.insert(10);
   ensemble_points.insert(42); // Doublon, sera ignoré
   ensemble_points.insert(5);

   // Le parcours sera automatiquement ordonné : 5, 10, 42
   for (std::set<int>::iterator it = ensemble_points.begin(); it != ensemble_points.end(); ++it) {
       std::cout << *it << " ";
   }

   // Recherche d'un élément
   auto position = ensemble_points.find(10);
   if (position != ensemble_points.end()) {
       std::cout << "\nValeur 10 trouvée.";
   }

   return 0;
}

Points clés à retenir

• Performance : Les vecteurs sont optimisés pour l'accès aléatoire et l'ajout en fin de structure.
• Unicité : Utilisez std::set lorsque vous devez maintenir une collection de valeurs uniques et triées.
• Abstraction : Les itérateurs permettent d'écrire du code indépendant du type de conteneur utilisé.