Travaux Dirigés 2 : L'Héritage Simple, Multiple et en Diamant

/**
 * TD 2 - Exercice 1 : Héritage Simple, Spécialisation et Visibilités
 * Modélisation d'une hiérarchie d'employés en C++20
 */
 
#include <iostream>
#include <string>
#include <iomanip>
 
// 1. Classe de Base
class Employe {
protected:
    // Attributs protégés : accessibles directement par les classes dérivées
    // mais protégés contre toute manipulation directe depuis l'extérieur.
    std::string m_nom;
    int m_matricule;
    double m_salaireBase;
 
public:
    // Constructeur avec liste d'initialisation
    Employe(const std::string& nom, int matricule, double salaireBase)
        : m_nom(nom), m_matricule(matricule), m_salaireBase(salaireBase) {}
 
    // Accesseurs const
    std::string getNom() const { return m_nom; }
    int getMatricule() const { return m_matricule; }
    double getSalaireBase() const { return m_salaireBase; }
 
    // Mutateur avec contrôle de validité
    void setSalaireBase(double nouveauSalaire) {
        if (nouveauSalaire >= 0.0) {
            m_salaireBase = nouveauSalaire;
        }
    }
 
    // Calcul de rémunération mensuelle
    double calculerSalaire() const {
        return m_salaireBase;
    }
 
    // Affichage des informations générales
    void afficher() const {
        std::cout << "[Employe #" << m_matricule << "] " << m_nom 
                  << " | Salaire base: " << std::fixed << std::setprecision(2) << m_salaireBase << " €";
    }
};
 
// 2. Classe Dérivée : Manager (Héritage public : "Un Manager EST-UN Employe")
class Manager : public Employe {
private:
    // Attributs spécifiques au manager
    double m_primeManagement;
    int m_nbCollaborateurs;
 
public:
    // Le constructeur de la dérivée DOIT invoquer le constructeur de la base
    // dans sa propre liste d'initialisation.
    Manager(const std::string& nom, int matricule, double salaireBase,
            double primeManagement, int nbCollaborateurs)
        : Employe(nom, matricule, salaireBase),
          m_primeManagement(primeManagement),
          m_nbCollaborateurs(nbCollaborateurs) {}
 
    // Accesseurs spécifiques
    double getPrime() const { return m_primeManagement; }
    int getNbCollaborateurs() const { return m_nbCollaborateurs; }
 
    void setPrime(double prime) {
        if (prime >= 0.0) m_primeManagement = prime;
    }
 
    // Spécialisation du calcul de salaire (salaire de base hérité + prime)
    double calculerSalaire() const {
        return m_salaireBase + m_primeManagement;
    }
 
    // Redéfinition de la méthode afficher() en réutilisant la méthode parente
    void afficher() const {
        // Réutilisation de l'affichage de la base via l'opérateur de résolution de portée ::
        Employe::afficher();
        std::cout << " | Prime: " << m_primeManagement << " €"
                  << " | Équipe: " << m_nbCollaborateurs << " membres"
                  << " | Total: " << calculerSalaire() << " €";
    }
};
 
// 3. Classe Dérivée : Developpeur
class Developpeur : public Employe {
private:
    std::string m_langagePrincipal;
    double m_bonusProjet;
 
public:
    Developpeur(const std::string& nom, int matricule, double salaireBase,
                const std::string& langage, double bonusProjet = 0.0)
        : Employe(nom, matricule, salaireBase),
          m_langagePrincipal(langage),
          m_bonusProjet(bonusProjet) {}
 
    std::string getLangage() const { return m_langagePrincipal; }
    double getBonus() const { return m_bonusProjet; }
 
    void ajouterBonus(double bonus) {
        if (bonus > 0.0) m_bonusProjet += bonus;
    }
 
    double calculerSalaire() const {
        return m_salaireBase + m_bonusProjet;
    }
 
    void afficher() const {
        Employe::afficher();
        std::cout << " | Langage: " << m_langagePrincipal
                  << " | Bonus: " << m_bonusProjet << " €"
                  << " | Total: " << calculerSalaire() << " €";
    }
};
 
int main() {
    std::cout << "=== TD 2 - Exercice 1 : Héritage Simple (Employe, Manager, Developpeur) ===\n\n";
 
    // 1. Instanciation d'un Employe standard
    Employe e1("Claire Dupont", 1001, 2400.0);
    std::cout << "--- Employé de base ---\n";
    e1.afficher();
    std::cout << "\n\n";
 
    // 2. Instanciation d'un Manager
    Manager m1("Alice Bernard", 2001, 3800.0, 750.0, 6);
    std::cout << "--- Manager (dérivée de Employe) ---\n";
    m1.afficher();
    std::cout << "\n\n";
 
    // 3. Instanciation d'un Développeur
    Developpeur d1("Bob Martin", 3001, 3100.0, "C++20", 350.0);
    std::cout << "--- Développeur (dérivée de Employe) ---\n";
    d1.afficher();
    std::cout << "\n";
 
    // 4. Utilisation des méthodes héritées de la base
    std::cout << "\n--- Modification via les méthodes héritées de Employe ---\n";
    std::cout << "Augmentation du salaire de base du développeur Bob Martin de 3100 € à 3300 €...\n";
    d1.setSalaireBase(3300.0); // Méthode de la classe de base Employe
    d1.ajouterBonus(150.0);    // Méthode propre à Developpeur
    d1.afficher();
    std::cout << "\n";
 
    return 0;
}

/**
 * TD 2 - Exercice 2 : Chaîne d'Héritage, Ordre d'Exécution & Masquage de Noms
 * Observation pas à pas de l'ordre LIFO et rétablissement de la surcharge avec using
 */
 
#include <iostream>
#include <string>
 
// Niveau 1 : Classe de Base
class Composant {
protected:
    int m_idSerie;
 
public:
    Composant(int id) : m_idSerie(id) {
        std::cout << "  [1. Composant] Constructeur (#" << m_idSerie 
                  << ") @" << this << "\n";
    }
 
    ~Composant() {
        std::cout << "  [1. Composant] Destructeur (#" << m_idSerie 
                  << ") @" << this << "\n";
    }
 
    int getId() const { return m_idSerie; }
 
    void configurer() {
        std::cout << "      -> Configuration générique du composant #" << m_idSerie << "\n";
    }
};
 
// Niveau 2 : Classe Intermédiaire
class Peripherique : public Composant {
protected:
    std::string m_interface;
 
public:
    Peripherique(int id, const std::string& interfaceConnexion)
        : Composant(id), m_interface(interfaceConnexion) {
        std::cout << "    [2. Peripherique] Constructeur (Interface: " << m_interface 
                  << ") @" << this << "\n";
    }
 
    ~Peripherique() {
        std::cout << "    [2. Peripherique] Destructeur (Interface: " << m_interface 
                  << ") @" << this << "\n";
    }
 
    // Rétablissement de la méthode de la base masquée par la surcharge locale
    using Composant::configurer;
 
    // Surcharge de configurer avec un paramètre (débit en Mbps)
    // En C++, définir cette méthode masque Composant::configurer() à moins d'utiliser 'using' !
    void configurer(int debitMbps) {
        std::cout << "      -> Configuration du périphérique #" << m_idSerie 
                  << " sur bus " << m_interface 
                  << " bridé à " << debitMbps << " Mbps\n";
    }
};
 
// Niveau 3 : Classe Dérivée Finale
class ClavierRGB : public Peripherique {
private:
    std::string m_retroEclairage;
 
public:
    ClavierRGB(int id, const std::string& interfaceConnexion, const std::string& profilRGB)
        : Peripherique(id, interfaceConnexion), m_retroEclairage(profilRGB) {
        std::cout << "      [3. ClavierRGB] Constructeur (RGB: " << m_retroEclairage 
                  << ") @" << this << "\n";
    }
 
    ~ClavierRGB() {
        std::cout << "      [3. ClavierRGB] Destructeur (RGB: " << m_retroEclairage 
                  << ") @" << this << "\n";
    }
 
    void changerRGB(const std::string& nouveauProfil) {
        m_retroEclairage = nouveauProfil;
        std::cout << "      -> Clavier #" << m_idSerie 
                  << " basculé sur le profil RGB : " << m_retroEclairage << "\n";
    }
 
    void afficherFiche() const {
        std::cout << "Clavier #" << m_idSerie 
                  << " | Bus: " << m_interface 
                  << " | Éclairage: " << m_retroEclairage << "\n";
    }
};
 
int main() {
    std::cout << "=== TD 2 - Exercice 2 : Cycle de Vie & Masquage de Noms ===\n\n";
 
    std::cout << "--- 1. Observation de la cascade de construction et destruction ---\n";
    std::cout << "Début du bloc local...\n";
    {
        std::cout << "Instanciation d'un ClavierRGB (pile) :\n";
        ClavierRGB clavier(4501, "USB-C", "Aura Rainbow");
 
        std::cout << "\nObjet opérationnel en mémoire :\n";
        clavier.afficherFiche();
 
        std::cout << "\nTest des méthodes de configuration (grâce à 'using Composant::configurer') :\n";
        // Appel de la version sans argument (héritée du niveau 1 Composant) :
        clavier.configurer();
        // Appel de la version avec paramètre (héritée du niveau 2 Peripherique) :
        clavier.configurer(1000);
 
        clavier.changerRGB("Rouge Pulsant");
 
        std::cout << "\nFin du bloc local, sortie de portée imminente...\n";
    }
    std::cout << "Fin du bloc local atteinte (tous les destructeurs ont été exécutés).\n";
 
    return 0;
}

/**
 * TD 2 - Exercice 3 : Modes de Dérivation (public, protected, private)
 * Rupture de la relation « EST-UN » et héritage d'implémentation
 */
 
#include <iostream>
#include <stdexcept>
#include <numeric>
#include <algorithm>
 
// 1. Classe de Base : Conteneur brut avec accès indicé libre
class TableauFixe {
protected:
    static constexpr std::size_t CAPACITE_MAX = 50;
    int m_donnees[CAPACITE_MAX];
    std::size_t m_taille;
 
public:
    TableauFixe() : m_taille(0) {}
 
    std::size_t getTaille() const { return m_taille; }
    std::size_t getCapacite() const { return CAPACITE_MAX; }
 
    void insererFin(int valeur) {
        if (m_taille >= CAPACITE_MAX) {
            throw std::overflow_error("TableauFixe plein : capacité maximale atteinte.");
        }
        m_donnees[m_taille++] = valeur;
    }
 
    void insererIndex(std::size_t index, int valeur) {
        if (m_taille >= CAPACITE_MAX) {
            throw std::overflow_error("TableauFixe plein.");
        }
        if (index > m_taille) {
            throw std::out_of_range("Index hors limites lors de l'insertion.");
        }
        for (std::size_t i = m_taille; i > index; --i) {
            m_donnees[i] = m_donnees[i - 1];
        }
        m_donnees[index] = valeur;
        ++m_taille;
    }
 
    void supprimerFin() {
        if (m_taille == 0) {
            throw std::underflow_error("Tableau vide, impossible de supprimer.");
        }
        --m_taille;
    }
 
    int get(std::size_t index) const {
        if (index >= m_taille) {
            throw std::out_of_range("Index hors limites.");
        }
        return m_donnees[index];
    }
 
    void afficher() const {
        std::cout << "[ ";
        for (std::size_t i = 0; i < m_taille; ++i) {
            std::cout << m_donnees[i] << " ";
        }
        std::cout << "] (taille = " << m_taille << ")\n";
    }
};
 
// 2. Dérivation PUBLIQUE : "Un TableauStatistique EST-UN TableauFixe"
// Tous les membres publics de TableauFixe restent publics pour les clients.
class TableauStatistique : public TableauFixe {
public:
    // Constructeur par défaut appelant le constructeur de la base
    TableauStatistique() : TableauFixe() {}
 
    // Ajout de calculs statistiques
    double moyenne() const {
        if (m_taille == 0) return 0.0;
        double somme = 0.0;
        for (std::size_t i = 0; i < m_taille; ++i) {
            somme += m_donnees[i];
        }
        return somme / m_taille;
    }
 
    int minimum() const {
        if (m_taille == 0) throw std::logic_error("Tableau vide");
        int minVal = m_donnees[0];
        for (std::size_t i = 1; i < m_taille; ++i) {
            if (m_donnees[i] < minVal) minVal = m_donnees[i];
        }
        return minVal;
    }
 
    int maximum() const {
        if (m_taille == 0) throw std::logic_error("Tableau vide");
        int maxVal = m_donnees[0];
        for (std::size_t i = 1; i < m_taille; ++i) {
            if (m_donnees[i] > maxVal) maxVal = m_donnees[i];
        }
        return maxVal;
    }
};
 
// 3. Dérivation PRIVÉE : "Une Pile N'EST PAS un TableauFixe, elle est implémentée avec"
// L'accès direct aux indices intermédiaires violerait le principe fondamental LIFO.
// Tous les membres hérités deviennent privés dans PileEntiers.
class PileEntiers : private TableauFixe {
public:
    PileEntiers() : TableauFixe() {}
 
    // Exposition sélective et contrôlée de la méthode getTaille de la base
    using TableauFixe::getTaille;
 
    // Interface stricte de pile LIFO
    void empiler(int val) {
        insererFin(val); // Appel autorisé en interne
    }
 
    int depiler() {
        if (estVide()) {
            throw std::underflow_error("Dépilement impossible : la pile est vide !");
        }
        int val = m_donnees[m_taille - 1];
        supprimerFin();
        return val;
    }
 
    int sommet() const {
        if (estVide()) {
            throw std::underflow_error("Pile vide, aucun sommet disponible.");
        }
        return m_donnees[m_taille - 1];
    }
 
    bool estVide() const {
        return m_taille == 0;
    }
 
    void afficherPile() const {
        std::cout << "Pile (sommet -> bas) : [ ";
        for (std::size_t i = m_taille; i > 0; --i) {
            std::cout << m_donnees[i - 1] << " ";
        }
        std::cout << "]\n";
    }
};
 
// Fonction externe attendant un TableauFixe par référence
void inspecterConteneur(const TableauFixe& tab) {
    std::cout << "Conteneur inspecté : taille=" << tab.getTaille() << " -> ";
    tab.afficher();
}
 
int main() {
    std::cout << "=== TD 2 - Exercice 3 : Modes d'Héritage (public vs private) ===\n\n";
 
    // 1. Dérivation Publique
    std::cout << "--- 1. TableauStatistique (Héritage public : IS-A TableauFixe) ---\n";
    TableauStatistique stats;
    stats.insererFin(12);
    stats.insererFin(45);
    stats.insererFin(8);
    stats.insererFin(27);
    stats.insererIndex(2, 99); // Méthode publique de la base accessible !
 
    std::cout << "Données : ";
    stats.afficher();
    std::cout << "Moyenne : " << stats.moyenne() << "\n";
    std::cout << "Min : " << stats.minimum() << " | Max : " << stats.maximum() << "\n";
 
    std::cout << "\nConversion implicite vers la base (Upcasting autorisé car public) :\n";
    inspecterConteneur(stats); // ✅ Valide : TableauStatistique EST un TableauFixe
 
    // 2. Dérivation Privée
    std::cout << "\n--- 2. PileEntiers (Héritage privé : Implémentation masquée) ---\n";
    PileEntiers pile;
    pile.empiler(10);
    pile.empiler(20);
    pile.empiler(30);
    pile.empiler(40);
 
    pile.afficherPile();
    std::cout << "Taille de la pile (via 'using TableauFixe::getTaille') : " << pile.getTaille() << "\n";
    std::cout << "Sommet actuel : " << pile.sommet() << "\n";
 
    std::cout << "Dépilement : " << pile.depiler() << "\n";
    std::cout << "Dépilement : " << pile.depiler() << "\n";
    std::cout << "Après 2 dépilements : ";
    pile.afficherPile();
 
    // DÉMONSTRATION DES SÉCURITÉS À LA COMPILATION :
    // pile.insererIndex(1, 999); 
    // ❌ ERREUR COMPILATION : 'insererIndex' is a private member of 'TableauFixe'
    //
    // inspecterConteneur(pile);  
    // ❌ ERREUR COMPILATION : 'TableauFixe' is an inaccessible base of 'PileEntiers'
    // Car la relation EST-UN n'existe pas pour l'extérieur !
 
    std::cout << "\nProtection vérifiée : l'utilisateur externe ne peut pas corrompre la pile\n"
              << "ni forcer un upcasting vers TableauFixe.\n";
 
    return 0;
}

/**
 * TD 2 - Exercice 4 : Héritage Multiple, Conflits de Noms & Agencement Mémoire
 * Combinaison d'interfaces et désambiguïsation par l'opérateur de portée ::
 */
 
#include <iostream>
#include <string>
 
// 1. Première classe de base : Imprimante
class Imprimante {
protected:
    int m_resolutionDPI;
    int m_pagesImprimees;
 
public:
    Imprimante(int dpi) : m_resolutionDPI(dpi), m_pagesImprimees(0) {
        std::cout << "  [+] Constructeur Imprimante @" << this 
                  << " (DPI: " << m_resolutionDPI << ")\n";
    }
 
    ~Imprimante() {
        std::cout << "  [-] Destructeur Imprimante @" << this << "\n";
    }
 
    void imprimer(const std::string& doc, int copies = 1) {
        m_pagesImprimees += copies;
        std::cout << "    [Imprimante] Impression de \"" << doc 
                  << "\" (" << copies << " copie(s) à " << m_resolutionDPI << " DPI)\n";
    }
 
    // Méthode générant un conflit de nom avec Scanner
    void reinitialiser() {
        m_pagesImprimees = 0;
        std::cout << "    [Imprimante] Compteur de pages imprimées remis à zéro.\n";
    }
 
    // Deuxième méthode en conflit
    void afficherStatut() const {
        std::cout << "    [Statut Imprimante @" << this << "] DPI: " << m_resolutionDPI 
                  << " | Pages imprimées: " << m_pagesImprimees << "\n";
    }
};
 
// 2. Deuxième classe de base : Scanner
class Scanner {
protected:
    int m_vitessePPM; // Pages par minute
    int m_pagesScannees;
 
public:
    Scanner(int ppm) : m_vitessePPM(ppm), m_pagesScannees(0) {
        std::cout << "  [+] Constructeur Scanner @" << this 
                  << " (Vitesse: " << m_vitessePPM << " PPM)\n";
    }
 
    ~Scanner() {
        std::cout << "  [-] Destructeur Scanner @" << this << "\n";
    }
 
    void numeriser(const std::string& doc) {
        ++m_pagesScannees;
        std::cout << "    [Scanner] Numérisation du document \"" << doc 
                  << "\" (débit " << m_vitessePPM << " PPM)\n";
    }
 
    // Méthode homonyme en conflit
    void reinitialiser() {
        m_pagesScannees = 0;
        std::cout << "    [Scanner] Compteur de pages numérisées remis à zéro.\n";
    }
 
    // Deuxième méthode en conflit
    void afficherStatut() const {
        std::cout << "    [Statut Scanner @" << this << "] Débit: " << m_vitessePPM 
                  << " PPM | Pages numérisées: " << m_pagesScannees << "\n";
    }
};
 
// 3. Classe Dérivée par Héritage Multiple : CopieurMultifonction
// Note : L'ordre de déclaration ci-dessous détermine l'ordre d'appel des constructeurs !
class CopieurMultifonction : public Imprimante, public Scanner {
private:
    std::string m_modele;
 
public:
    // Constructeur : invoque Imprimante puis Scanner
    CopieurMultifonction(const std::string& modele, int dpi, int ppm)
        : Imprimante(dpi), Scanner(ppm), m_modele(modele) {
        std::cout << "[+] CopieurMultifonction \"" << m_modele << "\" initialisé @" << this << "\n";
    }
 
    ~CopieurMultifonction() {
        std::cout << "[-] Destructeur CopieurMultifonction \"" << m_modele << "\" @" << this << "\n";
    }
 
    // Opération combinée utilisant les deux facettes héritées
    void photocopier(const std::string& docOriginal, int nbCopies) {
        std::cout << "\n>>> Démarrage d'une photocopie combinée (" << nbCopies << " copies) <<<\n";
        // Appel de la méthode héritée de Scanner
        numeriser(docOriginal);
        // Appel de la méthode héritée d'Imprimante
        imprimer("Copie de " + docOriginal, nbCopies);
    }
 
    // Résolution de l'ambiguïté pour afficherStatut() :
    // On redéfinit la méthode dans la classe dérivée pour fédérer les deux statuts
    void afficherStatut() const {
        std::cout << "\n=== Statut Synthétique Copieur [" << m_modele << "] ===\n";
        Imprimante::afficherStatut();
        Scanner::afficherStatut();
    }
 
    // Résolution de l'ambiguïté pour reinitialiser()
    void reinitialiser() {
        std::cout << "\n=== Réinitialisation globale de tous les modules ===\n";
        Imprimante::reinitialiser();
        Scanner::reinitialiser();
    }
};
 
int main() {
    std::cout << "=== TD 2 - Exercice 4 : Héritage Multiple & Conflits de Noms ===\n\n";
 
    std::cout << "--- 1. Instanciation et analyse de la disposition mémoire (Offsets) ---\n";
    {
        CopieurMultifonction copieur("OfficeJet Pro 9000", 1200, 35);
 
        // Analyse avancée des pointeurs et décalage d'adresse (Offset)
        const CopieurMultifonction* ptrCopieur = &copieur;
        const Imprimante* ptrImprimante = &copieur;
        const Scanner* ptrScanner = &copieur;
 
        std::cout << "\nAnalyse des adresses des sous-objets en mémoire :\n";
        std::cout << "  Adresse de l'objet complet CopieurMultifonction : " << ptrCopieur << "\n";
        std::cout << "  Adresse du sous-objet Imprimante (1ère base)    : " << ptrImprimante << "\n";
        std::cout << "  Adresse du sous-objet Scanner (2ème base)       : " << ptrScanner << "\n";
        std::cout << "  -> Décalage (offset) de Scanner : " 
                  << (reinterpret_cast<const char*>(ptrScanner) - reinterpret_cast<const char*>(ptrCopieur)) 
                  << " octets.\n";
 
        // Utilisation des services combinés
        copieur.photocopier("Contrat_Confidentialite.pdf", 3);
 
        // Affichage synthétique via la méthode redéfinie unificatrice
        copieur.afficherStatut();
 
        // 2. Levée d'ambiguïté explicite depuis l'extérieur sans redéfinition
        std::cout << "\n--- 2. Appel ciblé avec l'opérateur de portée (::) ---\n";
        std::cout << "Réinitialisation UNIQUEMENT du module scanner :\n";
        copieur.Scanner::reinitialiser();
 
        copieur.afficherStatut();
 
        std::cout << "\nSortie de portée : destruction en ordre inverse...\n";
    }
 
    return 0;
}

/**
 * TD 2 - Exercice 5 : Le Problème du Diamant & L'Héritage Virtuel
 * Résolution du "Diamond of Death", unicité de l'ancêtre commun
 * et responsabilité d'initialisation de la classe la plus dérivée.
 */
 
#include <iostream>
#include <string>
 
// 1. Sommet du Diamant : Classe de Base Commune
class Vehicule {
protected:
    std::string m_immatriculation;
    int m_puissanceKW;
 
public:
    Vehicule(const std::string& immat, int kw)
        : m_immatriculation(immat), m_puissanceKW(kw) {
        std::cout << "    [1. SOMMET Vehicule] Constructeur @" << this 
                  << " | Immat: " << m_immatriculation 
                  << ", Puissance: " << m_puissanceKW << " kW\n";
    }
 
    virtual ~Vehicule() {
        std::cout << "    [1. SOMMET Vehicule] Destructeur @" << this 
                  << " (Immat: " << m_immatriculation << ")\n";
    }
 
    std::string getImmatriculation() const { return m_immatriculation; }
    int getPuissanceKW() const { return m_puissanceKW; }
 
    void setPuissanceKW(int kw) {
        m_puissanceKW = kw;
    }
 
    void afficherVehicule() const {
        std::cout << "      [Base Vehicule @" << this << "] Immat: " 
                  << m_immatriculation << " (" << m_puissanceKW << " kW)\n";
    }
};
 
// 2. Branche Gauche : Bateau avec Héritage VIRTUEL
class Bateau : virtual public Vehicule {
protected:
    double m_tirantDEau; // en mètres
 
public:
    Bateau(const std::string& immat, int kw, double tirantDEau)
        : Vehicule(immat, kw), m_tirantDEau(tirantDEau) {
        std::cout << "  [2. BRANCHE GAUCHE Bateau] Constructeur @" << this 
                  << " | Tirant d'eau: " << m_tirantDEau << " m\n";
    }
 
    ~Bateau() override {
        std::cout << "  [2. BRANCHE GAUCHE Bateau] Destructeur @" << this << "\n";
    }
 
    void naviguer() const {
        std::cout << "      -> Navigation maritime : " << m_immatriculation 
                  << " navigue avec " << m_tirantDEau << " m de tirant d'eau.\n";
    }
};
 
// 3. Branche Droite : Automobile avec Héritage VIRTUEL
class Automobile : virtual public Vehicule {
protected:
    int m_nbPlaces;
 
public:
    Automobile(const std::string& immat, int kw, int nbPlaces)
        : Vehicule(immat, kw), m_nbPlaces(nbPlaces) {
        std::cout << "  [2. BRANCHE DROITE Automobile] Constructeur @" << this 
                  << " | Places: " << m_nbPlaces << "\n";
    }
 
    ~Automobile() override {
        std::cout << "  [2. BRANCHE DROITE Automobile] Destructeur @" << this << "\n";
    }
 
    void rouler() const {
        std::cout << "      -> Conduite sur route : " << m_immatriculation 
                  << " roule (" << m_nbPlaces << " places à bord).\n";
    }
};
 
// 4. Pointe du Diamant : Classe Terminale VehiculeAmphibie
class VehiculeAmphibie : public Bateau, public Automobile {
private:
    std::string m_nomModele;
    bool m_heliceDeployee;
 
public:
    // ⚡ RÈGLE FONDAMENTALE DE L'HÉRITAGE VIRTUEL :
    // C'est obligatoirement la classe LA PLUS DÉRIVÉE (ici VehiculeAmphibie)
    // qui doit invoquer le constructeur de la base virtuelle commune Vehicule(immat, kw).
    // Les appels Vehicule(...) situés dans Bateau et Automobile sont purement ignorés !
    VehiculeAmphibie(const std::string& immat, int kw, double tirantDEau, int nbPlaces, const std::string& modele)
        : Vehicule(immat, kw),                      // 1. Initialisation de la base virtuelle unique
          Bateau(immat, kw, tirantDEau),            // 2. Initialisation branche Bateau
          Automobile(immat, kw, nbPlaces),          // 3. Initialisation branche Automobile
          m_nomModele(modele),
          m_heliceDeployee(false) {
        std::cout << "[3. POINTE VehiculeAmphibie] Prêt : \"" << m_nomModele << "\" @" << this << "\n";
    }
 
    ~VehiculeAmphibie() override {
        std::cout << "[-] Destructeur VehiculeAmphibie \"" << m_nomModele << "\" @" << this << "\n";
    }
 
    void basculerModeNautique() {
        m_heliceDeployee = !m_heliceDeployee;
        std::cout << "      -> Mode nautique " << (m_heliceDeployee ? "ACTIVÉ (Hélice déployée)" : "DÉSACTIVÉ (Roues motrices)") << "\n";
    }
 
    void afficherFicheComplete() const {
        std::cout << "\n================ Fiche Technique Amphibie ================\n";
        std::cout << "Modèle        : " << m_nomModele << "\n";
        // ✅ Aucun conflit d'accès ! getImmatriculation() et m_puissanceKW sont uniques !
        std::cout << "Immat         : " << getImmatriculation() << "\n";
        std::cout << "Puissance     : " << getPuissanceKW() << " kW (" << m_puissanceKW << ")\n";
        std::cout << "Tirant d'eau  : " << m_tirantDEau << " m\n";
        std::cout << "Capacité      : " << m_nbPlaces << " passagers\n";
        std::cout << "Hélice active : " << (m_heliceDeployee ? "Oui" : "Non") << "\n";
        std::cout << "==========================================================\n";
    }
};
 
// Fonction démontrant le polymorphisme ascendant (Upcasting) vers le sommet du diamant
void controleTechnique(const Vehicule& v) {
    std::cout << ">> [Contrôle Technique] Validation du véhicule Immat : " 
              << v.getImmatriculation() << " (" << v.getPuissanceKW() << " kW)\n";
}
 
int main() {
    std::cout << "=== TD 2 - Exercice 5 : Le Diamant d'Héritage et sa Résolution Virtuelle ===\n\n";
 
    std::cout << "--- 1. Instanciation du véhicule amphibie (construction de la hiérarchie) ---\n";
    {
        VehiculeAmphibie amph("FR-AMPH-2026", 180, 0.85, 6, "AquaTerra Cruiser");
 
        std::cout << "\n--- 2. Analyse de l'unicité du sous-objet virtuel Vehicule ---\n";
        // Vérification des adresses :
        const VehiculeAmphibie* ptrAmph = &amph;
        const Bateau* ptrBat = &amph;
        const Automobile* ptrAuto = &amph;
        const Vehicule* ptrVehicule = &amph; // ✅ Possible UNIQUEMENT grâce à virtual !
 
        std::cout << "Adresse globale VehiculeAmphibie : " << ptrAmph << "\n";
        std::cout << "Adresse sous-objet Bateau        : " << ptrBat << "\n";
        std::cout << "Adresse sous-objet Automobile    : " << ptrAuto << "\n";
        std::cout << "Adresse sous-objet commun Vehicule: " << ptrVehicule << "\n";
 
        amph.afficherFicheComplete();
 
        std::cout << "\n--- 3. Démonstration de cohérence d'état unique ---\n";
        std::cout << "Modification de la puissance à 220 kW...\n";
        amph.setPuissanceKW(220); // Modifie l'unique exemplaire de m_puissanceKW !
 
        // Actions combinées des deux branches
        amph.rouler();
        amph.basculerModeNautique();
        amph.naviguer();
 
        std::cout << "\n--- 4. Upcasting vers la base commune Vehicule ---\n";
        // Sans héritage virtuel, l'instruction suivante provoquerait une erreur :
        // "Vehicule is an ambiguous base of VehiculeAmphibie"
        controleTechnique(amph);
 
        std::cout << "\n--- 5. Destruction automatique (LIFO) en sortie de bloc ---\n";
    }
 
    return 0;
}