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

#include <iostream>
#include <string>

using namespace std;

// Définir la classe FeuDeCirculation
class FeuDeCirculation {
private:
    // Déclarer une variable privée pour stocker la couleur du feu de 
    // circulation
    string couleur;
    // Déclarer une variable privée pour stocker la durée du feu en 
    // secondes
    int duree;

public:
    // Constructeur pour la classe FeuDeCirculation
    FeuDeCirculation(string couleur, int duree) {
        // Initialiser la couleur du feu de circulation
        this->couleur = couleur;
        // Initialiser la durée du feu de circulation
        this->duree = duree;
    }

    // Méthode pour changer la couleur du feu de circulation
    void changerCouleur(string newColor) {
        // Mettre à jour la variable couleur avec la nouvelle couleur
        couleur = newColor;
    }

    // Méthode pour vérifier si le feu est rouge
    bool estRouge() {
        // Retourne true si la couleur est rouge, sinon retourne 
        // false
        return couleur == "Rouge";
    }

    // Méthode pour vérifier si le feu est vert
    bool estVert() {
        // Retourne true si la couleur est verte, sinon retourne 
        // false
        return couleur == "Vert";
    }

    // Méthode pour obtenir la durée du feu de circulation
    int getDuree() {
        // Renvoyer la valeur de la durée
        return duree;
    }

    // Méthode pour définir la durée du feu de circulation
    void setDuree(int duree) {
        // Mettre à jour la variable durée avec la nouvelle valeur
        this->duree = duree;
    }
};

// Définir la fonction Main
int main() {
    // Créer un nouvel objet FeuDeCirculation avec une couleur 
    // initiale 'Rouge' et une durée de 30 secondes.
    FeuDeCirculation fc("Rouge", 30);

    // Afficher si le feu est rouge
    cout << "Le feu est rouge: " << (fc.estRouge() ? "true" : "false") << endl;

    // Afficher si le feu est vert
    cout << "Le feu est vert: " << (fc.estVert() ? "true" : "false") << endl;

    // Changer la couleur du feu de circulation en 'Vert'
    fc.changerCouleur("Vert");

    // Afficher si le feu de circulation est maintenant vert
    cout << "Le feu de circulation est maintenant vert: " << (fc.estVert() ? "true" : "false") << endl;

    // Afficher la durée du feu de circulation
    cout << "La durée du feu est: " << fc.getDuree() << " secondes" << endl;

    // Définir une nouvelle durée pour le feu de circulation à 15 
    // secondes
    fc.setDuree(15);

    // Afficher la durée actualisée du feu de circulation
    cout << "La durée du feu est maintenant: " << fc.getDuree() << " secondes" << endl;

    return 0;
}

Sortie:

Le feu est rouge: true
Le feu est vert: false
Le feu de circulation est maintenant vert: true
La durée du feu est: 30
La durée du feu est maintenant: 15

#include <iostream>
#include <string>
#include <chrono>
#include <ctime>

class Employee {
private:
    // Variable privée pour stocker le nom de l'employé
    std::string nom; 
    // Variable privée pour stocker le salaire de l'employé	
    double salaire;  
    // Variable privée pour stocker la date d'embauche	
    std::time_t datEmbauche; 

public:
    // Constructeur de la classe Employee
    Employee(const std::string& nom, double salaire, const std::string& dateStr) {
        // Initialiser le nom de l'employé
        this->nom = nom; 
        // Initialiser le salaire de l'employé
        this->salaire = salaire; 

        // Convertir la date sous forme de chaîne en std::time_t
        // Créer une structure tm pour stocker les éléments de la 
        // date
        std::tm tm = {}; 
        // Parser la date
        strptime(dateStr.c_str(), "%Y-%m-%d", &tm); 
        // Convertir en std::time_t
        datEmbauche = std::mktime(&tm); 
    }

    // Méthode pour récupérer le nom de l'employé
    std::string getNom() {
        return nom; // Retourner le nom
    }

    // Méthode pour définir le nom de l'employé
    void setNom(const std::string& nom) {
        this->nom = nom; // Mettre à jour le nom
    }

    // Méthode pour récupérer le salaire de l'employé
    double getSalaire() {
        return salaire; // Retourner le salaire
    }

    // Méthode pour définir le salaire de l'employé
    void setSalaire(double salaire) {
        this->salaire = salaire; // Mettre à jour le salaire
    }

    // Méthode pour récupérer la date d'embauche de l'employé
    std::time_t getDatEmbauche() {
        return datEmbauche; // Retourner la date d'embauche
    }

    // Méthode pour définir la date d'embauche de l'employé
    void setDatEmbauche(const std::string& dateStr) {
        // Créer une structure tm pour stocker les éléments de la 
        // date
        std::tm tm = {}; 
        // Parser la date
        strptime(dateStr.c_str(), "%Y-%m-%d", &tm);
        // Convertir en std::time_t
        datEmbauche = std::mktime(&tm); 
    }

    // Méthode pour calculer les années de service de l'employé
    int calculerAnneeService() {
        // Obtenir l'heure actuelle
        auto now = std::time(nullptr); 
        // Calculer la différence en années entre la date actuelle et
        // la date d'embauche
        return std::difftime(now, datEmbauche) / (365 * 24 * 60 * 60);
    }

    // Méthode pour afficher les détails de l'employé
    void afficherEmployee() {
        // Afficher le nom
        std::cout << "\nNom: " << nom; 
        // Afficher le salaire
        std::cout << "\nSalaire: " << salaire; 
        // Afficher la date d'embauche
        std::cout <<"\nDate d'embauche: "<< std::ctime(&datEmbauche); 
    }
};

int main() {
    // Créer un nouvel objet Employee nommé emp1
    Employee emp1("Alex Babtise", 80000, "2024-05-01");
    
    // Créer un nouvel objet Employee nommé emp2
    Employee emp2("Bob Kimo", 40000, "2022-03-01");

    // Afficher les détails de l'employé 1
    emp1.afficherEmployee();
    // Afficher les années de service de l'employé 1
    std::cout << "Années de service: " << emp1.calculerAnneeService() << std::endl;

    // Afficher les détails de l'employé 2
    emp2.afficherEmployee();
    // Afficher les années de service de l'employé 2
    std::cout << "Années de service: " << emp2.calculerAnneeService() << std::endl;

    return 0; // Fin du programme
}

Sortie:

Nom: Alex Babtise
Salaire: 80000.0
Date d'embauche: 2024-05-01
Années de service: 0

Nom: Bob Kimo
Salaire: 40000.0
Date d'embauche: 2022-03-01
Années de service: 2

#include <iostream>
#include <string>

// Définir la classe Etudiant
class Etudiant {
private:
    // Déclarer une variable privée pour stocker le nom de l'étudiant
    std::string nom;
    // Déclarer une variable privée pour stocker la note de l'étud..
    int note;
    // Déclarer un tableau fixe pour stocker les cours de l'étudiant
    std::string cours[10]; // Capacité maximale de 10 cours
    int nbCours; // Compteur pour le nombre de cours

public:
    // Constructeur pour la classe Etudiant
    Etudiant(const std::string& nom, int note) {
        // Initialiser le nom de l'étudiant
        this->nom = nom;
        // Initialiser la note de l'étudiant
        this->note = note;
        // Initialiser le compteur de cours
        nbCours = 0;
    }

    // Méthode pour récupérer le nom de l'étudiant
    std::string getNom() {
        // Retourner le nom de l'étudiant
        return nom;
    }

    // Méthode pour récupérer la note de l'étudiant
    int getNote() {
        // Retourner la note de l'étudiant
        return note;
    }

    // Méthode pour récupérer la liste de cours de l'étudiant
    std::string* getCours() {
        // Retourner le tableau de cours
        return cours;
    }

    // Méthode pour ajouter un cours à la liste des cours de l'étud..
    void ajouterCours(const std::string& c) {
        // Vérifier si l'on peut ajouter un cours
        if (nbCours < 10) {
            cours[nbCours] = c; // Ajouter le cours
            nbCours++; // Incrémenter le compteur
        } else {
            std::cout << "Impossible d'ajouter le cours. Limite atteinte." << std::endl;
        }
    }

    // Méthode pour supprimer un cours de la liste des cours de l'étu
    void supprimerCours(const std::string& c) {
        // Chercher le cours dans le tableau
        for (int i = 0; i < nbCours; i++) {
            if (cours[i] == c) {
                // Déplacer les cours restants vers la gauche
                for (int j = i; j < nbCours - 1; j++) {
                    cours[j] = cours[j + 1];
                }
                nbCours--; // Décrémenter le compteur de cours
                break;
            }
        }
    }

    // Méthode pour afficher les détails de l'étudiant
    void afficherEtudiant() {
        // Afficher le nom de l'étudiant
        std::cout << "Nom: " << nom << std::endl;
        // Afficher la note de l'étudiant
        std::cout << "Note: " << note << std::endl;
    }

    // Méthode pour afficher les cours de l'étudiant
    void afficherCours() {
        std::cout << "Les cours de " << nom << " : ";
        for (int i = 0; i < nbCours; i++) {
            // Ajouter une virgule sauf pour le dernier
            std::cout << cours[i] << (i < nbCours - 1 ? ", " : ""); 
        }
        std::cout << std::endl;
    }
};

// Définir la fonction Main
int main() {
    // Créer un nouvel objet Etudiant nommé e1
    Etudiant e1("Alex Babtise", 18);
    // Créer un nouvel objet Etudiant nommé e2
    Etudiant e2("Bob Kimo", 16);

    // Afficher un en-tête pour les détails de l'étudiant
    std::cout << "Détails de l'étudiant:" << std::endl;
    // Afficher les données de l'étudiant 1
    e1.afficherEtudiant();
    // Afficher les données de l'étudiant 2
    e2.afficherEtudiant();

    // Afficher un message indiquant que des cours sont ajoutés pour 
    // l'étudiant 1
    std::cout<<"Ajouter des cours pour "<<e1.getNom()<<std::endl;
    e1.ajouterCours("Mathématiques");
    e1.ajouterCours("Biologie");
    e1.ajouterCours("Histoire");

    // Afficher les cours de e1
    e1.afficherCours();

    // Afficher un message indiquant que des cours sont ajoutés pour 
    // l'étudiant 2
    std::cout<<"\nAjouter des cours pour "<<e2.getNom()<<std::endl;
    e2.ajouterCours("Anglais");
    e2.ajouterCours("Géologie");
    e2.ajouterCours("Physique");

    // Afficher les cours de e2
    e2.afficherCours();

    // Afficher un message indiquant que le cours 'Biologie' est 
    // supprimé pour e1
    std::cout << "\nSuppression du cours 'Biologie' pour " << e1.getNom() << std::endl;
    // Supprimer le cours 'Biologie' des cours de e1
    e1.supprimerCours("Biologie");

    // Afficher les cours de e1 après suppression
    e1.afficherCours();

    return 0;
}

Sortie:

Détails de l'étudiant:
Nom: Alex Babtise
Note: 18
Nom: Bob Kimo
Note: 16
Ajouter des cours pour Alex Babtise
Les cours de Alex Babtise : [Mathématiques, Biologie, Histoire]

Ajouter des cours pour Bob Kimo
Les cours de Bob Kimo : [Anglais, Géologie, Physique]

Suppression du cours 'Biologie' pour Alex Babtise
Les cours de Alex Babtise : [Mathématiques, Histoire]

#include <iostream>
#include <string>

// Capacité maximale de livres
const int MAX_LIVRES = 100; 

// Définir la classe Livre
class Livre {
private:
    // Attributs privés pour stocker le titre et l'auteur
    std::string titre;
    std::string auteur;

public:
    // Constructeur pour initialiser les champs titre et auteur
    Livre(std::string titre, std::string auteur) {
        // Attribuer le paramètre titre
        this->titre = titre; 
        // Attribuer le paramètre auteur
        this->auteur = auteur; 
    }

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

    // Méthode Setter pour le titre
    void setTitre(std::string titre) {
        // Attribuer le nouveau titre
        this->titre = titre; 
    }

    // Méthode pour récupérer l'auteur
    std::string getAuteur() {
        return auteur; // Retourner l'auteur
    }

    // Méthode Setter pour l'auteur
    void setAuteur(std::string auteur) {
        // Attribuer le nouvel auteur
        this->auteur = auteur; 
    }
};

// Définir la classe Bibliotheque
class Bibliotheque {
private:
    // Tableau pour stocker les objets Livre
    Livre* livres[MAX_LIVRES]; 
    // Compteur pour le nombre de livres
    int count; 

public:
    // Constructeur pour initialiser la bibliothèque
    Bibliotheque() {
        // Initialiser le compteur de livres à zéro
        count = 0; 
    }

    // Méthode pour ajouter un livre à la bibliothèque
    void addLivre(Livre* livre) {
        // Vérifier si on peut ajouter un livre
        if (count < MAX_LIVRES) { 
            // Ajouter le livre et incrémenter le compteur
            livres[count++] = livre; 
        }
    }

    // Méthode pour supprimer un livre de la bibliothèque
    void removeLivre(Livre* livre) {
        for (int i = 0; i < count; ++i) {
            // Vérifier si le livre est dans le tableau
            if (livres[i] == livre) { 
                for (int j = i; j < count - 1; ++j) {
                    // Déplacer les livres vers la gauche
                    livres[j] = livres[j + 1]; 
                }
                --count; // Décrémenter le compteur
                break; // Sortir de la boucle
            }
        }
    }

    // Méthode pour récupérer la liste des livres
    Livre** getLivres() {
        return livres; // Retourner le tableau des livres
    }

    // Méthode pour récupérer le nombre de livres
    int getCount() {
        return count; // Retourner le nombre de livres
    }
};

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

    // Créer de nouveaux objets Livre avec le titre et l'auteur
    Livre* livre1 = new Livre("Les Misérables", "Victor Hugo");
    Livre* livre2 = new Livre("Nana", "Émile Zola");
    Livre* livre3 = new Livre("Les fleurs du mal", "Baudelaire");
    Livre* livre4 = new Livre("Le Cid", "Corneille");

    // Ajouter les livres à la bibliothèque
    biblio.addLivre(livre1);
    biblio.addLivre(livre2);
    biblio.addLivre(livre3);
    biblio.addLivre(livre4);

    std::cout << "Livres dans la bibliothèque:" << std::endl;

    // Parcourir la liste des livres de la bibliothèque
    for (int i = 0; i < biblio.getCount(); ++i) {
        // Afficher titre et auteur
        std::cout << biblio.getLivres()[i]->getTitre() << " par " 
                  << biblio.getLivres()[i]->getAuteur() << std::endl;
    }

    // Supprimer un livre de la bibliothèque
    biblio.removeLivre(livre2);
    std::cout<<"\nLivres dans la bibliothèque après suppression de " 
             << livre2->getTitre() << ":" << std::endl;

    // Parcourir la liste mise à jour des livres
    for (int i = 0; i < biblio.getCount(); ++i) {
        // Afficher titre et auteur
        std::cout << biblio.getLivres()[i]->getTitre() << " par " 
                  << biblio.getLivres()[i]->getAuteur() << std::endl; 
    }

    // Libérer la mémoire
    delete livre1;
    delete livre2;
    delete livre3;
    delete livre4;

    return 0; // Fin du programme
}

Sortie:

Livres dans la bibliothéque:
Les Misérables par Victor Hugo
Nana par Émile Zola
Les fleurs du mal par Baudelaire
Le Cid par Corneille

Livres dans la biblio après suppression Nana:
Les Misérables par Victor Hugo
Les fleurs du mal par Baudelaire
Le Cid par Corneille

#include <iostream>
#include <string>
#include <iomanip> // Pour std::setfill et std::setw
#include <ctime>   // Pour struct tm et mktime

// Définir la classe Avion
class Avion {
private:
    // Attribut privé pour stocker le numéro de vol
    std::string numVol;
    // Attribut privé pour stocker la destination
    std::string destination;
    // Attribut privé pour stocker l'heure de départ prévue
    std::tm heureDepart;
    // Attribut privé pour stocker le temps de retard en minutes
    int tempsRetard;

public:
    // Constructeur pour initialiser le numéro de vol, la destination 
    // et l'heure de départ prévue
    Avion(std::string numVol, std::string destination, std::tm heureDepart) {
        // Attribuer le paramètre numVol au champ numVol
        this->numVol = numVol;
        // Attribuer le paramètre destination au champ destination
        this->destination = destination;
        // Attribuer le paramètre heureDepart au champ heureDepart
        this->heureDepart = heureDepart;
        // Initialiser le temps de retard à 0
        this->tempsRetard = 0;
    }

    // Méthode pour obtenir le numéro de vol
    std::string getNumVol() {
        // Retourner la valeur du champ numVol
        return numVol;
    }

    // Méthode pour définir le numéro de vol
    void setNumVol(std::string numVol) {
        // Attribuer le paramètre numVol au champ numVol
        this->numVol = numVol;
    }

    // Méthode pour obtenir la destination
    std::string getDestination() {
        // Retourner la valeur du champ destination
        return destination;
    }

    // Méthode pour définir la destination
    void setDestination(std::string destination) {
        // Attribuer le paramètre destination au champ destination
        this->destination = destination;
    }

    // Méthode pour obtenir l'heure de départ
    std::tm getHeureDepart() {
        // Retourner la valeur du champ heureDepart
        return heureDepart;
    }

    // Méthode pour définir l'heure de départ
    void setHeureDepart(std::tm heureDepart) {
        // Attribuer le paramètre heureDepart au champ heureDepart
        this->heureDepart = heureDepart;
    }

    // Méthode pour obtenir le temps de retard
    int getTempsRetard() {
        // Retourner la valeur du champ tempsRetard
        return tempsRetard;
    }

    // Méthode pour retarder le vol et mettre à jour l'heure de 
    // départ prévue
    void retarder(int minutes) {
        // Affecter le paramètre minutes au champ tempsRetard
        this->tempsRetard += minutes;
        // Ajouter le temps de retard à l'heure de départ
        heureDepart.tm_min += minutes;
        // Normaliser l'heure si nécessaire
        mktime(&heureDepart);
    }

    // Méthode pour vérifier le statut du vol
    void checkStatutVol() {
        // Vérifier s'il n'y a pas de retard
        if (tempsRetard == 0) {
            // Afficher un message indiquant que le vol est à l'heure
            std::cout << "Le vol " << numVol << " est à l'heure." << std::endl;
        } else {
            // Afficher un message indiquant que le vol est retardé
            std::cout << "Le vol " << numVol << " est retardé de " << tempsRetard << " minutes." << std::endl;
        }
    }
};

// Définir la fonction Main
int main() {
    // Créer un nouvel objet Avion avec le numéro de vol 'ABC123', la 
    // destination 'Paris' et l'heure de départ 11:30.
    std::tm heure1 = {0, 30, 11, 0, 0, 0}; // 11:30
    Avion a1("ABC123", "Paris", heure1);
    
    // Créer un nouvel objet Avion avec le numéro de vol 'POM569', la 
    // destination 'CasaBlanca' et l'heure de départ 15:00.
    std::tm heure2 = {0, 0, 15, 0, 0, 0}; // 15:00
    Avion a2("POM569", "CasaBlanca", heure2);
    
    // Créer un nouvel objet Avion avec le numéro de vol 'UYT852', la 
    // destination 'Bruxelles' et l'heure de départ 12:00.
    std::tm heure3 = {0, 0, 12, 0, 0, 0}; // 12:00
    Avion a3("UYT852", "Bruxelles", heure3);

    // Afficher le statut initial du vol
    std::cout << "Statut du vol:" << std::endl;
    a1.checkStatutVol();
    a2.checkStatutVol();
    a3.checkStatutVol();

    // Retarder a1 de 30 minutes
    a1.retarder(30);
    // Retarder a2 de 90 minutes
    a2.retarder(90);

    // Afficher l'état actuel du vol après les retards
    std::cout << "\nStatut actuel du vol:" << std::endl;
    a1.checkStatutVol();
    a2.checkStatutVol();
    a3.checkStatutVol();

    return 0;
}

Sortie:

Statut du vol:
Le vol ABC123 est à l'heure.
Le vol POM569 est à l'heure.
Le vol UYT852 est à l'heure.

Statut actuel du vol:
Le vol ABC123 est retardé de 30 minutes.
Le vol POM569 est retardé de 90 minutes.
Le vol UYT852 est à l'heure.