Chapitre 1 : Programmation Objet — Concepts Fondamentaux

#include <iostream>
 
class Rectangle {
   private:
    double m_largeur;  // Attribut / Donnée membre
    double m_hauteur;  // Attribut / Donnée membre
 
   public:
    // Constructeur avec liste d'initialisation
    Rectangle(double largeur, double hauteur)
        : m_largeur(largeur), m_hauteur(hauteur) {}
 
    // Méthode de calcul (const car ne modifie pas l'état)
    double calculer_aire() const { return m_largeur * m_hauteur; }
 
    // Méthode mutatrice (modifie l'état de l'objet)
    void redimensionner(double facteur) {
        if (facteur > 0) {
            m_largeur *= facteur;
            m_hauteur *= facteur;
        }
    }
 
    void afficher() const {
        std::cout << "Rectangle [" << m_largeur << " x " << m_hauteur
                  << "] - Aire = " << calculer_aire() << std::endl;
    }
};
 
int main() {
    Rectangle r1(4.0, 5.0);
    Rectangle r2(2.5, 10.0);
 
    r1.afficher();           // Rectangle [4 x 5] - Aire = 20
    r1.redimensionner(2.0);  // Modifie uniquement r1
    r1.afficher();           // Rectangle [8 x 10] - Aire = 80
 
    r2.afficher();  // Inchangé : Rectangle [2.5 x 10] - Aire = 25
    return 0;
}

#pragma once
#include <iostream>
 
// ===================================================================
// PARTIE INTERFACE DE LA CLASSE PileEntiers
// ===================================================================
 
/**
 * @class Pile d'entiers
 * @brief Classe représentant une pile d'entiers avec redimensionnement
 * dynamique.
 */
class PileEntiers {
    // Attributs de la structure de données (private ou protected si héritage)
    // Inaccessibles depuis l'extérieur de la classe pour garantir
    // l'encapsulation.
   private:
    int* m_elements;    // Tableau dynamique d'entiers
    size_t m_capacite;  // Capacité maximale allouée
    size_t m_sommet;    // Nombre d'éléments empilés
 
    // Méthode privée pour redimensionner le tableau dynamique
    // Elle n'a pas besoin d'être publique car elle est utilisée
    // uniquement en interne par la classe.
    // C'est un détail d'implémentation qui ne doit pas être exposé
    // à l'utilisateur de la classe.
    // Mais elle doit être déclarée dans la classe pour que le compilateur
    // puisse la trouver.
    void redimensionner(size_t nouvelle_capacite);
 
    // Partie publique de la classe (interface)
    // Indique les fonctionnalités accessibles depuis l'extérieur de la classe.
   public:
    // 1. Constructeur usuel
    explicit PileEntiers(size_t capacite_initiale = 4);
 
    // 2. Destructeur
    ~PileEntiers();
 
    // 3. Méthodes de manipulation de la pile
    void empiler(int element);
 
    int depiler();
};

#include "pile_entiers.hpp"
 
// ===================================================================
// PARTIE IMPLEMENTATION DE LA CLASSE PileEntiers
// ===================================================================
 
PileEntiers::PileEntiers(size_t capacite_initiale)
    : m_elements(new int[capacite_initiale]),
      m_capacite(capacite_initiale),
      m_sommet(0) {}
 
PileEntiers::~PileEntiers() { delete[] m_elements; }
 
void PileEntiers::redimensionner(size_t nouvelle_capacite) {
    int* nouv = new int[nouvelle_capacite];
    for (size_t i = 0; i < m_sommet; ++i) {
        nouv[i] = m_elements[i];
    }
    delete[] m_elements;
    m_elements = nouv;
    m_capacite = nouvelle_capacite;
}
 
void PileEntiers::empiler(int element) {
    if (m_sommet == m_capacite) {
        redimensionner(m_capacite * 2);
    }
    m_elements[m_sommet++] = element;
}
 
int PileEntiers::depiler() {
    if (m_sommet == 0) {
        throw std::out_of_range("Pile vide");
    }
    return m_elements[--m_sommet];
}

#include <iostream>
#include <string>
 
class Personne {
   private:
    // L'attribut est privé : il ne peut pas être modifié directement depuis
    // main()
    int m_age;
 
   public:
    // Constructeur
    Personne(int ageInitial) {
        // On utilise le setter dès la construction pour bénéficier de sa
        // validation
        set_age(ageInitial);
    }
 
    // --- GETTER ---
    // Permet de lire l'âge. Le "const" garantit que la méthode ne modifie pas
    // l'objet. A la manière de Java
    int get_age() const { return m_age; }
 
    // --- SETTER ---
    // Permet de modifier l'âge en imposant une règle de validation.
    // A la manière de Java
    void set_age(int age) {
        if (age >= 0) {
            m_age = age;
        } else {
            std::cout << "Erreur : l'âge ne peut pas être négatif !"
                      << std::endl;
        }
    }
 
    // --- Variante plus personnelle du getter et du setter ---
    // On peut aussi nommer les méthodes de manière plus naturelle, comme si
    // elles étaient des propriétés de l'objet. Cela peut rendre le code plus
    // lisible. Exemple :
 
    int age() const { return m_age; }
 
    void age(int age) {
        if (age >= 0) {
            m_age = age;
        } else {
            std::cout << "Erreur : l'âge ne peut pas être négatif !"
                      << std::endl;
        }
    }
};
 
int main() {
    // Création d'un objet avec l'âge initial de 25
    Personne jean(25);
 
    // Utilisation du GETTER pour afficher la valeur
    std::cout << "Jean a " << jean.get_age() << " ans." << std::endl;
 
    // Utilisation du SETTER pour modifier la valeur de manière valide
    jean.set_age(26);
    std::cout << "Jean a maintenant " << jean.get_age() << " ans." << std::endl;
 
    // Tentative de modification invalide : le SETTER la bloque
    jean.set_age(-5);
 
    return 0;
}

#include <iostream>
#include <stdexcept>
 
class Heure {
   private:
    int m_heures;   // Invariant : 0 <= m_heures <= 23
    int m_minutes;  // Invariant : 0 <= m_minutes <= 59
 
    bool est_valide(int h, int m) const {
        return (h >= 0 && h < 24) && (m >= 0 && m < 60);
    }
 
   public:
    Heure(int h, int m) {
        if (!est_valide(h, m)) {
            throw std::invalid_argument("Heure ou minutes invalides !");
        }
        m_heures = h;
        m_minutes = m;
    }
 
    void avancer(int minutes) {
        if (minutes < 0) return;
        int total_minutes = m_heures * 60 + m_minutes + minutes;
        m_heures = (total_minutes / 60) % 24;
        m_minutes = total_minutes % 60;
    }
 
    void afficher() const {
        std::cout << (m_heures < 10 ? "0" : "") << m_heures << ":"
                  << (m_minutes < 10 ? "0" : "") << m_minutes << std::endl;
    }
};
 
int main() {
    Heure h(23, 45);
    h.afficher();   // 23:45
    h.avancer(30);  // Passage automatique au jour suivant
    h.afficher();   // 00:15 (Invariant garanti !)
 
    // h.m_heures = 99;    // ❌ Interdit par le compilateur
    return 0;
}

Vecteur v1(5);
Vecteur v2(10);
v2 = v1; // Appel de v2.operator=(v1);

#include <iostream>
#include <stdexcept>
using namespace std;
 
/**
 * @class array_of_int
 * @brief A class that represents a dynamically allocated array of integers.
 *
 * This class handles memory allocation, deep copying, and boundary checking
 * for an array of integers.
 *
 */
class array_of_int {
   protected:
    /**
     * @brief The number of elements in the array.
     */
    int m_size;
 
    /**
     * @brief Pointer to the dynamically allocated memory block holding the
     * integers.
     */
    int* m_data;
 
   public:
    /**
     * @brief Default constructor.
     *
     * Initializes an empty array with a size of 0 and a null data pointer.
     */
    array_of_int() : m_size(0), m_data(nullptr) {}
 
    /**
     * @brief Parameterized constructor.
     *
     * Allocates an array of the specified size.
     *
     * @param size The number of elements to allocate for the array.
     * @throw std::runtime_error if the provided size is negative.
     */
    array_of_int(int size) : m_size(size) {
        if (size == 0) {
            m_data = nullptr;
        } else if (m_size < 0) {
            throw std::runtime_error("size must be positive or null");
        } else {
            m_data = new int[m_size];
        }
    }
 
    /**
     * @brief Copy constructor.
     *
     * Performs a deep copy of another array_of_int object.
     *
     * @param object The array_of_int object to copy.
     */
    array_of_int(const array_of_int& object) {
        m_size = object.m_size;
        if (m_size > 0) {
            m_data = new int[m_size];
            std::copy(&object.m_data[0], &object.m_data[m_size], &m_data[0]);
        } else {
            m_data = nullptr;
        }
    }
 
    ~array_of_int() {
        if (m_data != nullptr) {
            delete[] m_data;
        }
    }
 
    /**
     * @brief Copy assignment operator.
     *
     * Safely releases existing resources and performs a deep copy of the
     * right-hand object. Protects against self-assignment.
     *
     * @param object The array_of_int object to assign from.
     * @return array_of_int& A reference to the updated current object.
     */
    array_of_int& operator=(const array_of_int& object) {
        if (this != &object) {
            if (m_data != nullptr) delete[] m_data;
            m_size = object.m_size;
            if (m_size > 0) {
                m_data = new int[m_size];
                std::copy(&object.m_data[0], &object.m_data[m_size],
                          &m_data[0]);
            } else {
                m_data = nullptr;
            }
        }
        return *this;
    }
 
    /**
     * @brief Retrieves the current size of the array.
     *
     * @return int The number of elements in the array.
     */
    int size() { return m_size; }
 
    /**
     * @brief Overloaded subscript operator for element access.
     *
     * Provides access to the element at the specified index. Includes bounds
     * checking.
     *
     * @param n The index of the element to access.
     * @return int& A reference to the element at the specified index.
     * @throw std::out_of_range if the index is less than 0 or greater
     * than/equal to the size.
     */
    int& operator[](int n) {
        if ((n < 0) or (n >= m_size)) {
            throw std::out_of_range("index out of range");
        }
        return m_data[n];
    }
 
    /**
     * @brief Overloaded stream insertion operator.
     *
     * Formats the array contents as [val1 val2 val3 ] and outputs it to the
     * stream.
     *
     * @param out The output stream.
     * @param object The array_of_int object to output.
     * @return std::ostream& A reference to the output stream.
     */
    friend std::ostream& operator<<(std::ostream& out, array_of_int& object) {
        out << '[';
        for (int i = 0; i < object.m_size; ++i) {
            out << object.m_data[i] << ' ';
        }
        out << ']';
 
        return out;
    }
};
 
// ==================================================================
// Main function
// ==================================================================
int main() {
    // --------------------------------------------------------------
    // create an array of 10 integers
    // --------------------------------------------------------------
    array_of_int a1(10);
 
    // --------------------------------------------------------------
    // fill the array with values 10, 11, ..., 19
    // --------------------------------------------------------------
    for (int i = 0; i < a1.size(); ++i) {
        a1[i] = 10 + i;
    }
 
    std::cout << "a1=" << a1 << std::endl;
 
    // --------------------------------------------------------------
    // create a second array and assign the first array to it
    // --------------------------------------------------------------
    array_of_int a2;
    a2 = a1;
 
    std::cout << "a2=" << a2 << std::endl;
 
    // --------------------------------------------------------------
    // create a third array of 4 integers and assign values to it
    // --------------------------------------------------------------
    array_of_int a3(4);
    a3[1] = 55;
    a3[3] = 99;
    std::cout << "a3=" << a3 << std::endl;
 
    // --------------------------------------------------------------
    // assign the first array to the third array
    // --------------------------------------------------------------
    a3 = a1;
 
    std::cout << "a3=" << a3 << std::endl;
 
    // --------------------------------------------------------------
    // create a fourth array using the copy constructor
    // --------------------------------------------------------------
    array_of_int a4(a1);
    a4[0] = 100;
    std::cout << "a4=" << a4 << std::endl;
 
    // --------------------------------------------------------------
    // show that a1 is unchanged
    // --------------------------------------------------------------
    std::cout << "a1=" << a1 << std::endl;
 
    return EXIT_SUCCESS;
}