Chapitre 4 : La STL (Standard Template Library) — Flux, Conteneurs et Algorithmes

/**
 * Chapitre 4 - Exemple 1 : Les Flux Standards en C++ (std::cout, std::cerr)
 * Différence entre flux standard bufferisé et flux d'erreur immédiat
 */
 
#include <iostream>
#include <string>
 
int main() {
    std::cout << "=== Les Flux d'Entrée / Sortie en C++ ===\n\n";
 
    // 1. std::cout : Flux de sortie standard (standard output stream)
    // Il est bufferisé : les caractères sont stockés en mémoire tampon avant d'être émis
    std::cout << "[INFO] Bienvenue dans le programme d'initiation à la STL.\n";
    std::cout << "[INFO] std::cout est utilisé pour les résultats nominaux et les messages réguliers.\n";
 
    int valeur = 42;
    double temperature = 21.5;
    std::string module = "Licence 3 Pro Dev Web";
 
    // Chaînage naturel avec l'opérateur d'insertion <<
    std::cout << "Module : " << module 
              << " | Variable = " << valeur 
              << " | Température = " << temperature << " °C\n\n";
 
    // 2. std::cerr : Flux d'erreur standard (standard error stream)
    // Il n'est PAS bufferisé (unbuffered) : chaque caractère est envoyé immédiatement au terminal.
    // Idéal pour les messages d'alerte, diagnostics et exceptions.
    std::cerr << "[ERREUR std::cerr] Exemple d'alerte critique : fichier de configuration introuvable !\n";
    std::cerr << "[ATTENTION std::cerr] Ce message s'affiche immédiatement sans attendre le vidage du tampon.\n\n";
 
    // 3. std::endl vs '\n'
    // std::endl ajoute un saut de ligne ET force le vidage physique du tampon (flush).
    // '\n' est beaucoup plus rapide lors de boucles répétitives.
    std::cout << "Ligne avec vidage explicite du tampon." << std::endl;
 
    return 0;
}

/**
 * Chapitre 4 - Exemple 2 : Le Conteneur Séquentiel std::vector
 * Tableau dynamique redimensionnable de la STL
 */
 
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
 
int main() {
    std::cout << "=== Le Conteneur Dynamique std::vector ===\n\n";
 
    // 1. Déclaration et initialisation
    std::vector<int> nombres = {10, 20, 30, 40};
 
    std::cout << "Taille initiale : " << nombres.size() << " éléments.\n";
 
    // 2. Ajout dynamique en fin de vecteur avec push_back()
    std::cout << "Ajout de 50 et 60...\n";
    nombres.push_back(50);
    nombres.push_back(60);
 
    std::cout << "Nouvelle taille : " << nombres.size() 
              << " | Capacité allouée : " << nombres.capacity() << "\n";
 
    // 3. Parcours moderne par référence constante (Range-based for)
    std::cout << "Contenu du vecteur : [ ";
    for (const auto& x : nombres) {
        std::cout << x << " ";
    }
    std::cout << "]\n\n";
 
    // 4. Accès indicé : operator[] vs méthode sécurisée at()
    std::cout << "Premier élément (front) : " << nombres.front() << "\n";
    std::cout << "Dernier élément (back)   : " << nombres.back() << "\n";
    std::cout << "Élément à l'indice 2     : " << nombres[2] << "\n";
 
    try {
        std::cout << "Tentative d'accès sécurisé à l'indice 10 avec at()...\n";
        int valeurInvalide = nombres.at(10); // Lève une exception std::out_of_range
        std::cout << "Valeur : " << valeurInvalide << "\n";
    } catch (const std::out_of_range& e) {
        std::cerr << ">> [Exception interceptée] " << e.what() << "\n";
    }
 
    // 5. Retrait du dernier élément avec pop_back()
    std::cout << "\nRetrait du dernier élément avec pop_back()...\n";
    nombres.pop_back();
 
    std::cout << "Contenu final : [ ";
    for (const auto& x : nombres) {
        std::cout << x << " ";
    }
    std::cout << "] (taille = " << nombres.size() << ")\n";
 
    return 0;
}

/**
 * Chapitre 4 - Exemple 3 : Le Conteneur Associatif std::set
 * Ensemble ordonné d'éléments uniques (Arbre Rouge-Noir sous-jacent)
 */
 
#include <iostream>
#include <set>
#include <string>
 
int main() {
    std::cout << "=== L'Ensemble Ordonné std::set ===\n\n";
 
    // 1. Déclaration : un ensemble de chaînes de caractères
    // Les éléments sont automatiquement triés et TOUT DOUBLON EST REJETÉ !
    std::set<std::string> prenoms;
 
    // 2. Insertion d'éléments avec insert()
    prenoms.insert("Charlie");
    prenoms.insert("Alice");
    prenoms.insert("Bob");
    prenoms.insert("David");
 
    // Tentative d'insertion d'un doublon
    auto resultat = prenoms.insert("Alice");
    if (!resultat.second) {
        std::cout << "[INFO] \"Alice\" existe déjà dans le set : doublon ignoré !\n";
    }
 
    // 3. Parcours : les éléments apparaissent toujours par ordre alphabétique / croissant
    std::cout << "\nContenu du set (trié automatiquement) : { ";
    for (const auto& nom : prenoms) {
        std::cout << "\"" << nom << "\" ";
    }
    std::cout << "} (taille = " << prenoms.size() << ")\n\n";
 
    // 4. Recherche efficace en O(log N)
    // En C++20, la méthode .contains() vérifie la présence en une ligne très lisible :
    std::string recherche = "Bob";
    if (prenoms.contains(recherche)) {
        std::cout << ">> \"" << recherche << "\" est bien présent dans l'ensemble.\n";
    } else {
        std::cout << ">> \"" << recherche << "\" est absent.\n";
    }
 
    // 5. Suppression d'un élément
    std::cout << "\nSuppression de \"David\"...\n";
    prenoms.erase("David");
 
    std::cout << "Contenu après suppression : { ";
    for (const auto& nom : prenoms) {
        std::cout << "\"" << nom << "\" ";
    }
    std::cout << "}\n";
 
    return 0;
}

/**
 * Chapitre 4 - Exemple 4 : Le Tableau Associatif std::map
 * Dictionnaire Clé-Valeur ordonné (Arbre Binaire Équilibré)
 */
 
#include <iostream>
#include <map>
#include <string>
 
int main() {
    std::cout << "=== Le Dictionnaire Associatif std::map ===\n\n";
 
    // 1. Déclaration : Clé = string (nom du fruit), Valeur = double (prix au kilo)
    std::map<std::string, double> catalogue;
 
    // 2. Insertion avec l'opérateur crochet []
    catalogue["Pomme"] = 2.40;
    catalogue["Banane"] = 1.90;
    catalogue["Orange"] = 2.80;
    catalogue["Fraise"] = 5.50;
 
    // 3. Parcours moderne avec décomposition structurée (Structured Binding C++17/C++20)
    std::cout << "Catalogue des prix (trié automatiquement par clé) :\n";
    for (const auto& [fruit, prix] : catalogue) {
        std::cout << "  • " << fruit << " : " << prix << " € / kg\n";
    }
 
    // 4. Recherche sécurisée en C++20 sans créer de fausse entrée
    std::cout << "\nRecherche d'articles :\n";
    std::string recherche = "Cerise";
 
    if (catalogue.contains(recherche)) {
        std::cout << ">> " << recherche << " coûte " << catalogue[recherche] << " €\n";
    } else {
        std::cout << ">> " << recherche << " n'est pas au catalogue.\n";
    }
 
    // 5. ⚠️ Piège classique de l'operator[] :
    // Si la clé n'existe pas, l'opérateur [] L'INSÈRE avec sa valeur par défaut (ici 0.0) !
    std::cout << "\nAppel de catalogue[\"Kiwi\"] sans assignation préalable :\n";
    double prixKiwi = catalogue["Kiwi"]; // Insère silencieusement "Kiwi" avec la valeur 0.0 !
    std::cout << "Prix retourné pour Kiwi : " << prixKiwi << " €\n";
 
    std::cout << "\nVérification : Le catalogue contient maintenant Kiwi !\n";
    for (const auto& [fruit, prix] : catalogue) {
        std::cout << "  • " << fruit << " : " << prix << " € / kg\n";
    }
 
    return 0;
}

/**
 * Chapitre 4 - Exemple 5 : Les Algorithmes de la STL (<algorithm>)
 * Mise en œuvre de sort, reverse, count et count_if avec expressions lambda
 */
 
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
 
// Fonction utilitaire d'affichage
void afficher(const std::vector<int>& v, const std::string& message) {
    std::cout << message << " : [ ";
    for (int x : v) {
        std::cout << x << " ";
    }
    std::cout << "]\n";
}
 
int main() {
    std::cout << "=== Les Algorithmes Fondamentaux de la STL ===\n\n";
 
    std::vector<int> notes = {12, 5, 18, 12, 9, 14, 12, 20, 7};
    afficher(notes, "Notes initiales");
 
    // 1. std::sort : Tri croissant en O(N log N) (IntroSort)
    std::cout << "\n--- 1. std::sort (Tri dans l'ordre croissant) ---\n";
    std::sort(notes.begin(), notes.end());
    afficher(notes, "Après std::sort");
 
    // 2. std::reverse : Inversion en place des éléments
    std::cout << "\n--- 2. std::reverse (Inversion du vecteur) ---\n";
    std::reverse(notes.begin(), notes.end());
    afficher(notes, "Après std::reverse (ordre décroissant)");
 
    // 3. std::count : Comptage des occurrences exactes d'une valeur
    std::cout << "\n--- 3. std::count (Comptage de valeurs exactes) ---\n";
    int cible = 12;
    auto nbDouze = std::count(notes.begin(), notes.end(), cible);
    std::cout << "Nombre de fois où la note " << cible << " apparaît : " << nbDouze << "\n";
 
    int absente = 15;
    std::cout << "Nombre de fois où la note " << absente << " apparaît : " 
              << std::count(notes.begin(), notes.end(), absente) << "\n";
 
    // 4. std::count_if : Comptage selon un prédicat (Fonction Lambda)
    std::cout << "\n--- 4. std::count_if (Comptage conditionnel avec Lambda) ---\n";
 
    // Prédicat 1 : Notes supérieures ou égales à 10 (la moyenne)
    auto nbMoyenne = std::count_if(notes.begin(), notes.end(), [](int n) {
        return n >= 10;
    });
    std::cout << "Nombre d'étudiants ayant la moyenne (>= 10) : " << nbMoyenne << "\n";
 
    // Prédicat 2 : Nombres pairs
    auto nbPairs = std::count_if(notes.begin(), notes.end(), [](int n) {
        return n % 2 == 0;
    });
    std::cout << "Nombre de notes paires : " << nbPairs << "\n";
 
    return 0;
}