Chapitre 2 : L'Héritage Simple, Multiple et en Diamant

#include <iostream>
#include <string>
 
// 1. Classe de Base
class Vehicule {
protected:
    std::string m_marque;
    int         m_annee;
 
public:
    Vehicule(std::string marque, int annee)
        : m_marque(std::move(marque)), m_annee(annee) {
        std::cout << "[Vehicule] Construction : " << m_marque << std::endl;
    }
 
    virtual ~Vehicule() {
        std::cout << "[Vehicule] Destruction : " << m_marque << std::endl;
    }
 
    void klaxonner() const {
        std::cout << m_marque << " : Pouet pouet !" << std::endl;
    }
};
 
// 2. Classe Dérivée (Héritage public)
class Voiture : public Vehicule {
private:
    int m_nbPortes;
 
public:
    // Appel explicite du constructeur de la base dans la liste d'initialisation
    Voiture(std::string marque, int annee, int nbPortes)
        : Vehicule(std::move(marque), annee), m_nbPortes(nbPortes) {
        std::cout << "[Voiture] Construction (" << m_nbPortes << " portes)" << std::endl;
    }
 
    ~Voiture() override {
        std::cout << "[Voiture] Destruction" << std::endl;
    }
 
    void afficher() const {
        // Accès direct possible aux membres protected de la base
        std::cout << "Voiture : " << m_marque << " de " << m_annee 
                  << " avec " << m_nbPortes << " portes." << std::endl;
    }
};
 
int main() {
    Voiture v("Renault", 2023, 5);
    v.klaxonner(); // Méthode héritée de Vehicule
    v.afficher();  // Méthode propre à Voiture
    return 0;
}

#include <iostream>
 
class EmetteurAudio {
public:
    void diffuser() const {
        std::cout << "Diffusion du son..." << std::endl;
    }
};
 
class EmetteurVideo {
public:
    void diffuser() const {
        std::cout << "Diffusion de la vidéo..." << std::endl;
    }
};
 
// Héritage multiple de deux bases ayant une méthode 'diffuser()'
class LecteurMultimedia : public EmetteurAudio, public EmetteurVideo {
public:
    void toutDiffuser() const {
        // diffuser(); ❌ ERREUR COMPILATION : Appel ambigu !
 
        // Solution : Levée d'ambiguïté explicite avec l'opérateur de portée ::
        EmetteurAudio::diffuser();
        EmetteurVideo::diffuser();
    }
};
 
int main() {
    LecteurMultimedia lecteur;
 
    // lecteur.diffuser(); // ❌ ERREUR : 'diffuser' is ambiguous
 
    // Appel direct via résolution de portée :
    lecteur.EmetteurAudio::diffuser();
    lecteur.EmetteurVideo::diffuser();
 
    std::cout << "--- Diffusion combinée ---\n";
    lecteur.toutDiffuser();
    return 0;
}

#include <iostream>
 
// 1. Classe de base au sommet du diamant
class Appareil {
protected:
    int m_idSerie;
 
public:
    Appareil(int id) : m_idSerie(id) {
        std::cout << "[Appareil] Créé avec ID: " << m_idSerie << std::endl;
    }
    virtual ~Appareil() = default;
 
    int getId() const { return m_idSerie; }
};
 
// 2. Héritage VIRTUEL pour Clavier et Ecran (partage de l'ancêtre unique Appareil)
class Clavier : virtual public Appareil {
public:
    Clavier(int id) : Appareil(id) {
        std::cout << "[Clavier] Initialisé" << std::endl;
    }
    void taperTexte() const { std::cout << "Saisie clavier..." << std::endl; }
};
 
class Ecran : virtual public Appareil {
public:
    Ecran(int id) : Appareil(id) {
        std::cout << "[Ecran] Initialisé" << std::endl;
    }
    void afficherImage() const { std::cout << "Affichage à l'écran..." << std::endl; }
};
 
// 3. Classe terminale dérivée : UN SEUL sous-objet Appareil en mémoire !
class TerminalPortable : public Clavier, public Ecran {
public:
    // ⚡ RÈGLE CRITIQUE : Dans un héritage virtuel, c'est la classe LA PLUS DÉRIVÉE
    // (ici TerminalPortable) qui est chargée d'appeler directement le constructeur
    // de la base virtuelle Appareil !
    TerminalPortable(int id)
        : Appareil(id), Clavier(id), Ecran(id) {
        std::cout << "[TerminalPortable] Prêt." << std::endl;
    }
 
    void statut() const {
        // ✅ Aucun conflit ! Appareil::getId() est unique et sans ambiguïté.
        std::cout << "Terminal #" << getId() << " en ligne." << std::endl;
    }
};
 
int main() {
    TerminalPortable tp(98765);
    tp.taperTexte();
    tp.afficherImage();
    tp.statut(); // Affiche bien l'ID unique 98765 sans ambiguïté
    return 0;
}