Chapitre 3 : La Généricité et les Templates en C++

#include <iostream>
#include <string>
 
// 1. Définition du patron de fonction echanger
template <typename T>
void echanger(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}
 
// 2. Définition du patron de fonction minimum
template <typename T>
T minimum(const T& a, const T& b) {
    return (a < b) ? a : b;
}
 
int main() {
    // Utilisation avec des entiers (int)
    int n1 = 10, n2 = 25;
    echanger(n1, n2); // Déduction automatique : T = int
    std::cout << "Min(10, 25) = " << minimum(n1, n2) << std::endl;
 
    // Utilisation avec des chaînes (std::string)
    std::string s1 = "Zèbre", s2 = "Antilope";
    echanger(s1, s2); // Déduction automatique : T = std::string
    std::cout << "Min alphabétique = " << minimum(s1, s2) << std::endl;
 
    // Spécification explicite du type si nécessaire
    double d = minimum<double>(5.5, 12);
    std::cout << "Min double = " << d << std::endl;
 
    return 0;
}

template <typename T1, typename T2>
void afficherPaire(const T1& premier, const T2& second) {
    std::cout << "(" << premier << " : " << second << ")\n";
}
 
// Utilisation :
afficherPaire("Note", 18.5); // T1 = const char*, T2 = double

#ifndef PAIRE_HPP
#define PAIRE_HPP
 
template <typename T1, typename T2>
class Paire {
private:
    T1 m_premier;
    T2 m_second;
 
public:
    Paire(const T1& p, const T2& s)
        : m_premier(p), m_second(s) {}
 
    T1 getPremier() const { return m_premier; }
    T2 getSecond()  const { return m_second; }
 
    void setPremier(const T1& val) { m_premier = val; }
    void setSecond(const T2& val)  { m_second = val; }
};
 
#endif // PAIRE_HPP

#ifndef PILE_HPP
#define PILE_HPP
 
#include <iostream>
#include <stdexcept>
 
template <typename T>
class Pile {
private:
    T*     m_elements;   // Tableau dynamique d'éléments de type T
    size_t m_capacite;   // Capacité maximale allouée
    size_t m_sommet;     // Nombre d'éléments empilés
 
    void redimensionner(size_t nouvelleCapacite) {
        T* nouv = new T[nouvelleCapacite];
        for (size_t i = 0; i < m_sommet; ++i) {
            nouv[i] = m_elements[i];
        }
        delete[] m_elements;
        m_elements = nouv;
        m_capacite = nouvelleCapacite;
    }
 
public:
    // 1. Constructeur usuel
    explicit Pile(size_t capaciteInitiale = 4)
        : m_elements(new T[capaciteInitiale]), m_capacite(capaciteInitiale), m_sommet(0) {}
 
    // 2. Destructeur
    ~Pile() {
        delete[] m_elements;
    }
 
    // 3. Constructeur par recopie (Copie profonde générique)
    Pile(const Pile<T>& autre)
        : m_elements(new T[autre.m_capacite]), m_capacite(autre.m_capacite), m_sommet(autre.m_sommet) {
        for (size_t i = 0; i < m_sommet; ++i) {
            m_elements[i] = autre.m_elements[i];
        }
    }
 
    // 4. Opérateur d'affectation
    Pile<T>& operator=(const Pile<T>& autre) {
        if (this != &autre) {
            delete[] m_elements;
            m_capacite = autre.m_capacite;
            m_sommet = autre.m_sommet;
            m_elements = new T[m_capacite];
            for (size_t i = 0; i < m_sommet; ++i) {
                m_elements[i] = autre.m_elements[i];
            }
        }
        return *this;
    }
 
    // Méthodes de manipulation de la pile
    void empiler(const T& element) {
        if (m_sommet == m_capacite) {
            redimensionner(m_capacite * 2);
        }
        m_elements[m_sommet++] = element;
    }
 
    T depiler() {
        if (estVide()) {
            throw std::underflow_error("Impossible de dépiler : la pile est vide !");
        }
        return m_elements[--m_sommet];
    }
 
    const T& sommet() const {
        if (estVide()) {
            throw std::underflow_error("Pile vide !");
        }
        return m_elements[m_sommet - 1];
    }
 
    bool estVide() const { return m_sommet == 0; }
    size_t taille() const { return m_sommet; }
};
 
#endif // PILE_HPP

#ifndef TABLEAUFIXE_HPP
#define TABLEAUFIXE_HPP
 
#include <cstddef>
#include <stdexcept>
 
template <typename T, size_t N>
class TableauFixe {
private:
    T m_donnees[N]; // Tableau statique alloué sur la pile (stack)
 
public:
    size_t capacite() const { return N; }
    size_t taille() const { return N; }
 
    T& operator[](size_t index) {
        return m_donnees[index];
    }
 
    const T& operator[](size_t index) const {
        return m_donnees[index];
    }
 
    T& at(size_t index) {
        if (index >= N) {
            throw std::out_of_range("Index hors limites !");
        }
        return m_donnees[index];
    }
};
 
#endif // TABLEAUFIXE_HPP