//Partie 1 : Fonctions Templates
// Exercice 1 : Fonction maximum

#include <iostream>
#include <string>
using namespace std;

template <typename T>
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << maximum(5, 10) << endl;
    cout << maximum(3.14, 7.8) << endl;
    cout << maximum('a', 'z') << endl;
    cout << maximum(string("Ali"), string("Zara")) << endl;
}


//Exercice 2 : Fonction echanger

template <typename T>
void echanger(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}
//Test :

int x = 5, y = 10;
echanger(x, y);

double d1 = 3.5, d2 = 7.2;
echanger(d1, d2);
//Exercice 3 : Fonction addition (deux types)

template <typename T, typename U>
auto addition(T a, U b) {
    return a + b;
}
//Test :
cout << addition(5, 2.5) << endl;   // 7.5
cout << addition(10, 3) << endl;    // 13

//Partie 2 : Classes Templates
// Exercice 4 : Classe Boite<T>

template <typename T>
class Boite {
private:
    T valeur;

public:
    Boite(T v) : valeur(v) {}

    T getValeur() const {
        return valeur;
    }

    void setValeur(T v) {
        valeur = v;
    }

    void afficher() const {
        cout << "Valeur : " << valeur << endl;
    }
};

//Test :

Boite<int> b1(10);
Boite<double> b2(3.14);
Boite<string> b3("Bonjour");

b1.afficher();
b2.afficher();
b3.afficher();

//Exercice 5 : Classe Pile<T>

template <typename T>
class Pile {
private:
    T* data;
    int sommet;
    int capacite;

public:
    Pile(int cap) : capacite(cap), sommet(-1) {
        data = new T[capacite];
    }

    ~Pile() {
        delete[] data;
    }

    bool isEmpty() const {
        return sommet == -1;
    }

    bool isFull() const {
        return sommet == capacite - 1;
    }

    void push(T valeur) {
        if (isFull()) {
            cout << "Pile pleine !" << endl;
            return;
        }
        data[++sommet] = valeur;
    }

    T pop() {
        if (isEmpty()) {
            cout << "Pile vide !" << endl;
            throw runtime_error("Erreur : pile vide");
        }
        return data[sommet--];
    }

    void afficher() const {
        for (int i = 0; i <= sommet; i++)
            cout << data[i] << " ";
        cout << endl;
    }
};


// Test :
Pile<int> p(5);
p.push(10);
p.push(20);
p.afficher();

//Partie 3 : Spécialisation de Template
//Spécialisation pour char*

//Objectif : éviter la copie superficielle.

#include <cstring>

template <>
class Boite<char*> {
private:
    char* valeur;

public:
    Boite(const char* v) {
        valeur = new char[strlen(v) + 1];
        strcpy(valeur, v);
    }

    ~Boite() {
        delete[] valeur;
    }

    void afficher() const {
        cout << "Valeur : " << valeur << endl;
    }
};


//Partie 4 : Templates et STL
// Exercice 7
// vector<int>

#include <vector>

vector<int> v1;
v1.push_back(10);
v1.push_back(20);

// vector<double>
vector<double> v2;
v2.push_back(3.14);

//Pourquoi vector est une classe template ?

//Car elle est définie ainsi :

template <class T, class Allocator = allocator<T>>
class vector;