Travaux Dirigés 3 : La Généricité et les Templates en C++

/**
 * TD 3 - Exercice 1 : Patrons de Fonctions & Algorithmes Fondamentaux
 * Déduction de type, transmission par const ref, et détection des ambiguïtés en C++20.
 */
 
#include <iostream>
#include <string>
#include <vector>
 
// 1. Patron de fonction pour intervertir deux variables (swap)
template <typename T>
void echanger(T& a, T& b) {
    T temporaire = a;
    a = b;
    b = temporaire;
}
 
// 2. Patron de fonction renvoyant le maximum entre deux valeurs
// Transmission par référence constante pour éviter la recopie d'objets lourds
template <typename T>
const T& maximum(const T& a, const T& b) {
    return (a < b) ? b : a;
}
 
// 3. Patron à deux types distincts pour gérer des arguments hétérogènes
// 'auto' en type de retour laisse le compilateur déduire le type commun (C++14/C++20)
template <typename T1, typename T2>
auto maximumHeterogene(const T1& a, const T2& b) {
    return (a < b) ? b : a;
}
 
// 4. Algorithme générique de recherche séquentielle dans un tableau brut
// Renvoie l'indice de la première occurrence trouvée, ou -1 si absent
template <typename T>
int trouverIndice(const T tableau[], std::size_t taille, const T& cible) {
    for (std::size_t i = 0; i < taille; ++i) {
        if (tableau[i] == cible) {
            return static_cast<int>(i);
        }
    }
    return -1;
}
 
// 5. Affichage générique des éléments d'un tableau
template <typename T>
void afficherTableau(const T tableau[], std::size_t taille, const std::string& nom) {
    std::cout << nom << " : [ ";
    for (std::size_t i = 0; i < taille; ++i) {
        std::cout << tableau[i] << " ";
    }
    std::cout << "]\n";
}
 
int main() {
    std::cout << "=== TD 3 - Exercice 1 : Patrons de Fonctions (Templates) ===\n\n";
 
    // Test 1 : Échange générique
    std::cout << "--- 1. Test du patron echanger<T>() ---\n";
    int x = 42, y = 99;
    std::cout << "Avant échange entiers : x = " << x << ", y = " << y << "\n";
    echanger(x, y); // Déduction automatique : T = int
    std::cout << "Après échange entiers : x = " << x << ", y = " << y << "\n";
 
    std::string s1 = "Licence", s2 = "Informatique";
    std::cout << "Avant échange strings : s1 = \"" << s1 << "\", s2 = \"" << s2 << "\"\n";
    echanger(s1, s2); // Déduction automatique : T = std::string
    std::cout << "Après échange strings : s1 = \"" << s1 << "\", s2 = \"" << s2 << "\"\n";
 
    // Test 2 : Maximum homogène et résolution d'ambiguïté
    std::cout << "\n--- 2. Test du patron maximum<T>() & Ambiguïtés ---\n";
    std::cout << "Max entre 15 et 28      : " << maximum(15, 28) << "\n";
    std::cout << "Max entre 3.14 et 2.71  : " << maximum(3.14, 2.71) << "\n";
    std::cout << "Max entre 'A' et 'Z'    : " << maximum('A', 'Z') << "\n";
 
    // Appel ambigu si types différents : maximum(10, 20.5); // ❌ ERREUR COMPILATION
    // Levée de l'ambiguïté par spécification explicite du type entre chevrons :
    std::cout << "Max explicite <double>(10, 20.5) : " << maximum<double>(10, 20.5) << "\n";
 
    // Levée de l'ambiguïté par patron hétérogène :
    std::cout << "Max hétérogène (10, 20.5)        : " << maximumHeterogene(10, 20.5) << "\n";
 
    // Test 3 : Recherche séquentielle générique
    std::cout << "\n--- 3. Test de l'algorithme trouverIndice<T>() ---\n";
    int notes[] = {12, 17, 9, 14, 20, 15};
    afficherTableau(notes, 6, "Tableau de notes");
    std::cout << "Indice de la note 20 : " << trouverIndice(notes, 6, 20) << "\n";
    std::cout << "Indice de la note 18 : " << trouverIndice(notes, 6, 18) << " (absent)\n";
 
    std::string prenoms[] = {"Alice", "Bob", "Claire", "David"};
    afficherTableau(prenoms, 4, "Tableau de prénoms");
    std::cout << "Indice de \"Claire\" : " << trouverIndice(prenoms, 4, std::string("Claire")) << "\n";
    std::cout << "Indice de \"Eve\"    : " << trouverIndice(prenoms, 4, std::string("Eve")) << " (absent)\n";
 
    return 0;
}

/**
 * TD 3 - Exercice 2 : Patrons de Classes & Paramètres Non-Types (NTTP)
 * Implémentation d'un conteneur statique sécurisé alloué sur la pile en C++20.
 */
 
#include <iostream>
#include <string>
#include <stdexcept>
#include <numeric>
 
// Patron de classe avec un type T et une valeur constante N connue à la compilation
template <typename T, std::size_t N>
class TableauStatique {
    // Vérification statique : interdire la création d'un conteneur vide
    static_assert(N > 0, "La taille du TableauStatique doit être strictement positive !");
 
private:
    // Allocation directe sur la pile : zéro indirection, zéro fragmentation du tas
    T m_elements[N];
 
public:
    // Constructeur par défaut : initialise les éléments par défaut
    TableauStatique() : m_elements{} {}
 
    // Taille constante connue à la compilation (constexpr noexcept)
    constexpr std::size_t taille() const noexcept {
        return N;
    }
 
    // Accès indicé rapide sans contrôle des bornes (version modifiable)
    T& operator[](std::size_t index) noexcept {
        return m_elements[index];
    }
 
    // Accès indicé rapide (version constante en lecture seule)
    const T& operator[](std::size_t index) const noexcept {
        return m_elements[index];
    }
 
    // Accès indicé sécurisé avec contrôle strict des bornes
    T& at(std::size_t index) {
        if (index >= N) {
            throw std::out_of_range("Index hors limites : " + std::to_string(index) 
                                    + " >= taille (" + std::to_string(N) + ")");
        }
        return m_elements[index];
    }
 
    const T& at(std::size_t index) const {
        if (index >= N) {
            throw std::out_of_range("Index hors limites : " + std::to_string(index) 
                                    + " >= taille (" + std::to_string(N) + ")");
        }
        return m_elements[index];
    }
 
    // Remplit l'intégralité du conteneur avec une valeur donnée
    void remplir(const T& valeur) {
        for (std::size_t i = 0; i < N; ++i) {
            m_elements[i] = valeur;
        }
    }
 
    // Calcul de la somme : exige que le type T supporte operator+= et l'initialisation T{}
    T calculerSomme() const {
        T total{};
        for (std::size_t i = 0; i < N; ++i) {
            total += m_elements[i];
        }
        return total;
    }
 
    // Affichage des éléments
    void afficher(const std::string& nom) const {
        std::cout << nom << " [taille=" << N << ", " << sizeof(*this) << " octets sur la pile] : [ ";
        for (std::size_t i = 0; i < N; ++i) {
            std::cout << m_elements[i] << " ";
        }
        std::cout << "]\n";
    }
};
 
int main() {
    std::cout << "=== TD 3 - Exercice 2 : TableauStatique<T, N> (NTTP) ===\n\n";
 
    // 1. Tableau d'entiers de taille 5
    std::cout << "--- 1. Tableau d'entiers sur la pile (TableauStatique<int, 5>) ---\n";
    TableauStatique<int, 5> tabEntiers;
    for (std::size_t i = 0; i < tabEntiers.taille(); ++i) {
        tabEntiers[i] = static_cast<int>((i + 1) * 10);
    }
    tabEntiers.afficher("tabEntiers");
    std::cout << "Somme des entiers : " << tabEntiers.calculerSomme() << "\n";
 
    // 2. Tableau de chaînes de caractères de taille 3
    std::cout << "\n--- 2. Tableau de chaînes (TableauStatique<std::string, 3>) ---\n";
    TableauStatique<std::string, 3> tabMots;
    tabMots[0] = "Programmation";
    tabMots[1] = "Orientée";
    tabMots[2] = "Objet";
    tabMots.afficher("tabMots");
    std::cout << "Concaténation (calculerSomme) : \"" << tabMots.calculerSomme() << "\"\n";
 
    // 3. Démonstration de la méthode sécurisée at() et levée d'exception
    std::cout << "\n--- 3. Contrôle des bornes avec at() ---\n";
    try {
        std::cout << "Accès valide à l'index 2 : " << tabEntiers.at(2) << "\n";
        std::cout << "Tentative d'accès illégal à l'index 10...\n";
        tabEntiers.at(10) = 999; // Lève une exception
    } catch (const std::out_of_range& e) {
        std::cout << ">> Exception interceptée avec succès : " << e.what() << "\n";
    }
 
    // 4. Incompatibilité des types instanciés (Typage Statique Fort)
    TableauStatique<int, 10> autreTab;
    autreTab.remplir(7);
    std::cout << "\nautreTab (taille 10) rempli de 7 :\n";
    autreTab.afficher("autreTab");
 
    // L'instruction suivante refuserait de compiler :
    // tabEntiers = autreTab;
    // ❌ ERREUR COMPILATION : no match for 'operator=' between TableauStatique<int, 5> and TableauStatique<int, 10>
    std::cout << "\nRemarque : TableauStatique<int, 5> et TableauStatique<int, 10> sont\n"
              << "deux types distincts et étanches pour le compilateur.\n";
 
    return 0;
}

/**
 * TD 3 - Exercice 3 : Spécialisation de Patrons (Fonctions & Classes)
 * Résolution du piège des pointeurs C (const char*) et formatage spécialisé en C++20.
 */
 
#include <iostream>
#include <cstring>
#include <string>
#include <sstream>
#include <iomanip>
 
// =====================================================================
// PARTIE 1 : Patron de fonction et sa spécialisation pour const char*
// =====================================================================
 
// 1. Patron générique primaire
template <typename T>
T plusGrand(T a, T b) {
    return (a < b) ? b : a;
}
 
// 2. Spécialisation totale (Full Template Specialization) pour const char*
// Nécessaire car 'a < b' sur des pointeurs compare les adresses mémoire et non le texte !
template <>
const char* plusGrand<const char*>(const char* a, const char* b) {
    // Comparaison lexicographique via std::strcmp
    return (std::strcmp(a, b) < 0) ? b : a;
}
 
// =====================================================================
// PARTIE 2 : Patron de classe et spécialisations
// =====================================================================
 
// 1. Patron de classe primaire : Formateur générique
template <typename T>
class Formateur {
public:
    static std::string formater(const T& val) {
        std::ostringstream oss;
        oss << "[Générique: " << val << "]";
        return oss.str();
    }
};
 
// 2. Spécialisation totale pour le type 'bool'
template <>
class Formateur<bool> {
public:
    static std::string formater(const bool& val) {
        return val ? "[Booléen: VRAI (TRUE)]" : "[Booléen: FAUX (FALSE)]";
    }
};
 
// 3. Spécialisation partielle pour n'importe quel type de pointeur (U*)
template <typename U>
class Formateur<U*> {
public:
    static std::string formater(U* ptr) {
        if (ptr == nullptr) {
            return "[Pointeur: NULLPTR (0x0)]";
        }
        std::ostringstream oss;
        oss << "[Pointeur @" << static_cast<const void*>(ptr) 
            << " pointant vers: " << *ptr << "]";
        return oss.str();
    }
};
 
// 4. Spécialisation totale pour const char* (éviter de déférencer comme un simple char)
template <>
class Formateur<const char*> {
public:
    static std::string formater(const char* texte) {
        if (texte == nullptr) return "[Chaîne C: NULL]";
        return "[Chaîne C: \"" + std::string(texte) + "\"]";
    }
};
 
int main() {
    std::cout << "=== TD 3 - Exercice 3 : Spécialisation de Templates ===\n\n";
 
    // --- 1. Test du patron de fonction plusGrand ---
    std::cout << "--- 1. Patron de fonction : Problématique de const char* ---\n";
    int n1 = 100, n2 = 250;
    std::cout << "plusGrand(100, 250)         : " << plusGrand(n1, n2) << " (entiers standard)\n";
 
    double d1 = 3.1415, d2 = 2.7182;
    std::cout << "plusGrand(3.1415, 2.7182)   : " << plusGrand(d1, d2) << " (réels standard)\n";
 
    // Chaînes C littérales
    const char* mot1 = "zoo";
    const char* mot2 = "arbre";
 
    std::cout << "\nComparaison de deux chaînes C littérales (\"" << mot1 << "\" et \"" << mot2 << "\") :\n";
    std::cout << "Adresse de \"" << mot1 << "\" : " << static_cast<const void*>(mot1) << "\n";
    std::cout << "Adresse de \"" << mot2 << "\" : " << static_cast<const void*>(mot2) << "\n";
 
    // Grâce à la spécialisation template <>, c'est std::strcmp qui est appelé :
    const char* gagnant = plusGrand(mot1, mot2);
    std::cout << "Résultat lexicographique via spécialisation : \"" << gagnant << "\" (correct !)\n";
 
    // --- 2. Test du patron de classe Formateur ---
    std::cout << "\n--- 2. Patron de classe Formateur<T> et ses spécialisations ---\n";
 
    // Cas générique : entiers, réels, string
    std::cout << Formateur<int>::formater(42) << "\n";
    std::cout << Formateur<double>::formater(19.99) << "\n";
    std::cout << Formateur<std::string>::formater(std::string("C++20")) << "\n";
 
    // Cas spécialisé bool
    std::cout << Formateur<bool>::formater(true) << "\n";
    std::cout << Formateur<bool>::formater(false) << "\n";
 
    // Cas spécialisé pour les pointeurs
    int variable = 777;
    int* ptrVar = &variable;
    int* ptrNul = nullptr;
 
    std::cout << Formateur<int*>::formater(ptrVar) << "\n";
    std::cout << Formateur<int*>::formater(ptrNul) << "\n";
 
    // Cas spécialisé pour const char*
    std::cout << Formateur<const char*>::formater("Licence Professionnelle Informatique") << "\n";
 
    return 0;
}

/**
 * TD 3 - Exercice 4 : Conteneur Dynamique Générique & Règle des Trois
 * Implémentation complète d'un VecteurGenerique<T> auto-redimensionnable en C++20.
 */
 
#include <iostream>
#include <string>
#include <stdexcept>
#include <algorithm>
 
template <typename T>
class VecteurGenerique {
private:
    T* m_donnees;
    std::size_t m_taille;
    std::size_t m_capacite;
 
public:
    // 1. Constructeur par défaut (allocation minimale)
    explicit VecteurGenerique(std::size_t capaciteInitiale = 2)
        : m_donnees(capaciteInitiale > 0 ? new T[capaciteInitiale] : nullptr),
          m_taille(0),
          m_capacite(capaciteInitiale) {
        std::cout << "  [+] VecteurGenerique(@" << this << ") alloué (capacité: " 
                  << m_capacite << ")\n";
    }
 
    // 2. Destructeur (Pilier 1 de la Règle des Trois)
    ~VecteurGenerique() {
        std::cout << "  [-] ~VecteurGenerique(@" << this << ") libération mémoire tas @" 
                  << static_cast<void*>(m_donnees) << "\n";
        delete[] m_donnees;
    }
 
    // 3. Constructeur par recopie profonde (Pilier 2 de la Règle des Trois)
    VecteurGenerique(const VecteurGenerique<T>& source)
        : m_donnees(source.m_capacite > 0 ? new T[source.m_capacite] : nullptr),
          m_taille(source.m_taille),
          m_capacite(source.m_capacite) {
        for (std::size_t i = 0; i < m_taille; ++i) {
            m_donnees[i] = source.m_donnees[i]; // Recopie de chaque élément T
        }
        std::cout << "  [C] VecteurGenerique COPIÉ depuis @" << &source 
                  << " vers @" << this << " (taille: " << m_taille << ")\n";
    }
 
    // 4. Opérateur d'affectation sécurisé (Pilier 3 de la Règle des Trois)
    VecteurGenerique<T>& operator=(const VecteurGenerique<T>& source) {
        // Protection vitale contre l'auto-affectation (v = v)
        if (this == &source) {
            std::cout << "  [=] Auto-affectation détectée sur @" << this << ", ignorée.\n";
            return *this;
        }
 
        // Allocation préalable du nouveau tampon (sécurité aux exceptions)
        T* nouveauTampon = source.m_capacite > 0 ? new T[source.m_capacite] : nullptr;
        for (std::size_t i = 0; i < source.m_taille; ++i) {
            nouveauTampon[i] = source.m_donnees[i];
        }
 
        // Libération de l'ancienne mémoire
        delete[] m_donnees;
 
        // Mise à jour des métadonnées
        m_donnees = nouveauTampon;
        m_taille = source.m_taille;
        m_capacite = source.m_capacite;
 
        std::cout << "  [=] VecteurGenerique AFFECTÉ depuis @" << &source << " vers @" << this << "\n";
        return *this;
    }
 
    // Redimensionnement automatique (stratégie géométrique par doublement)
    void reserver(std::size_t nouvelleCapacite) {
        if (nouvelleCapacite <= m_capacite) return;
 
        T* nouveauTampon = new T[nouvelleCapacite];
        for (std::size_t i = 0; i < m_taille; ++i) {
            nouveauTampon[i] = m_donnees[i];
        }
 
        delete[] m_donnees;
        m_donnees = nouveauTampon;
        m_capacite = nouvelleCapacite;
        std::cout << "      -> Réallocation dynamique (@" << this << ") : capacité portée à " 
                  << m_capacite << "\n";
    }
 
    // Ajout d'un élément en fin de conteneur
    void push_back(const T& valeur) {
        if (m_taille == m_capacite) {
            reserver(m_capacite == 0 ? 2 : m_capacite * 2);
        }
        m_donnees[m_taille++] = valeur;
    }
 
    // Retrait du dernier élément
    void pop_back() {
        if (m_taille == 0) {
            throw std::underflow_error("Impossible de faire pop_back() sur un vecteur vide !");
        }
        --m_taille;
    }
 
    // Accesseurs
    std::size_t getTaille() const noexcept { return m_taille; }
    std::size_t getCapacite() const noexcept { return m_capacite; }
    bool estVide() const noexcept { return m_taille == 0; }
 
    // Accès aux éléments
    T& operator[](std::size_t index) noexcept { return m_donnees[index]; }
    const T& operator[](std::size_t index) const noexcept { return m_donnees[index]; }
 
    T& at(std::size_t index) {
        if (index >= m_taille) {
            throw std::out_of_range("Index hors limites (" + std::to_string(index) 
                                    + " >= " + std::to_string(m_taille) + ")");
        }
        return m_donnees[index];
    }
 
    const T& at(std::size_t index) const {
        if (index >= m_taille) {
            throw std::out_of_range("Index hors limites (" + std::to_string(index) 
                                    + " >= " + std::to_string(m_taille) + ")");
        }
        return m_donnees[index];
    }
 
    void afficher(const std::string& nom) const {
        std::cout << nom << " [taille=" << m_taille << ", cap=" << m_capacite << "] : [ ";
        for (std::size_t i = 0; i < m_taille; ++i) {
            std::cout << m_donnees[i] << " ";
        }
        std::cout << "]\n";
    }
};
 
int main() {
    std::cout << "=== TD 3 - Exercice 4 : VecteurGenerique<T> & Règle des Trois ===\n\n";
 
    std::cout << "--- 1. Utilisation avec des entiers et redimensionnement dynamique ---\n";
    {
        VecteurGenerique<int> v(2);
        v.push_back(10);
        v.push_back(20);
        v.afficher("v après 2 ajouts");
 
        std::cout << "Ajout d'un 3ème élément (déclenche réallocation) :\n";
        v.push_back(30);
        v.afficher("v après 3ème ajout");
 
        v.push_back(40);
        v.push_back(50);
        v.afficher("v après 5 ajouts");
 
        std::cout << "\n--- 2. Test du Constructeur de Recopie (copie profonde) ---\n";
        VecteurGenerique<int> copie = v;
        copie.afficher("copie");
 
        std::cout << "Modification de copie[0] = 999...\n";
        copie[0] = 999;
        std::cout << "copie[0] = " << copie[0] << " | original v[0] = " << v[0] 
                  << " (indépendance mémoire vérifiée !)\n";
 
        std::cout << "\n--- 3. Test de l'Affectation et de l'Auto-affectation ---\n";
        VecteurGenerique<int> autre(1);
        autre = v;
        autre.afficher("autre après affectation");
 
        std::cout << "Test critique autre = autre :\n";
        autre = autre;
        autre.afficher("autre après auto-affectation");
 
        std::cout << "\nSortie de bloc (destructions automatiques RAII) :\n";
    }
 
    std::cout << "\n--- 4. Utilisation avec des chaînes de caractères (std::string) ---\n";
    {
        VecteurGenerique<std::string> mots;
        mots.push_back("C++");
        mots.push_back("Templates");
        mots.push_back("Généricité");
        mots.push_back("RAII");
        mots.afficher("mots");
    }
 
    return 0;
}

/**
 * TD 3 - Exercice 5 : Structure de Données Chaînée Générique
 * Conception intégrale d'une File<T> (Queue FIFO) en C++20 avec Règle des Trois.
 */
 
#include <iostream>
#include <string>
#include <stdexcept>
 
template <typename T>
class FileGenerique {
private:
    // Structure interne représentant un maillon de la liste chaînée
    struct Noeud {
        T donnee;
        Noeud* suivant;
 
        Noeud(const T& val) : donnee(val), suivant(nullptr) {}
    };
 
    Noeud* m_tete;        // Pointeur vers le premier élément à sortir (Tête / Front)
    Noeud* m_queue;       // Pointeur vers le dernier élément entré (Queue / Back)
    std::size_t m_taille; // Nombre d'éléments présents dans la file
 
public:
    // 1. Constructeur par défaut (file initialement vide)
    FileGenerique() : m_tete(nullptr), m_queue(nullptr), m_taille(0) {
        std::cout << "  [+] FileGenerique(@" << this << ") initialisée vide\n";
    }
 
    // 2. Destructeur (libération de tous les nœuds chaînés)
    ~FileGenerique() {
        std::cout << "  [-] ~FileGenerique(@" << this << ") destruction de " 
                  << m_taille << " nœud(s)...\n";
        vider();
    }
 
    // 3. Constructeur par recopie (copie profonde de la liste chaînée)
    FileGenerique(const FileGenerique<T>& source)
        : m_tete(nullptr), m_queue(nullptr), m_taille(0) {
        Noeud* courant = source.m_tete;
        while (courant != nullptr) {
            enfiler(courant->donnee); // Reconstruit fidèlement les nœuds dans l'ordre FIFO
            courant = courant->suivant;
        }
        std::cout << "  [C] FileGenerique COPIÉE depuis @" << &source 
                  << " vers @" << this << " (" << m_taille << " éléments)\n";
    }
 
    // 4. Opérateur d'affectation sécurisé
    FileGenerique<T>& operator=(const FileGenerique<T>& source) {
        if (this == &source) {
            std::cout << "  [=] Auto-affectation détectée sur @" << this << ", ignorée.\n";
            return *this;
        }
 
        // Nettoyer les éléments actuels
        vider();
 
        // Dupliquer les nœuds de la source
        Noeud* courant = source.m_tete;
        while (courant != nullptr) {
            enfiler(courant->donnee);
            courant = courant->suivant;
        }
 
        std::cout << "  [=] FileGenerique AFFECTÉE depuis @" << &source 
                  << " vers @" << this << "\n";
        return *this;
    }
 
    // Vide complètement la file et désalloue les nœuds
    void vider() {
        while (m_tete != nullptr) {
            Noeud* aSupprimer = m_tete;
            m_tete = m_tete->suivant;
            delete aSupprimer;
        }
        m_queue = nullptr;
        m_taille = 0;
    }
 
    // Enfile un élément en queue de file (Complexité O(1))
    void enfiler(const T& valeur) {
        Noeud* nouveau = new Noeud(valeur);
        if (estVide()) {
            m_tete = nouveau;
            m_queue = nouveau;
        } else {
            m_queue->suivant = nouveau;
            m_queue = nouveau;
        }
        ++m_taille;
    }
 
    // Défile et renvoie le premier élément en tête de file (Complexité O(1))
    T defiler() {
        if (estVide()) {
            throw std::underflow_error("Erreur : Impossible de défiler une file vide !");
        }
 
        Noeud* ancien = m_tete;
        T valeurSortie = ancien->donnee;
 
        m_tete = m_tete->suivant;
        if (m_tete == nullptr) {
            m_queue = nullptr; // La file est devenue complètement vide
        }
 
        delete ancien;
        --m_taille;
        return valeurSortie;
    }
 
    // Consultation du premier élément sans le retirer
    const T& premier() const {
        if (estVide()) {
            throw std::underflow_error("File vide : aucun élément en tête !");
        }
        return m_tete->donnee;
    }
 
    bool estVide() const noexcept {
        return m_tete == nullptr;
    }
 
    std::size_t getTaille() const noexcept {
        return m_taille;
    }
 
    // Affichage de la file du premier sorti vers le dernier entré
    void afficher(const std::string& nom) const {
        std::cout << nom << " [taille=" << m_taille << "] (Tête -> Queue) : [ ";
        Noeud* courant = m_tete;
        while (courant != nullptr) {
            std::cout << courant->donnee;
            if (courant->suivant != nullptr) std::cout << " -> ";
            courant = courant->suivant;
        }
        std::cout << " ]\n";
    }
};
 
int main() {
    std::cout << "=== TD 3 - Exercice 5 : FileGenerique<T> (Queue FIFO Chaînée) ===\n\n";
 
    std::cout << "--- 1. File de tâches d'impression (std::string) ---\n";
    {
        FileGenerique<std::string> spooler;
        spooler.enfiler("Doc_Compta.pdf");
        spooler.enfiler("Rapport_Stage.docx");
        spooler.enfiler("Photo_Identite.png");
 
        spooler.afficher("Spooler d'impression");
        std::cout << "Prochain document à imprimer : \"" << spooler.premier() << "\"\n\n";
 
        std::cout << "Traitement (défilement FIFO) :\n";
        std::cout << "-> Impression en cours : " << spooler.defiler() << "\n";
        std::cout << "-> Impression en cours : " << spooler.defiler() << "\n";
        spooler.afficher("Spooler restant");
 
        std::cout << "\nAjout d'une nouvelle tâche urgente :\n";
        spooler.enfiler("Facture_Client.pdf");
        spooler.afficher("Spooler mis à jour");
 
        std::cout << "\n--- 2. Test du Constructeur de Recopie (indépendance des listes) ---\n";
        FileGenerique<std::string> copieSpooler = spooler;
        copieSpooler.afficher("Copie du spooler");
 
        std::cout << "Défilement sur la copie : " << copieSpooler.defiler() << "\n";
        copieSpooler.afficher("Copie après défilement");
        spooler.afficher("Original (intact !)");
 
        std::cout << "\n--- 3. Affectation et Auto-affectation ---\n";
        FileGenerique<std::string> autre;
        autre = spooler;
        autre.afficher("Autre après affectation");
 
        autre = autre; // Test auto-affectation
        autre.afficher("Autre après auto-affectation");
 
        std::cout << "\nSortie de bloc : libération mémoire nœud par nœud...\n";
    }
 
    std::cout << "\n--- 4. File d'entiers & Gestion des Exceptions ---\n";
    {
        FileGenerique<int> fileEntiers;
        fileEntiers.enfiler(100);
        fileEntiers.enfiler(200);
 
        std::cout << "Élément retiré : " << fileEntiers.defiler() << "\n";
        std::cout << "Élément retiré : " << fileEntiers.defiler() << "\n";
 
        try {
            std::cout << "Tentative de défiler une file vide...\n";
            fileEntiers.defiler(); // Lève underflow_error
        } catch (const std::underflow_error& e) {
            std::cout << ">> Exception interceptée avec succès : " << e.what() << "\n";
        }
    }
 
    return 0;
}