Travaux Dirigés 1 : Concepts Fondamentaux, Encapsulation & Règle des Trois

/**
 * TD 1 - Exercice 1 : Transition Procédural vers Objet & Encapsulation de base
 * Modélisation d'un Point2D géométrique en C++20
 */
 
#include <iostream>
#include <cmath>
 
class Point2D {
private:
    double m_x;
    double m_y;
 
public:
    // 1. Constructeur par défaut (initialise à l'origine)
    Point2D() : m_x(0.0), m_y(0.0) {}
 
    // 2. Constructeur avec coordonnées (liste d'initialisation)
    Point2D(double x, double y) : m_x(x), m_y(y) {}
 
    // 3. Accesseurs (getters) - strictement 'const' car ils ne modifient pas l'objet
    double getX() const { return m_x; }
    double getY() const { return m_y; }
 
    // 4. Mutateurs (setters)
    void setX(double x) { m_x = x; }
    void setY(double y) { m_y = y; }
 
    // 5. Opération de translation modifiant l'état de l'objet
    void translater(double dx, double dy) {
        m_x += dx;
        m_y += dy;
    }
 
    // 6. Calcul de distance euclidienne entre *this et un autre point
    // Passage par référence constante pour éviter toute copie inutile
    double distance(const Point2D& autre) const {
        return std::hypot(m_x - autre.m_x, m_y - autre.m_y);
    }
 
    // 7. Affichage formaté
    void afficher() const {
        std::cout << "(" << m_x << ", " << m_y << ")";
    }
};
 
// Fonction externe illustrant le passage par référence constante
void afficherInfosPoint(const Point2D& p) {
    std::cout << "Point aux coordonnées ";
    p.afficher(); // Possible uniquement car afficher() est const !
    std::cout << " (distance origine = " << p.distance(Point2D()) << ")\n";
}
 
int main() {
    std::cout << "=== TD 1 - Exercice 1 : Point2D ===\n";
 
    Point2D p1;              // Origine (0, 0)
    Point2D p2(3.0, 4.0);    // Point (3, 4)
 
    std::cout << "p1 initial : ";
    p1.afficher();
    std::cout << "\n";
 
    std::cout << "p2 initial : ";
    p2.afficher();
    std::cout << "\n";
 
    std::cout << "\nDistance entre p1 et p2 : " << p1.distance(p2) << "\n";
 
    std::cout << "\nTranslation de p1 de (+1.5, -2.0)...\n";
    p1.translater(1.5, -2.0);
    std::cout << "p1 après translation : ";
    p1.afficher();
    std::cout << "\n";
 
    std::cout << "\nAppel de fonction externe avec passage par const ref :\n";
    afficherInfosPoint(p2);
 
    return 0;
}

/**
 * TD 1 - Exercice 2 : Invariants de classe, Pointeur 'this' et Chaînage de méthodes
 * Classe Duree normalisée avec interface fluide (Fluent Interface) en C++20
 */
 
#include <iostream>
#include <iomanip>
 
class Duree {
private:
    int m_heures;
    int m_minutes;
    int m_secondes;
 
    // Méthode privée préservant l'invariant de classe :
    // - 0 <= m_secondes < 60
    // - 0 <= m_minutes < 60
    // - m_heures >= 0
    void normaliser() {
        // Conversion globale en secondes
        long long totalSec = static_cast<long long>(m_heures) * 3600 + m_minutes * 60 + m_secondes;
        if (totalSec < 0) {
            totalSec = 0; // Seuil plancher (pas de durée négative)
        }
 
        m_heures = static_cast<int>(totalSec / 3600);
        long long reste = totalSec % 3600;
        m_minutes = static_cast<int>(reste / 60);
        m_secondes = static_cast<int>(reste % 60);
    }
 
public:
    // 1. Constructeur par défaut (durée nulle)
    Duree() : m_heures(0), m_minutes(0), m_secondes(0) {}
 
    // 2. Constructeur à partir d'un nombre total de secondes (mot-clé explicit pour éviter conversions implicites surprises)
    explicit Duree(int secondesTotales) : m_heures(0), m_minutes(0), m_secondes(secondesTotales) {
        normaliser();
    }
 
    // 3. Constructeur complet
    Duree(int h, int m, int s) : m_heures(h), m_minutes(m), m_secondes(s) {
        normaliser();
    }
 
    // 4. Accesseurs const
    int getHeures() const { return m_heures; }
    int getMinutes() const { return m_minutes; }
    int getSecondes() const { return m_secondes; }
 
    int enSecondes() const {
        return m_heures * 3600 + m_minutes * 60 + m_secondes;
    }
 
    // 5. Méthodes chaînables (Fluent Interface) grâce au renvoi de *this par référence
    Duree& ajouterSecondes(int s) {
        m_secondes += s;
        normaliser();
        return *this; // Renvoie l'objet courant pour permettre le chaînage
    }
 
    Duree& ajouterMinutes(int m) {
        m_minutes += m;
        normaliser();
        return *this;
    }
 
    Duree& ajouterHeures(int h) {
        m_heures += h;
        normaliser();
        return *this;
    }
 
    // 6. Comparaison
    bool estSuperieure(const Duree& autre) const {
        return this->enSecondes() > autre.enSecondes();
    }
 
    // 7. Affichage formaté 00h 00m 00s
    void afficher() const {
        std::cout << std::setfill('0')
                  << std::setw(2) << m_heures << "h "
                  << std::setw(2) << m_minutes << "m "
                  << std::setw(2) << m_secondes << "s";
    }
};
 
int main() {
    std::cout << "=== TD 1 - Exercice 2 : Invariants et Pointeur this (Duree) ===\n";
 
    // Test 1 : Invariant de classe et normalisation
    std::cout << "Création d'une durée brute (1h, 75m, 130s) :\n";
    Duree d1(1, 75, 130);
    std::cout << "-> Résultat après normalisation : ";
    d1.afficher();
    std::cout << " (" << d1.enSecondes() << " secondes)\n\n";
 
    // Test 2 : Chaînage de méthodes (Fluent Interface) via *this
    std::cout << "Chaînage sur d1: .ajouterHeures(2).ajouterMinutes(40).ajouterSecondes(50)\n";
    d1.ajouterHeures(2)
      .ajouterMinutes(40)
      .ajouterSecondes(50);
 
    std::cout << "-> Résultat : ";
    d1.afficher();
    std::cout << "\n\n";
 
    // Test 3 : Comparaison
    Duree marathon(3, 15, 0); // 3h 15m 00s
    std::cout << "Durée marathon : ";
    marathon.afficher();
    std::cout << "\n";
 
    if (d1.estSuperieure(marathon)) {
        std::cout << "d1 est plus longue que le marathon.\n";
    } else {
        std::cout << "d1 est plus courte ou égale au marathon.\n";
    }
 
    return 0;
}

/**
 * TD 1 - Exercice 3 : Composition d'Objets & Cycle de Vie
 * Observation de l'ordre d'appel des constructeurs/destructeurs
 * et impact du passage par valeur vs référence constante en C++20.
 */
 
#include <iostream>
#include <string>
 
class Capteur {
private:
    int m_id;
    std::string m_type;
 
public:
    Capteur(int id, const std::string& type) : m_id(id), m_type(type) {
        std::cout << "  [+] Capteur #" << m_id << " (" << m_type 
                  << ") construit @" << this << "\n";
    }
 
    // Constructeur par recopie explicite pour tracer les duplications
    Capteur(const Capteur& source) : m_id(source.m_id), m_type(source.m_type + " [copie]") {
        std::cout << "  [C] Capteur COPIÉ depuis @" << &source 
                  << " vers @" << this << "\n";
    }
 
    ~Capteur() {
        std::cout << "  [-] Capteur #" << m_id << " détruit @" << this << "\n";
    }
 
    void mesurer() const {
        std::cout << "      Mesure acquise par " << m_type << " #" << m_id << "\n";
    }
};
 
class StationMeteo {
private:
    std::string m_nom;
    // Les membres sont TOUJOURS initialisés dans leur ordre de déclaration ici :
    Capteur m_capteurTemp;
    Capteur m_capteurPression;
 
public:
    // Remarquez : même si on inversait l'ordre dans la liste d'initialisation,
    // C++ construirait m_capteurTemp puis m_capteurPression selon la déclaration ci-dessus.
    StationMeteo(const std::string& nom, int idT, int idP)
        : m_nom(nom),
          m_capteurTemp(idT, "Thermomètre"),
          m_capteurPression(idP, "Baromètre") {
        std::cout << "[+] StationMeteo \"" << m_nom << "\" entièrement initialisée @" << this << "\n";
    }
 
    // Constructeur de copie
    StationMeteo(const StationMeteo& source)
        : m_nom(source.m_nom + " (copie)"),
          m_capteurTemp(source.m_capteurTemp),
          m_capteurPression(source.m_capteurPression) {
        std::cout << "[C] StationMeteo COPIÉE depuis @" << &source << " vers @" << this << "\n";
    }
 
    ~StationMeteo() {
        std::cout << "[-] StationMeteo \"" << m_nom << "\" commence sa destruction @" << this << "\n";
        // Après le corps de ce destructeur, les membres m_capteurPression puis
        // m_capteurTemp puis m_nom sont détruits dans l'ordre INVERSE de leur déclaration !
    }
 
    void releverDonnees() const {
        std::cout << "--- Relevé de " << m_nom << " ---\n";
        m_capteurTemp.mesurer();
        m_capteurPression.mesurer();
    }
};
 
// Fonction recevant l'objet par VALEUR (provoque une copie complète en cascade)
void inspecterParValeur(StationMeteo s) {
    std::cout << ">> Dans inspecterParValeur() :\n";
    s.releverDonnees();
    std::cout << ">> Fin de inspecterParValeur(). Destruction imminente de la copie :\n";
}
 
// Fonction recevant l'objet par RÉFÉRENCE CONSTANTE (zéro copie, coût nul)
void inspecterParReference(const StationMeteo& s) {
    std::cout << ">> Dans inspecterParReference() (aucune copie créée) :\n";
    s.releverDonnees();
    std::cout << ">> Fin de inspecterParReference().\n";
}
 
int main() {
    std::cout << "=== TD 1 - Exercice 3 : Composition & Cycle de Vie ===\n\n";
 
    std::cout << "--- Étape 1 : Construction locale dans un bloc ---\n";
    {
        StationMeteo stationAlpha("Pic du Midi", 101, 102);
        std::cout << "-> Station construite avec succès.\n";
        std::cout << "-> Sortie du bloc local :\n";
    }
    std::cout << "-> Bloc local terminé.\n\n";
 
    std::cout << "--- Étape 2 : Impact du passage par valeur vs par référence ---\n";
    StationMeteo stationBeta("Mont Blanc", 201, 202);
 
    std::cout << "\nAppel 1 : inspecterParValeur (observez la cascade de copies) :\n";
    inspecterParValeur(stationBeta);
 
    std::cout << "\nAppel 2 : inspecterParReference (recommandé en C++) :\n";
    inspecterParReference(stationBeta);
 
    std::cout << "\n--- Fin du main(). Destruction de stationBeta : ---\n";
    return 0;
}

/**
 * TD 1 - Exercice 4 : Allocation Dynamique, Détection de Bogue et Copie Profonde
 * Classe VecteurDynamique gérant manuellement sa mémoire sur le tas en C++20.
 */
 
#include <iostream>
#include <algorithm> // std::copy
#include <stdexcept> // std::out_of_range
 
class VecteurDynamique {
private:
    std::size_t m_capacite;
    double* m_donnees;
 
public:
    // 1. Constructeur paramétré : allocation dynamique sur le tas
    explicit VecteurDynamique(std::size_t capacite, double valInit = 0.0)
        : m_capacite(capacite),
          m_donnees(capacite > 0 ? new double[capacite] : nullptr) {
        for (std::size_t i = 0; i < m_capacite; ++i) {
            m_donnees[i] = valInit;
        }
        std::cout << "[+] VecteurDynamique (taille " << m_capacite 
                  << ") alloué sur le tas à l'adresse : " << static_cast<void*>(m_donnees) << "\n";
    }
 
    // 2. Destructeur : libération de la ressource allouée
    ~VecteurDynamique() {
        std::cout << "[-] Libération du tableau à l'adresse : " 
                  << static_cast<void*>(m_donnees) << "\n";
        delete[] m_donnees;
        m_donnees = nullptr;
    }
 
    // 3. Constructeur par Recopie PROFONDE (Deep Copy)
    // INDISPENSABLE : sans lui, le compilateur génère une copie bit-à-bit (Shallow Copy)
    // où les deux objets partagent le même pointeur m_donnees -> crash "double free" !
    VecteurDynamique(const VecteurDynamique& source)
        : m_capacite(source.m_capacite),
          m_donnees(source.m_capacite > 0 ? new double[source.m_capacite] : nullptr) {
 
        // Copie des éléments un par un dans notre nouvelle zone mémoire distincte
        for (std::size_t i = 0; i < m_capacite; ++i) {
            m_donnees[i] = source.m_donnees[i];
        }
 
        std::cout << "[C] COPIE PROFONDE créée (nouvelle adresse tas : " 
                  << static_cast<void*>(m_donnees) 
                  << " distincte de la source : " << static_cast<void*>(source.m_donnees) << ")\n";
    }
 
    // Accesseurs avec contrôle de bornes
    std::size_t getCapacite() const { return m_capacite; }
 
    double get(std::size_t index) const {
        if (index >= m_capacite) {
            throw std::out_of_range("Indice de vecteur hors bornes !");
        }
        return m_donnees[index];
    }
 
    void set(std::size_t index, double valeur) {
        if (index >= m_capacite) {
            throw std::out_of_range("Indice de vecteur hors bornes !");
        }
        m_donnees[index] = valeur;
    }
 
    void afficher() const {
        std::cout << "[ ";
        for (std::size_t i = 0; i < m_capacite; ++i) {
            std::cout << m_donnees[i] << (i + 1 < m_capacite ? ", " : " ");
        }
        std::cout << "] (adresse tas: " << static_cast<void*>(m_donnees) << ")\n";
    }
};
 
int main() {
    std::cout << "=== TD 1 - Exercice 4 : Allocation Dynamique & Copie Profonde ===\n\n";
 
    std::cout << "1. Création de v1 de taille 4 initialisé avec 10.0 :\n";
    VecteurDynamique v1(4, 10.0);
    std::cout << "v1 : ";
    v1.afficher();
 
    std::cout << "\n2. Copie de v1 vers v2 via le constructeur de copie :\n";
    VecteurDynamique v2 = v1; // Appelle VecteurDynamique(const VecteurDynamique&)
    std::cout << "v2 : ";
    v2.afficher();
 
    std::cout << "\n3. Modification de v2[0] = 999.0 :\n";
    v2.set(0, 999.0);
 
    std::cout << "v1 après modif de v2 : ";
    v1.afficher(); // Doit être INCHANGÉ (prouve l'indépendance mémoire)
    std::cout << "v2 après modif de v2 : ";
    v2.afficher();
 
    std::cout << "\n4. Sortie de fonction (destructions ordonnées sans conflit) :\n";
    return 0;
}

/**
 * TD 1 - Exercice 5 : La Forme Canonique Complète (Règle des Trois)
 * Conception intégrale d'une classe Chaine (gestion manuelle de char*) en C++20.
 */
 
#include <iostream>
#include <cstring>   // strlen, strcpy, strcat
#include <stdexcept> // out_of_range
 
class Chaine {
private:
    char* m_tampon;       // Pointeur brut vers la chaîne stockée sur le tas
    std::size_t m_taille; // Longueur effective (hors caractère nul '\0')
 
public:
    // 1. Constructeur par défaut (chaîne vide "")
    Chaine() : m_tampon(new char[1]{'\0'}), m_taille(0) {
        std::cout << "[+] Chaine() vide créée @" << this << "\n";
    }
 
    // 2. Constructeur à partir d'un littéral C (const char*)
    Chaine(const char* str) {
        if (str == nullptr) {
            m_taille = 0;
            m_tampon = new char[1]{'\0'};
        } else {
            m_taille = std::strlen(str);
            m_tampon = new char[m_taille + 1];
            std::strcpy(m_tampon, str);
        }
        std::cout << "[+] Chaine(\"" << m_tampon << "\") construite @" << this << "\n";
    }
 
    // -------------------------------------------------------------
    // LA RÈGLE DES TROIS (FORME CANONIQUE DE COPIE)
    // -------------------------------------------------------------
 
    // 1ère règle : LE DESTRUCTEUR
    ~Chaine() {
        std::cout << "[-] ~Chaine() détruite @" << this 
                  << " (libère \"" << (m_tampon ? m_tampon : "") << "\")\n";
        delete[] m_tampon;
        m_tampon = nullptr;
    }
 
    // 2ème règle : LE CONSTRUCTEUR PAR RECOPIE (Deep Copy)
    Chaine(const Chaine& source) : m_taille(source.m_taille) {
        m_tampon = new char[m_taille + 1];
        std::strcpy(m_tampon, source.m_tampon);
        std::cout << "[C] Chaine COPIÉE depuis @" << &source << " vers @" << this 
                  << " (valeur: \"" << m_tampon << "\")\n";
    }
 
    // 3ème règle : L'OPÉRATEUR D'AFFECTATION (operator=)
    Chaine& operator=(const Chaine& source) {
        std::cout << "[=] operator= invoqué sur @" << this 
                  << " depuis source @" << &source << "\n";
 
        // Étape 1 : Protection vitale contre l'auto-affectation (a = a)
        // Sans ce test, on détruirait notre propre mémoire avant de pouvoir la copier !
        if (this == &source) {
            std::cout << "    -> Auto-affectation détectée, aucun travail nécessaire.\n";
            return *this;
        }
 
        // Étape 2 : Libération de l'ancienne mémoire détenue par this
        delete[] m_tampon;
 
        // Étape 3 : Allocation de la nouvelle taille et copie profonde
        m_taille = source.m_taille;
        m_tampon = new char[m_taille + 1];
        std::strcpy(m_tampon, source.m_tampon);
 
        // Étape 4 : Renvoyer une référence vers *this pour permettre l'enchaînement (a = b = c)
        return *this;
    }
 
    // -------------------------------------------------------------
    // MÉTHODES UTILITAIRES
    // -------------------------------------------------------------
 
    std::size_t longueur() const {
        return m_taille;
    }
 
    const char* c_str() const {
        return m_tampon;
    }
 
    char at(std::size_t index) const {
        if (index >= m_taille) {
            throw std::out_of_range("Indice hors bornes dans Chaine !");
        }
        return m_tampon[index];
    }
 
    void afficher() const {
        std::cout << "\"" << m_tampon << "\" (longueur: " << m_taille << ")";
    }
 
    // Concaténation en place
    Chaine& concatener(const Chaine& autre) {
        std::size_t nouvelleTaille = m_taille + autre.m_taille;
        char* nouveauTampon = new char[nouvelleTaille + 1];
 
        std::strcpy(nouveauTampon, m_tampon);
        std::strcat(nouveauTampon, autre.m_tampon);
 
        delete[] m_tampon;
        m_tampon = nouveauTampon;
        m_taille = nouvelleTaille;
 
        return *this;
    }
 
    Chaine& operator+=(const Chaine& autre) {
        return concatener(autre);
    }
};
 
int main() {
    std::cout << "=== TD 1 - Exercice 5 : La Forme Canonique Complète (Chaine) ===\n\n";
 
    std::cout << "--- 1. Constructions de base ---\n";
    Chaine s1("Bonjour");
    Chaine s2(" Monde");
    std::cout << "s1 = "; s1.afficher(); std::cout << "\n";
    std::cout << "s2 = "; s2.afficher(); std::cout << "\n\n";
 
    std::cout << "--- 2. Constructeur par recopie (initialisation) ---\n";
    Chaine s3 = s1; // Appelle le constructeur de recopie
    std::cout << "s3 = "; s3.afficher(); std::cout << "\n\n";
 
    std::cout << "--- 3. Affectation d'un objet existant (operator=) ---\n";
    Chaine s4("Temporaire");
    s4 = s2;        // Appelle operator=
    std::cout << "s4 = "; s4.afficher(); std::cout << "\n\n";
 
    std::cout << "--- 4. Test critique de l'auto-affectation (s1 = s1) ---\n";
    s1 = s1;
    std::cout << "s1 après s1 = s1 : "; s1.afficher(); std::cout << "\n\n";
 
    std::cout << "--- 5. Test des affectations enchaînées (s4 = s3 = s2) ---\n";
    s4 = s3 = s2;
    std::cout << "s4 après chaîne : "; s4.afficher(); std::cout << "\n\n";
 
    std::cout << "--- 6. Concaténation ---\n";
    Chaine message("Programmation ");
    message += Chaine("Orientée Objet C++ !");
    std::cout << "message : "; message.afficher(); std::cout << "\n\n";
 
    std::cout << "--- 7. Sortie du programme et destructions RAII automatiques : ---\n";
    return 0;
}