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

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

using namespace std;

// Taille maximale pour les vols et les hôtels
const int MAX_VOL = 100;
const int MAX_HOTEL = 100;

// Classe Vol
class Vol {
    // Attributs privés
    int numVol;
    string nomPassager;
    string origin;
    string destination;
    string date;
    int nbrPassagers;
    double prix;
    int numConf;  // Numéro de confirmation

public:
    // Constructeur
    Vol(int nv, string np, string o, string d, string dt, int npg, double p)
        : numVol(nv), nomPassager(np), origin(o), destination(d), date(dt), nbrPassagers(npg), prix(p), numConf(0) {}

    // Méthode pour récupérer le numéro de vol
    int getNumVol() const { return numVol; }

    // Méthode pour récupérer le nom du passager
    string getNomPassager() const { return nomPassager; }

    // Méthode pour récupérer l'origine du vol
    string getOrigin() const { return origin; }

    // Méthode pour récupérer la destination du vol
    string getDestination() const { return destination; }

    // Méthode pour récupérer la date du vol
    string getDate() const { return date; }

    // Méthode pour récupérer le nombre de passagers
    int getNbrPassagers() const { return nbrPassagers; }

    // Méthode pour récupérer le prix du vol
    double getPrix() const { return prix; }

    // Méthode pour définir et récupérer le numéro de confirmation
    void setNumConf(int nc) { numConf = nc; }
    int getNumConf() const { return numConf; }
};

// Classe Hotel
class Hotel {
    // Attributs privés
    int hotelId;
    string nomPersonne;
    string lieu;
    string dateArriv;
    string dateDepart;
    int nbrPersonne;
    double prix;
    int numConf;  // Numéro de confirmation

public:
    // Constructeur
    Hotel(int hId, string np, string l, string da, string dd, int npers, double p)
        : hotelId(hId), nomPersonne(np), lieu(l), dateArriv(da), dateDepart(dd), nbrPersonne(npers), prix(p), numConf(0) {}

    // Méthode pour récupérer le numéro de confirmation
    void setNumConf(int nc) { numConf = nc; }
    int getNumConf() const { return numConf; }
};

// Classe Voyage
class Voyage {
    // Attributs privés : tableaux statiques
    Vol* vols[MAX_VOL];
    Hotel* hotels[MAX_HOTEL];
    int volCount;     // Compteur pour les vols
    int hotelCount;   // Compteur pour les hôtels

public:
    // Constructeur
    Voyage() : volCount(0), hotelCount(0) {
        // Initialiser les tableaux à nullptr
        for (int i = 0; i < MAX_VOL; ++i) vols[i] = nullptr;
        for (int i = 0; i < MAX_HOTEL; ++i) hotels[i] = nullptr;
        // Initialiser le générateur de nombres aléatoires
        srand(time(0));  
    }

    // Méthode pour rechercher des vols
    void rechercherVols(string orig, string dest, string date, int nbrVoyageur) {
        cout << "Recherche de vols de " << orig << " à " << dest << " le " << date << " pour " << nbrVoyageur << " voyageurs." << endl;
    }

    // Méthode pour rechercher des hôtels
    void rechercherHotels(string lieu, string dateArriv, string dateDepart, int nbrPers) {
        cout << "Recherche d'hôtels dans " << lieu << " de " << dateArriv << " à " << dateDepart << " pour " << nbrPers << " personnes." << endl;
    }

    // Méthode pour réserver un vol
    void reserverVol(int numVol, string nomPassager, string orig, string dest, string date, int nbrVoyageur, double prix) {
        if (volCount < MAX_VOL) {
            vols[volCount] = new Vol(numVol, nomPassager, orig, dest, date, nbrVoyageur, prix);
            int numConf = generateConfirmationNumber();
            vols[volCount]->setNumConf(numConf);
            cout << "Vol réservé ! Numéro de confirmation: " << numConf << endl;
            ++volCount;
        } else {
            cout << "Limite de réservation de vols atteinte !" << endl;
        }
    }

    // Méthode pour réserver un hôtel
    void reserverHotel(int hotelId, string nomPersonne, string lieu, string dateArriv, string dateDepart, int nbrPersonne, double prix) {
        if (hotelCount < MAX_HOTEL) {
            hotels[hotelCount] = new Hotel(hotelId, nomPersonne, lieu, dateArriv, dateDepart, nbrPersonne, prix);
            int numConf = generateConfirmationNumber();
            hotels[hotelCount]->setNumConf(numConf);
            cout << "Hôtel réservé ! Numéro de confirmation: " << numConf << endl;
            ++hotelCount;
        } else {
            cout << "Limite de réservation d'hôtels atteinte !" << endl;
        }
    }

    // Méthode pour annuler une réservation
    void annulerReservation(int numConf) {
        // Recherche dans les vols
        for (int i = 0; i < volCount; ++i) {
            if (vols[i] != nullptr && vols[i]->getNumConf() == numConf) {
                delete vols[i];
                vols[i] = nullptr;
                cout << "Annulation de la réservation de vol avec le numéro de confirmation " << numConf << endl;
                return;
            }
        }

        // Recherche dans les hôtels
        for (int i = 0; i < hotelCount; ++i) {
            if (hotels[i] != nullptr && hotels[i]->getNumConf() == numConf) {
                delete hotels[i];
                hotels[i] = nullptr;
                cout << "Annulation de la réservation d'hôtel avec le numéro de confirmation " << numConf << endl;
                return;
            }
        }

        // Si aucune réservation n'est trouvée
        cout << "Aucune réservation trouvée avec le numéro de confirmation " << numConf << endl;
    }

    // Méthode pour générer un numéro de confirmation aléatoire
    int generateConfirmationNumber() {
        // Génère un nombre entre 100000 et 999999
        return rand() % 900000 + 100000;  
    }
};

int main() {
    // Créer un objet Voyage
    Voyage app;

    // Recherche de vols
    app.rechercherVols("Paris", "Casablanca", "2024-02-01", 1);

    // Recherche d'hôtels
    app.rechercherHotels("Casablanca", "2024-09-01", "2024-10-05", 2);

    // Réservation de vols
    app.reserverVol(96342588, "Alex Babtise", "Paris", "Casablanca", "2024-08-01", 1, 600.00);

    // Réservation d'hôtels
    app.reserverHotel(98765432, "Martin Nadine", "Casablanca", "2024-09-01", "2024-09-05", 1, 150.00);

    // Annulation d'une réservation
    // Numéro de confirmation fictif
    app.annulerReservation(123456);

    return 0;
}

Sortie:

Recherche de vols de Paris à Casablanca le 2024-02-01 pour 1 voyageurs.
Recherche d'hôtels dans Casablanca de 2024-09-01 à 2024-10-05 pour 2 personnes.
Vol réservé ! Numéro de confirmation: 100881
Vol réservé ! Numéro de confirmation: 455285
Hôtel réservé ! Numéro de confirmation: 799037
Aucune réservation n'a été trouvée avec le numéro de confirmation 90945840.

#include <iostream>
#include <string>

using namespace std;

const int MAX_PLATS = 100; // Capacité maximale du menu

// Définir la classe Restaurant
class Restaurant {
private:
    // Déclarez des tableaux pour stocker les plats du menu, les 
    // prix, les notes, et le nombre de plats
    string menu[MAX_PLATS];
    double prix[MAX_PLATS];
    int notes[MAX_PLATS];
    int nbrDePlats[MAX_PLATS];
    // Nombre actuel de plats dans le menu
    int totalPlats;  

public:
    // Constructeur pour initialiser les tableaux et la variable 
    // totalPlats
    Restaurant() {
        totalPlats = 0;  // Aucun plat au début
    }

    // Méthode pour ajouter un plat au menu
    void addPlat(string elem, double prix_p) {
        if (totalPlats < MAX_PLATS) {
            // Ajouter le plat au menu
            menu[totalPlats] = elem;
            // Ajouter le prix à la liste de prix
            prix[totalPlats] = prix_p;
            // Initialiser la note du plat à 0
            notes[totalPlats] = 0;
            // Initialiser le compteur du plat à 0
            nbrDePlats[totalPlats] = 0;
            totalPlats++;
        } else {
            cout << "Le menu est plein, impossible d'ajouter plus de plats." << endl;
        }
    }

    // Méthode pour supprimer un plat du menu
    void removePlat(string plat) {
        int index = -1;
        // Trouver l'index du plat dans le tableau menu
        for (int i = 0; i < totalPlats; i++) {
            if (menu[i] == plat) {
                index = i;
                break;
            }
        }

        if (index >= 0) {
            // Supprimer le plat en décalant les éléments suivants 
            // dans les tableaux
            for (int i = index; i < totalPlats - 1; i++) {
                menu[i] = menu[i + 1];
                prix[i] = prix[i + 1];
                notes[i] = notes[i + 1];
                nbrDePlats[i] = nbrDePlats[i + 1];
            }
            totalPlats--;  // Réduire le nombre de plats
        }
    }

    // Méthode pour ajouter une note à un plat
    void addNote(string plat, int note) {
        int index = -1;
        // Trouver l'index du plat dans le menu
        for (int i = 0; i < totalPlats; i++) {
            if (menu[i] == plat) {
                index = i;
                break;
            }
        }

        if (index >= 0) {
            // Mettre à jour la note du plat et le compteur de plats
            notes[index] += note;
            nbrDePlats[index]++;
        }
    }

    // Méthode pour obtenir la note moyenne d'un plat
    double getMoyenneNote(string plat) {
        int index = -1;
        // Trouver l'index du plat dans le menu
        for (int i = 0; i < totalPlats; i++) {
            if (menu[i] == plat) {
                index = i;
                break;
            }
        }

        if (index >= 0 && nbrDePlats[index] > 0) {
            // Calculer la note moyenne du plat
            return (double)notes[index] / nbrDePlats[index];
        } else {
            return 0.0;
        }
    }

    // Méthode pour afficher le menu
    void afficherMenu() {
        for (int i = 0; i < totalPlats; i++) {
            // Afficher le plat et son prix
            cout << menu[i] << ": €" << prix[i] << endl;
        }
    }

    // Méthode de calcul de la note moyenne de tous les plats
    double calculerNoteMoyenne() {
        double noteTotale = 0;
        int nbrNote = 0;

        // Parcourir les notes de tous les plats
        for (int i = 0; i < totalPlats; i++) {
            noteTotale += notes[i];
            nbrNote += nbrDePlats[i];
        }

        // Calculer la note moyenne globale
        return nbrNote > 0 ? noteTotale / nbrNote : 0.0;
    }
};

// Définir la fonction Main
int main() {
    // Créer un nouvel objet Restaurant
    Restaurant restaurant;

    // Ajouter des plats au menu
    restaurant.addPlat("Bœuf à la ficelle", 15.00);
    restaurant.addPlat("Pizza", 8.99);
    restaurant.addPlat("Salade", 5.00);

    cout << "Menu: Plats et prix" << endl;
    restaurant.afficherMenu();

    // Ajouter des notes aux plats
    restaurant.addNote("Bœuf à la ficelle", 4);
    restaurant.addNote("Bœuf à la ficelle", 5);
    restaurant.addNote("Pizza", 3);
    restaurant.addNote("Pizza", 4);
    restaurant.addNote("Salade", 2);

    // Obtenir et afficher la note moyenne des plats
    cout << "Note moyenne pour Pizza: " << restaurant.getMoyenneNote("Pizza") << endl;
    cout << "Note moyenne pour Salade: " << restaurant.getMoyenneNote("Salade") << endl;
    cout << "Note moyenne de tous les plats: " << restaurant.calculerNoteMoyenne() << endl;

    // Supprimer un plat
    cout << "\nSupprimer 'Pizza' du menu." << endl;
    restaurant.removePlat("Pizza");

    cout << "\nMenu actualisé:" << endl;
    restaurant.afficherMenu();

    return 0;
}

Sortie:

Menu: Plats et prix
Bœuf à la ficelle: 15.00€
Pizza: 8,99€
Salade: 5.0€
Note moyenne pour Pizza: 3.5
Note moyenne pour Salad: 2
Note moyenne: 3.56987155
Supprimer 'Pizza' du menu.

Menu actualisé:
Bœuf à la ficelle: 15.00€
Salade: 5.0€

#include <iostream>
#include <string>

using namespace std;

// Définir la classe CompteBancaire
class CompteBancaire {
private:
    // Attribut pour le numéro de compte
    string numCompte;
    // Attribut pour le nom du titulaire du compte
    string titulaireCompte;
    // Attribut pour le solde du compte
    double solde;

public:
    // Constructeur pour initialiser l'objet CompteBancaire
    CompteBancaire(string numCompte, string titulaireCompte, double initialBalance) {
        this->numCompte = numCompte;
        this->titulaireCompte = titulaireCompte;
        this->solde = initialBalance;
    }

    // Méthode pour déposer de l'argent sur le compte
    void deposer(double montant) {
        if (montant > 0) {
            solde += montant;
            cout << "Déposés: " << montant << ". Nouveau solde: " << solde << endl;
        } else {
            cout << "Le montant déposé doit être positif." << endl;
        }
    }

    // Méthode pour retirer de l'argent du compte
    void retirer(double montant) {
        if (montant > 0 && montant <= solde) {
            solde -= montant;
            cout << "Retrait: " << montant << ". Nouveau solde: " << solde << endl;
        } else {
            cout << "Solde insuffisant ou montant invalide." << endl;
        }
    }

    // Méthode pour vérifier le solde du compte
    double checkSolde() const {
        return solde;
    }

    // Méthode pour récupérer le numéro de compte
    string getNumCompte() const {
        return numCompte;
    }

    // Méthode pour récupérer le nom du titulaire du compte
    string getTitulaireCompte() const {
        return titulaireCompte;
    }
};

// Définir la classe CompteEpargne qui hérite de CompteBancaire
class CompteEpargne : public CompteBancaire {
private:
    // Attribut pour le taux d'intérêt
    double tauxInter;

public:
    // Constructeur pour initialiser l'objet CompteEpargne
    CompteEpargne(string numCompte, string titulaireCompte, double soldeInitial, double tauxInter)
        : CompteBancaire(numCompte, titulaireCompte, soldeInitial) {
        this->tauxInter = tauxInter;
    }

    // Méthode pour appliquer l'intérêt au solde
    void appliquerInter() {
        // Calculer l'intérêt
        double inter = checkSolde() * tauxInter / 100;
        deposer(inter);  // Ajouter de l'intérêt au solde
        cout << "Intérêts appliqués: " << inter << ". Nouveau solde: " << checkSolde() << endl;
    }

    // Méthode Getter pour le taux d'intérêt
    double getTauxInter() const {
        return tauxInter;
    }

    // Méthode Setter pour le taux d'intérêt
    void setTauxInter(double tauxInter) {
        if (tauxInter > 0) {
            this->tauxInter = tauxInter;
        } else {
            cout << "Le taux d'intérêt doit être positif." << endl;
        }
    }
};

// Définir la fonction Main
int main() {
    // Créer un objet CompteBancaire
    CompteBancaire cpt("902456001", "Alex Babtise", 1500.0);
    // Vérifier le solde
    cout << "Solde actuel: " << cpt.checkSolde() << endl;

    cpt.deposer(4000.0);  // Déposer de l'argent
    cpt.retirer(3000.0);  // Retirer de l'argent
    // Vérifier le solde
    cout << "Solde actuel: " << cpt.checkSolde() << endl;

    // Créer un objet CompteEpargne
    CompteEpargne epargne("555236123", "Emily Leona", 3000.0, 5.0);
    // Appliquer l'intérêt
    epargne.appliquerInter();
    // Vérifier le solde
    cout << "Compte d'épargne solde: " << epargne.checkSolde() << endl;

    return 0;
}

Sortie:

Solde actuel: 1500.0
Déposés: 4000.0. Nouveau solde: 5500.0
Retrait: 3000.0. Nouveau solde: 2500.0
Solde actuel: 2500.0
Déposés: 150.0. Nouveau solde: 3150.0
Intérêts appliqués: 150.0. Nouveau solde: 3150.0
Compte d'épargne solde: 3150.0

#include <iostream>
#include <string>

using namespace std;

// Définir la classe Vehicule
class Vehicule {
protected:
    // Attribut pour la marque du véhicule
    string marque;
    // Attribut pour le modèle du véhicule
    string model;
    // Attribut pour l'année du véhicule
    int an;

public:
    // Constructeur pour initialiser l'objet Vehicule
    Vehicule(string marque, string model, int an) {
        this->marque = marque;
        this->model = model;
        this->an = an;
    }

    // Méthode pour afficher les détails du véhicule
    virtual void afficherDetails() const {
        cout << "Les détails du véhicule:" << endl;
        cout << "Marque: " << marque << endl;
        cout << "Modèle: " << model << endl;
        cout << "Année: " << an << endl;
    }

    // Méthode Getter pour marque du véhicule
    string getMarque() const {
        return marque;
    }

    // Méthode Getter pour le modèle du véhicule
    string getModel() const {
        return model;
    }

    // Méthode Getter pour l'année du véhicule
    int getAn() const {
        return an;
    }
};

// Définir la classe Voiture qui hérite de Vehicule
class Voiture : public Vehicule {
private:
    // Attribut pour la taille du coffre de la voiture
    double tailleCoffre;

public:
    // Constructeur pour initialiser l'objet Voiture
    Voiture(string marque, string model, int an, double tailleCoffre)
        : Vehicule(marque, model, an) {
        this->tailleCoffre = tailleCoffre;
    }

    // Surcharger la méthode afficherDetails pour inclure la taille 
    // du coffre
    void afficherDetails() const override {
        // Appeler la méthode de la classe mère
        Vehicule::afficherDetails();
        cout << "Taille du coffre: " << tailleCoffre << " mètres cubes" << endl;
    }

    // Méthode pour récupérer la taille du coffre
    double getTailleCoffre() const {
        return tailleCoffre;
    }

    // Méthode pour définir la taille du coffre
    void setTailleCoffre(double tailleCoffre) {
        if (tailleCoffre > 0) {
            this->tailleCoffre = tailleCoffre;
        } else {
            cout << "La taille du coffre doit être positive." << endl;
        }
    }
};

// Définir la classe Camion qui hérite de Vehicule
class Camion : public Vehicule {
private:
    // Attribut pour la capacité de charge du camion
    double capacitCharge;

public:
    // Constructeur pour initialiser l'objet Camion
    Camion(string marque, string model, int an, double capacitCharge)
        : Vehicule(marque, model, an) {
        this->capacitCharge = capacitCharge;
    }

    // Surcharger la méthode afficherDetails pour inclure la capacité 
    // de charge
    void afficherDetails() const override {
        // Appeler la méthode de la classe mère
        Vehicule::afficherDetails();
        cout << "Capacité de charge: " << capacitCharge << " tonnes" << endl;
    }

    // Méthode pour récupérer la capacité de charge
    double getCapacitCharge() const {
        return capacitCharge;
    }

    // Méthode pour définir la capacité de charge
    void setCapacitCharge(double capacitCharge) {
        if (capacitCharge > 0) {
            this->capacitCharge = capacitCharge;
        } else {
            cout << "La capacité de charge doit être positive." << endl;
        }
    }
};

// Définir la fonction main
int main() {
    // Créer un objet Voiture
    Voiture v("BMW", "Série 6", 2014, 16.15);
    // Afficher les détails de la voiture
    v.afficherDetails(); 

    // Créer un objet Camion
    Camion c("Mercedes", "Arocs", 2024, 4.5);
    // Afficher les détails du camion
    c.afficherDetails(); 

    return 0;
}

Sortie:

Les détails du véhicule:
Marque: BMW
Modèle: Série 6
Année: 2014
Taille du coffre: 16.15 mètres cubes
Les détails du véhicule:
Marque: Mercedes
Modèle: Arocs
Année: 2024
Capacité de charge: 4.5 tons

#include <iostream>
#include <string>

using namespace std;

// Définir la classe Client
class Client {
private:
    // Attributs pour le nom, l'email et l'historique des achats du 
    // client
    string nom;
    string email;
    // Utilisation d'un tableau pour stocker l'historique des achats
    double historiqueAchats[100]; 
    // Compteur pour le nombre d'achats
    int nombreAchats; 

public:
    // Constructeur pour initialiser le nom et l'email du client
    Client(const string& nom, const string& email) : nombreAchats(0) {
        this->nom = nom;
        this->email = email;
    }

    // Méthode pour ajouter un achat à l'historique des achats
    // Ajout de virtual ici
    virtual void addAchat(double montant) { 
        // Vérifier la capacité du tableau
        if (nombreAchats < 100) { 
            historiqueAchats[nombreAchats] = montant;
            nombreAchats++;
        } else {
            cout << "L'historique des achats est plein." << endl;
        }
    }

    // Méthode de calcul des dépenses totales
    double calculerTotalDepenses() {
        double total = 0;
        // Parcourir chaque achat et faire la somme des montants
        for (int i = 0; i < nombreAchats; i++) {
            total += historiqueAchats[i];
        }
        return total;
    }

    // Getters pour l'attribut nom
    string getNom() const {
        return nom;
    }

    // Getters pour l'attribut email
    string getEmail() const {
        return email;
    }

    // Méthode pour récupérer l'historique des achats
    void afficherHistoriqueAchats() const {
        cout << "Historique des achats pour " << nom << ": ";
        for (int i = 0; i < nombreAchats; i++) {
            cout << historiqueAchats[i] << (i < nombreAchats - 1 ? ", " : "");
        }
        cout << endl;
    }
};

// Définir la classe fille ClientFidele qui hérite de la classe Client
class ClientFidele : public Client {
private:
    // Attribut pour le taux de remise
    double tauxRemise;

public:
    // Constructeur pour initialiser ClientFidele avec le nom, 
    // l'email et le taux de réduction
    ClientFidele(const string& nom, const string& email, double tauxRemise)
        : Client(nom, email), tauxRemise(tauxRemise) {}

    // Méthode pour appliquer la réduction à un montant donné
    double appliquerRemise(double montant) {
        return montant - (montant * tauxRemise / 100);
    }

    // Surcharger la méthode addAchat pour appliquer la réduction 
    // avant d'ajouter l'achat
    void addAchat(double montant) override { 
        double r = appliquerRemise(montant);
        // Appeler la méthode de la classe mère pour ajouter le 
        // montant réduit
        Client::addAchat(r);
    }

    // Méthode pour récupérer le taux de remise
    double getTauxRemise() const {
        return tauxRemise;
    }

    // Méthode pour définir le taux de remise
    void setTauxRemise(double tauxRemise) {
        this->tauxRemise = tauxRemise;
    }
};

// Définir la fonction Main
int main() {
    // Créer un client régulier
    Client c("Alex Rio", "[email protected]");
    c.addAchat(200);
    c.addAchat(300);
    cout << "Dépenses totales pour " << c.getNom() << ": " << c.calculerTotalDepenses() << endl;

    // Afficher l'historique des achats
    c.afficherHistoriqueAchats();

    // Créer un client fidèle avec un taux de réduction de 5%
    ClientFidele f("Emily Bazi", "[email protected]", 5);
    f.addAchat(200);
    f.addAchat(300);
    cout << "Dépenses totales pour " << f.getNom() << " après réduction: " << f.calculerTotalDepenses() << endl;

    // Afficher l'historique des achats du client fidèle
    f.afficherHistoriqueAchats();

    return 0;
}

Sortie:

Dépenses totales pour Alex Rio: 500.0
Dépenses totales pourr Emily Bazi après réduction: 475.0