Exercices corrigés C++ – Programmation Orientée Objet | Partie 3

#include <iostream>
#include <string>

using namespace std;

// Définir la classe Produit
class Produit {
private:
    // Champ privé pour stocker le nom du produit
    string nom;
    // Champ privé pour stocker la quantité du produit	
    int quantite;     

public:
    // Constructeur par défaut
    Produit() : nom(""), quantite(0) {}

    // Constructeur pour initialiser le nom et la quantité du produit
    Produit(string nom, int quantite) {
        // Affecter le paramètre nom au champ nom
        this->nom = nom;
        // Affecter le paramètre quantite au champ quantite        
        this->quantite = quantite; 
    }

    // Méthode pour obtenir le nom du produit
    string getNom() {
        return nom; // Retourner la valeur du champ nom
    }

    // Méthode pour obtenir la quantité du produit
    int getQuantite() {
        // Retourner la valeur du champ quantite
        return quantite; 
    }
};

// Définir la classe Stock
class Stock {
private:
    // Champ privé pour stocker une liste d'objets Produit
    Produit* produits;
    // Taille actuelle du tableau	
    int taille;
    // Capacité maximale du tableau	
    int capacite;          

public:
    // Constructeur pour initialiser le champ produits
    Stock(int capacite) : capacite(capacite), taille(0) {
        // Créer un tableau dynamique de produits
        produits = new Produit[capacite]; 
    }

    // Destructeur pour libérer la mémoire
    ~Stock() {
        delete[] produits; // Libérer la mémoire allouée
    }

    // Méthode pour ajouter un produit à la liste des produits
    void addProduit(const Produit& produit) {
        if (taille < capacite) {
            // Ajouter le produit à la liste
            produits[taille++] = produit; 
        } else {
            cout << "Stock plein, impossible d'ajouter le produit." << endl;
        }
    }

    // Méthode pour supprimer un produit de la liste des produits
    void removeProduit(const string& nom) {
        for (int i = 0; i < taille; i++) {
            if (produits[i].getNom() == nom) {
                // Décaler les produits suivants
                for (int j = i; j < taille - 1; j++) {
                    produits[j] = produits[j + 1];
                }
                taille--; // Réduire la taille
                cout << "Produit " << nom << " supprimé." << endl;
                return;
            }
        }
        cout << "Produit " << nom << " non trouvé." << endl;
    }

    // Méthode pour vérifier si les produits en stock sont 
    // insuffisants
    void checkStock() {
        // Itérer dans la liste des produits
        for (int i = 0; i < taille; i++) {
            // Vérifier si la quantité du produit est inférieure ou
            // égale à 100
            if (produits[i].getQuantite() <= 100) {
                // Afficher un message indiquant que le produit est
                // en rupture de stock
                cout << produits[i].getNom() << " est en rupture de stock. La quantité actuelle: " << produits[i].getQuantite() << endl;
            }
        }
    }
};

// Définir la fonction Main
int main() {
    // Créer une nouvelle instance de la classe Stock avec une 
    // capacité de 10
    Stock stock(10);

    // Créer de nouveaux objets Produit avec nom et quantité
    Produit p1("Souris", 300);
    Produit p2("Clavier", 70);
    Produit p3("Tablette", 40);

    cout << "Ajouter trois produits en stock:" << endl;
    stock.addProduit(p1); // Ajouter produit 1
    stock.addProduit(p2); // Ajouter produit 2
    stock.addProduit(p3); // Ajouter produit 3

    cout << "\nVérifier la disponibilité des stocks:" << endl;

    // Vérifier et afficher les produits dont le stock est 
    // insuffisant
    stock.checkStock();

    cout << "\nSupprimer la tablette du stock!" << endl;

    // Supprimer le produit Tablette du stock
    stock.removeProduit("Tablette");

    cout<<"\nVérifier à nouveau la disponibilité des stocks:"<<endl;

    // Vérifier et afficher les produits dont le stock est 
    // insuffisant
    stock.checkStock();

    return 0; // Fin du programme
}

Sortie:

Ajouter trois produits en stock:

Vérifier la disponibilité des stocks:
Clavier est en rupture de stock. La quantité actuelle: 70
Tablette est en rupture de stock. La quantité actuelle: 40

Supprimer la tablette du stock!

Vérifier à nouveau la disponibilité des stocks:
Clavier est en rupture de stock. La quantité actuelle: 70

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

// Définir la classe Etudiant
class Etudiant {
private:
    string nom;
    int age;

public:
    // Constructeur pour initialiser le nom et l'âge de l'étudiant
    Etudiant(string nom, int age) : nom(nom), age(age) {}

    // Getter pour obtenir le nom
    string getNom() { return nom; }

    // Getter pour obtenir l'âge
    int getAge() { return age; }
};

// Définir la classe Enseignant
class Enseignant {
private:
    string nom;
    string matiere;

public:
    // Constructeur pour initialiser le nom et la matière de 
    // l'enseignant
    Enseignant(string nom, string matiere) : nom(nom), matiere(matiere) {}

    // Getter pour obtenir le nom de l'enseignant
    string getNom() { return nom; }

    // Getter pour obtenir la matière de l'enseignant
    string getMatiere() { return matiere; }
};

// Définir la classe Classe
class Classe {
private:
    string nomClasse;
    Enseignant enseignant;
    // Tableau d'étudiants de taille fixe
    Etudiant* etudiants[4]; 
    int nbEtudiants;

public:
    // Constructeur pour initialiser la classe et son enseignant
    Classe(string nomClasse, Enseignant enseignant) : nomClasse(nomClasse), enseignant(enseignant), nbEtudiants(0) {}

    // Ajouter un étudiant à la classe
    void addEtudiant(Etudiant* etudiant) {
        if (nbEtudiants < 4) {
            etudiants[nbEtudiants++] = etudiant;
        } else {
            cout << "La classe est pleine !" << endl;
        }
    }

    // Obtenir le nom de la classe
    string getNomClasse() { return nomClasse; }

    // Obtenir l'enseignant
    Enseignant getEnseignant() { return enseignant; }

    // Obtenir le nombre d'étudiants
    int getNbEtudiants() { return nbEtudiants; }
};

// Définir la classe Ecole
class Ecole {
private:
    // Tableau d'étudiants de taille fixe
    Etudiant* etudiants[10];
    // Tableau d'enseignants de taille fixe	
    Enseignant* enseignants[5];
    // Tableau de classes de taille fixe	
    Classe* classes[3]; 
    int nbEtudiants;
    int nbEnseignants;
    int nbClasses;

public:
    // Constructeur pour initialiser l'école
    Ecole() : nbEtudiants(0), nbEnseignants(0), nbClasses(0) {}

    // Ajouter un étudiant
    void addEtudiant(Etudiant* etudiant) {
        if (nbEtudiants < 10) {
            etudiants[nbEtudiants++] = etudiant;
        } else {
            cout << "L'école est pleine d'étudiants !" << endl;
        }
    }

    // Ajouter un enseignant
    void addEnseignant(Enseignant* enseignant) {
        if (nbEnseignants < 5) {
            enseignants[nbEnseignants++] = enseignant;
        } else {
            cout << "L'école est pleine d'enseignants !" << endl;
        }
    }

    // Ajouter une classe
    void addClasse(Classe* classe) {
        if (nbClasses < 3) {
            classes[nbClasses++] = classe;
        } else {
            cout << "L'école est pleine de classes !" << endl;
        }
    }

    // Supprimer un étudiant
    void removeEtudiant(Etudiant* etudiant) {
        for (int i = 0; i < nbEtudiants; i++) {
            if (etudiants[i] == etudiant) {
                for (int j = i; j < nbEtudiants - 1; j++) {
                    etudiants[j] = etudiants[j + 1];
                }
                nbEtudiants--;
                break;
            }
        }
    }

    // Supprimer un enseignant
    void removeEnseignant(Enseignant* enseignant) {
        for (int i = 0; i < nbEnseignants; i++) {
            if (enseignants[i] == enseignant) {
                for (int j = i; j < nbEnseignants - 1; j++) {
                    enseignants[j] = enseignants[j + 1];
                }
                nbEnseignants--;
                break;
            }
        }
    }

    // Supprimer une classe
    void removeClasse(Classe* classe) {
        for (int i = 0; i < nbClasses; i++) {
            if (classes[i] == classe) {
                for (int j = i; j < nbClasses - 1; j++) {
                    classes[j] = classes[j + 1];
                }
                nbClasses--;
                break;
            }
        }
    }

    // Obtenir le nombre d'étudiants
    int getNbEtudiants() { return nbEtudiants; }

    // Obtenir le nombre d'enseignants
    int getNbEnseignants() { return nbEnseignants; }

    // Obtenir le nombre de classes
    int getNbClasses() { return nbClasses; }
};

// Fonction principale
int main() {
    // Créer une nouvelle instance de la classe Ecole
    Ecole ecole;

    // Créer des objets Etudiant avec nom et âge
    Etudiant et1("Alex Babtise", 20);
    Etudiant et2("Bob Firok", 25);
    Etudiant et3("Emily Taylor", 22);
    Etudiant et4("Ali Binani", 23);

    // Ajouter les étudiants à l'école
    ecole.addEtudiant(&et1);
    ecole.addEtudiant(&et2);
    ecole.addEtudiant(&et3);
    ecole.addEtudiant(&et4);

    // Créer des objets Enseignant avec nom et matière
    Enseignant es1("Yohan Sinor", "Math");
    Enseignant es2("Thomas Fiza", "Anglais");
    Enseignant es3("Olivier Bibo", "Science");

    // Ajouter les enseignants à l'école
    ecole.addEnseignant(&es1);
    ecole.addEnseignant(&es2);
    ecole.addEnseignant(&es3);

    // Créer des objets Classe et ajouter des étudiants
    Classe classMath("Mathematics", es1);
    classMath.addEtudiant(&et1);
    classMath.addEtudiant(&et2);
    classMath.addEtudiant(&et3);
    classMath.addEtudiant(&et4);

    Classe classAnglais("Anglais", es2);
    classAnglais.addEtudiant(&et1);
    classAnglais.addEtudiant(&et2);
    classAnglais.addEtudiant(&et3);

    Classe classScience("Science", es3);
    classScience.addEtudiant(&et1);
    classScience.addEtudiant(&et2);
    classScience.addEtudiant(&et3);
    classScience.addEtudiant(&et4);

    // Ajouter les classes à l'école
    ecole.addClasse(&classMath);
    ecole.addClasse(&classAnglais);
    ecole.addClasse(&classScience);

    // Afficher les informations sur l'école
    cout << "Informations sur l'école:" << endl;
    cout << "Nombre d'étudiants: " << ecole.getNbEtudiants() << endl;
    cout << "Nombre d'enseignants: " << ecole.getNbEnseignants() << endl;
    cout << "Nombre de classes: " << ecole.getNbClasses() << endl << endl;

    // Afficher les informations sur les cours de mathématiques
    cout << "Informations sur les cours de mathématiques:" << endl;
    cout << "Nom de la classe: " << classMath.getNomClasse() << endl;
    cout << "Enseignant: " << classMath.getEnseignant().getNom() << endl;
    cout << "Nombre d'étudiants: " << classMath.getNbEtudiants() << endl << endl;

    // Afficher les informations sur les cours d'anglais
    cout << "Informations sur les cours d'anglais:" << endl;
    cout << "Nom de la classe: " << classAnglais.getNomClasse() << endl;
    cout << "Enseignant: " << classAnglais.getEnseignant().getNom() << endl;
    cout << "Nombre d'étudiants: " << classAnglais.getNbEtudiants() << endl << endl;

    // Afficher les informations sur les cours de sciences
    cout << "Informations sur les cours de sciences:" << endl;
    cout << "Nom de la classe: " << classScience.getNomClasse() << endl;
    cout << "Enseignant: " << classScience.getEnseignant().getNom() << endl;
    cout << "Nombre d'étudiants: " << classScience.getNbEtudiants() << endl << endl;

    // Supprimer un étudiant, un enseignant et une classe de l'école
    ecole.removeEtudiant(&et1);
    ecole.removeEnseignant(&es2);
    ecole.removeClasse(&classMath);

    // Afficher les informations mises à jour sur l'école après suppression
    cout << "Informations sur l'école après suppression d'un élève, d'un enseignant et d'une classe:" << endl;
    cout << "Nombre d'étudiants: " << ecole.getNbEtudiants() << endl;
    cout << "Nombre d'enseignants: " << ecole.getNbEnseignants() << endl;
    cout << "Nombre de classes: " << ecole.getNbClasses() << endl;

    return 0;
}

Sortie:

Informations sur l'école:
Nombre d'étudiants: 4
Nombre d'enseignants: 3
Nombre de classes: 3

Informations sur les cours de mathématiques:
Nom de Class: Mathematics
Enseignant: Yohan Sinor
Nombre d'étudiants: 4

Informations sur les cours d'anglais:
Nom de Class: Anglais
Enseignant: Thomas Fiza
Nombre d'étudiants: 3

Informations sur les cours de sciences:
Nom de Class: Science
Enseignant: Olivier Bibo
Nombre d'étudiants: 4

Informations sur l'école après suppression d'un élève, d'un enseignant et d'une classe:
Nombre d'étudiants: 3
Nombre d'enseignants: 2
Nombre de classes: 2

#include <iostream>
#include <string>
#include <cstdlib> // Pour rand()
#include <ctime>   // Pour time()

using namespace std;

// Définir la taille maximale de la bibliothèque musicale
// Vous pouvez ajuster cette valeur en fonction de vos besoins
const int MAX_CHANSONS = 100;  

// Définir la classe Chanson
class Chanson {
private:
    // Champs privés pour stocker le titre et l'artiste de la chanson
    string title;
    string artist;

public:
    // Constructeur pour initialiser les champs titre et artiste
    Chanson(string title = "", string artist = "") {
        this->title = title;
        this->artist = artist;
    }

    // Méthode Getter pour récupérer le titre de la chanson
    string getTitre() const {
        return title;
    }

    // Méthode pour modifier le titre de la chanson
    void setTitre(string title) {
        this->title = title;
    }

    // Méthode Getter pour récupérer l'artiste de la chanson
    string getArtist() const {
        return artist;
    }

    // Méthode pour modifier le nom de l'artiste de la chanson
    void setArtist(string artist) {
        this->artist = artist;
    }
};

// Définir la classe BiblioMusicale
class BiblioMusicale {
private:
    // Tableau statique pour stocker les chansons
    Chanson chansons[MAX_CHANSONS];
    // Pour suivre le nombre actuel de chansons dans la bibliothèque
    int nbChansons; 

public:
    // Constructeur pour initialiser la bibliothèque musicale
    BiblioMusicale() {
        // Initialiser le nombre de chansons à 0
        nbChansons = 0; 
    }

    // Méthode pour ajouter une chanson à la bibliothèque
    void addChanson(const Chanson &song) {
        if (nbChansons < MAX_CHANSONS) {
            chansons[nbChansons++] = song;
        } else {
            cout << "La bibliothèque musicale est pleine !" << endl;
        }
    }

    // Méthode pour supprimer une chanson de la bibliothèque
    void removeChanson(const Chanson &song) {
        int indexToRemove = -1;
        for (int i = 0; i < nbChansons; i++) {
            if (chansons[i].getTitre() == song.getTitre() && chansons[i].getArtist() == song.getArtist()) {
                indexToRemove = i;
                break;
            }
        }

        if (indexToRemove != -1) {
            for (int i = indexToRemove; i < nbChansons - 1; i++) {
                // Décaler les chansons
                chansons[i] = chansons[i + 1]; 
            }
            nbChansons--; // Réduire le nombre de chansons
        } else {
            cout<<"Chanson non trouvée dans la bibliothèque."<<endl;
        }
    }

    // Méthode pour obtenir la liste de toutes les chansons de la 
    // bibliothèque
    void getChansons() const {
        for (int i = 0; i < nbChansons; i++) {
            cout << chansons[i].getTitre() << " par " << chansons[i].getArtist() << endl;
        }
    }

    // Méthode pour lire une chanson aléatoire de la bibliothèque
    void lireChansonAleatoire() const {
        if (nbChansons == 0) {
            cout << "Il n'y a pas de chansons à lire." << endl;
            return;
        }
        // Initialiser le générateur aléatoire
        srand(time(0));
        // Générer un index aléatoire		
        int index = rand() % nbChansons; 
        cout << "Lire: " << chansons[index].getTitre() << " par " << chansons[index].getArtist() << endl;
    }
};

// Définir la fonction Main
int main() {
    // Créer une nouvelle instance de la classe BiblioMusicale
    BiblioMusicale biblio;

    // Ajouter des chansons à la bibliothèque musicale
    biblio.addChanson(Chanson("Un clair de lune", "Jean Chérasse"));
    biblio.addChanson(Chanson("Cadet Rousselle", "André Hunebelle"));
    biblio.addChanson(Chanson("Help!", "Richard Lester"));
    biblio.addChanson(Chanson("Baisers volés", "François Truffaut"));
    biblio.addChanson(Chanson("Je t'aime", "Serge Gainsbourg"));
    biblio.addChanson(Chanson("Staying Alive", "Michel Blanc"));

    // Afficher toutes les chansons de la bibliothèque musicale
    cout << "Toutes les chansons:" << endl;
    biblio.getChansons();

    // Lire et afficher trois fois une chanson choisie au hasard dans 
    // la bibliothèque
    cout << "\nLecture d'une chanson aléatoire:" << endl;
    biblio.lireChansonAleatoire();
    cout << endl;
    biblio.lireChansonAleatoire();
    cout << endl;
    biblio.lireChansonAleatoire();

    return 0;
}

Sortie:

Toutes les chansons:
Un clair de lune par Jean Chérasse
Cadet Rousselle par André Hunebelle
Help! par Richard Lester
Baisers volés par François Truffaut
Je t'aime par Serge Gainsbourg
Staying Alive par Michel Blanc

Lecture d'une chanson aléatoire:
Lire: Help! par Richard Lester

Lire: Baisers volés par François Truffaut

Lire: Help! par Richard Lester

#include <iostream>
#include <cmath> // Pour la fonction sqrt et M_PI

// Définir la classe Forme comme une classe abstraite
class Forme {
public:
    // Méthode abstraite pour récupérer la surface de la forme
    // Cette méthode doit être implémentée par toute sous-classe de 
    // Forme
    virtual double getSurface() = 0;

    // Méthode abstraite permettant d'obtenir le périmètre de la 
    // forme
    // Cette méthode doit être implémentée par toute sous-classe de 
    // Forme
    virtual double getPerimeter() = 0;
};

// Définir la classe Rectangle, qui hérite de la classe Forme
class Rectangle : public Forme {
private:
    // Champs privés pour stocker la longueur et la largeur du 
    // rectangle
    double longueur;
    double largeur;

public:
    // Constructeur pour initialiser la longueur et la largeur du 
    // rectangle
    Rectangle(double longueur, double largeur) {
        // Définir le champ longueur à la longueur fournie
        this->longueur = longueur; 
        // Définir le champ largeur à la largeur fournie
        this->largeur = largeur;   
    }

    // Méthode pour calculer et renvoyer la surface du rectangle
    double getSurface() override {
        // Calculer la surface en multipliant la longueur et la 
        // largeur
        return longueur * largeur;
    }

    // Méthode pour calculer et renvoyer le périmètre du rectangle
    double getPerimeter() override {
        // Calculer le périmètre à l'aide de la formule 2 * (longueur 
        // + largeur)
        return 2 * (longueur + largeur);
    }
};

// Définir la classe Cercle, qui hérite de la classe Forme
class Cercle : public Forme {
private:
    // Champ privé pour stocker le rayon du cercle
    double rayon;

public:
    // Constructeur pour initialiser le rayon du cercle
    Cercle(double rayon) {
        // Attribuer au champ rayon le rayon fourni
        this->rayon = rayon; 
    }

    // Méthode pour calculer et renvoyer la surface du cercle
    double getSurface() override {
        // Calculer la surface en utilisant la formule π * rayon^2
        return M_PI * rayon * rayon;
    }

    // Méthode pour calculer le périmètre du cercle
    double getPerimeter() override {
        // Calculer le périmètre en utilisant la formule 2*π*rayon
        return 2 * M_PI * rayon;
    }
};

// Définir la classe Triangle, qui hérite de la classe Forme
class Triangle : public Forme {
private:
    // Champs privés pour stocker les côtés du triangle
    double c1;
    double c2;
    double c3;

public:
    // Constructeur pour initialiser les côtés du triangle
    Triangle(double c1, double c2, double c3) {
        this->c1 = c1;
        this->c2 = c2;
        this->c3 = c3;
    }

    // Méthode pour calculer et renvoyer la surface du triangle
    double getSurface() override {
        // Calculer le semi-périmètre
        double s = (c1 + c2 + c3) / 2;

        // Calculer la surface à l'aide de la formule de Heron
        return sqrt(s * (s - c1) * (s - c2) * (s - c3));
    }

    // Méthode pour calculer et renvoyer le périmètre du triangle
    double getPerimeter() override {
        // Calculer le périmètre en additionnant les côtés
        return c1 + c2 + c3;
    }
};

// Définir la fonction Main
int main() {
    // Créer un rectangle de longueur 15 et de largeur 20
    Forme* rectangle = new Rectangle(15, 20);

    // Créer un cercle de rayon 5
    Forme* circle = new Cercle(5);

    // Créer un triangle dont les côtés sont 5, 7 et 9
    Forme* triangle = new Triangle(5, 7, 9);

    std::cout << "\nSurface et périmètre de différentes formes:";

    // Afficher les détails et calculs du rectangle
    std::cout << "\nRectangle:";
    std::cout << "\nSurface: " << rectangle->getSurface();
    std::cout << "\nPérimètre: " << rectangle->getPerimeter();

    // Afficher les détails et calculs du cercle
    std::cout << "\n\nCercle:";
    std::cout << "\nSurface: " << circle->getSurface();
    std::cout << "\nPérimètre: " << circle->getPerimeter();

    // Afficher les détails et calculs du triangle
    std::cout << "\n\nTriangle:";
    std::cout << "\nSurface: " << triangle->getSurface();
    std::cout << "\nPérimètre: " << triangle->getPerimeter();

    // Libérer la mémoire allouée
    delete rectangle;
    delete circle;
    delete triangle;

    return 0;
}

Sortie:

Surface et périmètre de différentes formes:

Rectangle:
Surface: 300.0
Périmètre: 70.0

Cercle:
Surface: 78.53981633974483
Périmètre: 31.41592653589793

Triangle:
Surface: 17.41228014936585
Périmètre: 21.0

#include <iostream>
#include <string>

// Définir la classe Avis pour représenter un avis sur un film
class Avis {
private:
    // Texte de l'avis
    std::string textAvis;
    // Nom de la personne ayant donné l'avis	
    std::string nomAvis;
    // Note donnée par l'utilisateur	
    double note;          

public:
    // Constructeur par défaut
    Avis() : textAvis(""), nomAvis(""), note(0.0) {}

    // Constructeur avec paramètres pour initialiser les champs
    Avis(const std::string& textAvis, const std::string& nomAvis, double note) {
        // Initialiser le texte de l'avis
        this->textAvis = textAvis; 
        // Initialiser le nom de l'avis
        this->nomAvis = nomAvis;   
        // Initialiser la note
        this->note = note;         
    }

    // Méthode pour récupérer le texte de l'avis
    std::string getTextAvis() const {
        return textAvis; // Retourner le texte de l'avis
    }

    // Méthode pour récupérer le nom de l'avis
    std::string getNomAvis() const {
        return nomAvis; // Retourner le nom de l'avis
    }

    // Méthode pour récupérer la note
    double getNote() const {
        return note; // Retourner la note
    }
};

// Définir la classe Film pour représenter un film
class Film {
private:
    // Titre du film
    std::string titre;  
    // Nom du directeur	
    std::string directeur;
    // Tableau pour stocker les acteurs	
    std::string acteurs[10]; 
	// Nombre d'acteurs dans le film
    int nombreActeurs;
    // Pointeur vers un tableau d'avis	
    Avis* avis;  
    // Nombre d'avis donnés	
    int nombreAvis;  
    // Taille maximale du tableau d'avis	
    int tailleAvis;          

public:
    // Constructeur pour initialiser le film avec son titre, 
    // directeur et acteurs
    Film(const std::string& titre, const std::string& directeur, const std::string acteurs[], int tailleActeurs) 
        : titre(titre), directeur(directeur), nombreActeurs(tailleActeurs), nombreAvis(0), tailleAvis(10) {
        // Copier les acteurs fournis dans le tableau d'acteurs
        for (int i = 0; i < tailleActeurs; i++) {
            // Initialiser le tableau d'acteurs
            this->acteurs[i] = acteurs[i]; 
        }
        // Allouer un tableau pour les avis
        avis = new Avis[tailleAvis]; 
    }

    // Méthode pour ajouter un avis à la liste des avis
    void addAvis(const Avis& a) {
        // Vérifier si l'espace est disponible
        if (nombreAvis < tailleAvis) { 
            avis[nombreAvis] = a; // Ajouter l'avis
            nombreAvis++; // Incrémenter le nombre d'avis
        }
    }

    // Méthode pour récupérer les avis
    Avis* getAvis() const {
        return avis; // Retourner le tableau d'avis
    }

    // Méthode pour récupérer le titre du film
    std::string getTitre() const {
        return titre; // Retourner le titre
    }

    // Méthode pour récupérer le directeur du film
    std::string getDirecteur() const {
        return directeur; // Retourner le directeur
    }

    // Méthode pour récupérer les acteurs du film
    std::string* getActeurs() {
        return acteurs; // Retourner le tableau d'acteurs
    }

    // Méthode pour obtenir le nombre d'avis
    int getNombreAvis() const { 
        return nombreAvis; // Retourner le nombre d'avis
    }

    // Destructeur pour libérer la mémoire allouée
    ~Film() {
        delete[] avis; // Libérer le tableau d'avis
    }
};

// Définir la fonction Main
int main() {
    // Déclarer et initialiser un tableau d'acteurs
    std::string acteurs[] = {"Pierre Pelletier", "Pierre Mondy"};

    // Créer un objet Film avec un titre, un directeur et une liste 
    // d'acteurs
    Film f1("La Roue", "Jean Servais", acteurs, 2);

    // Créer plusieurs objets d'avis pour le film
    Avis avis1("Excellent film!", "Alex Babtise", 5.0);
    Avis avis2("Fortement recommandé!", "Jean Zino", 4.5);
    Avis avis3("Un film magnifique", "Bob Polib", 4.0);

    // Ajouter les avis au film
    f1.addAvis(avis1);
    f1.addAvis(avis2);
    f1.addAvis(avis3);

    // Afficher les avis pour le film
    std::cout << "\nAvis pour '"<<f1.getTitre()<<"':" << std::endl;

    // Boucle pour afficher chaque avis
    for (int i = 0; i < f1.getNombreAvis(); i++) { 
        // Récupérer l'avis à l'index i
        Avis a = f1.getAvis()[i]; 
        // Afficher l'avis
        std::cout << a.getTextAvis() << " par " << a.getNomAvis() << " - " << a.getNote() << std::endl; 
    }

    return 0; // Fin du programme
}

Sortie:

Avis pour 'La Roue':
Excellent film! par Alex Babtise - 5.0
Fortement recommandé! par Jean Zino - 4.5
Un film magnifique par Bob Polib - 4.0