Programmation Orientee Objets C++

PARTIE A : GENERALITES

Presentation

Le cours de "Programmation Orientee Objets C++" a fourni une introduction complete a la programmation orientee objet en utilisant C++. Ce cours etait essentiel pour developper des applications logicielles modernes avec un accent sur la reutilisabilite du code, la maintenabilite et la gestion efficace de la memoire. Le C++ combine la puissance de la programmation bas niveau avec les fonctionnalites orientees objet de haut niveau.

Annee universitaire : 2023-2024
Semestre : 7
Categorie : Programmation

PARTIE B : PARTIE DESCRIPTIVE

Supports de cours :

Partie 1 (PDF) | Partie 2 (PDF) | Partie 3 (PDF) | Partie 4 (PDF) | Partie 5 (PDF) | Partie 6 (PDF) | Partie 7 (PDF)

Details de l'experience

Environnement et contexte

Le cours couvrait a la fois les concepts theoriques et l'implementation pratique de la programmation orientee objet en C++. Nous avons utilise des environnements de developpement C++ modernes et travaille sur des projets de complexite croissante qui demontraient la puissance et la flexibilite des principes de la POO en C++.

Ma fonction

Dans ce cours, j'etais responsable de :

• Comprendre les concepts fondamentaux de la POO (encapsulation, heritage, polymorphisme)
• Implementer des classes et des objets en C++
• Gerer l'allocation et la desallocation de memoire
• Utiliser les templates et la Standard Template Library (STL)
• Appliquer des patrons de conception dans des applications C++
• Deboguer et optimiser du code C++

PARTIE C : PARTIE TECHNIQUE

Cette section explore les aspects techniques de la programmation orientee objet en C++.

Concepts techniques appris

1. Classes et objets

Le fondement de la POO en C++ :

Definition de classe :

class Rectangle {
private:
    double width;
    double height;

public:
    // Constructeur
    Rectangle(double w, double h) : width(w), height(h) {}

    // Fonctions membres
    double area() const {
        return width * height;
    }

    double perimeter() const {
        return 2 * (width + height);
    }

    // Accesseurs et mutateurs
    void setWidth(double w) { width = w; }
    double getWidth() const { return width; }
};

Concepts cles :

• Encapsulation : Masquage des donnees a l'aide des specificateurs d'acces private/protected/public
• Constructeur/Destructeur : Initialisation et nettoyage des objets
• Fonctions membres : Methodes qui operent sur les donnees de l'objet
• Correction const : Utilisation de const pour les operations en lecture seule

2. Constructeurs et destructeurs

Fonctions membres speciales pour la gestion du cycle de vie des objets :

class DynamicArray {
private:
    int* data;
    size_t size;

public:
    // Constructeur par defaut
    DynamicArray() : data(nullptr), size(0) {}

    // Constructeur parametre
    DynamicArray(size_t n) : size(n) {
        data = new int[size];
    }

    // Constructeur de copie
    DynamicArray(const DynamicArray& other) : size(other.size) {
        data = new int[size];
        std::copy(other.data, other.data + size, data);
    }

    // Constructeur de deplacement (C++11)
    DynamicArray(DynamicArray&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    // Destructeur
    ~DynamicArray() {
        delete[] data;
    }

    // Operateur d'affectation par copie
    DynamicArray& operator=(const DynamicArray& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }
};

Regle des trois/cinq : Si vous devez definir un destructeur personnalise, un constructeur de copie ou un operateur d'affectation par copie, vous aurez probablement besoin des trois (ou cinq avec la semantique de deplacement).

3. Heritage

Figure : Heritage et polymorphisme en C++ - Classe de base Animal et classes derivees

Reutilisation du code a travers les hierarchies de classes :

class Shape {
protected:
    std::string color;

public:
    Shape(const std::string& c) : color(c) {}
    virtual ~Shape() {}  // Destructeur virtuel

    virtual double area() const = 0;  // Fonction virtuelle pure
    virtual void draw() const {
        std::cout << "Drawing a " << color << " shape\n";
    }
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(const std::string& c, double r)
        : Shape(c), radius(r) {}

    double area() const override {
        return M_PI * radius * radius;
    }

    void draw() const override {
        std::cout << "Drawing a " << color << " circle\n";
    }
};

class Rectangle : public Shape {
private:
    double width, height;

public:
    Rectangle(const std::string& c, double w, double h)
        : Shape(c), width(w), height(h) {}

    double area() const override {
        return width * height;
    }
};

Types d'heritage :

• Heritage public : Relation est-un
• Heritage protege : Heritage d'implementation
• Heritage prive : Rarement utilise

4. Polymorphisme

Dispatch dynamique a travers les fonctions virtuelles :

void printArea(const Shape& shape) {
    std::cout << "Area: " << shape.area() << std::endl;
    shape.draw();
}

int main() {
    Circle circle("red", 5.0);
    Rectangle rect("blue", 4.0, 6.0);

    printArea(circle);     // Appelle Circle::area()
    printArea(rect);       // Appelle Rectangle::area()

    // Conteneur polymorphe
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>("green", 3.0));
    shapes.push_back(std::make_unique<Rectangle>("yellow", 2.0, 5.0));

    for (const auto& shape : shapes) {
        shape->draw();
    }
}

Concepts cles :

• Fonctions virtuelles : Permettent le polymorphisme a l'execution
• Destructeur virtuel : Essentiel pour les classes de base
• Fonctions virtuelles pures : Definissent des interfaces abstraites
• Mot-cle override : Declaration explicite de redefinition (C++11)

5. Surcharge d'operateurs

Definition de comportements personnalises pour les operateurs :

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Operateurs arithmetiques
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    Complex operator*(const Complex& other) const {
        return Complex(
            real * other.real - imag * other.imag,
            real * other.imag + imag * other.real
        );
    }

    // Operateur de comparaison
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }

    // Operateurs de flux (comme fonctions amies)
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }

    friend std::istream& operator>>(std::istream& is, Complex& c) {
        is >> c.real >> c.imag;
        return is;
    }
};

6. Templates

Programmation generique pour la reutilisabilite du code :

// Template de fonction
template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// Template de classe
template<typename T>
class Stack {
private:
    std::vector<T> elements;

public:
    void push(const T& element) {
        elements.push_back(element);
    }

    T pop() {
        if (elements.empty()) {
            throw std::runtime_error("Stack is empty");
        }
        T value = elements.back();
        elements.pop_back();
        return value;
    }

    bool empty() const {
        return elements.empty();
    }

    size_t size() const {
        return elements.size();
    }
};

// Specialisation de template
template<>
class Stack<bool> {
    // Implementation specialisee pour bool
};

7. Bibliotheque standard de templates (STL)

Collection puissante de conteneurs et algorithmes generiques :

Conteneurs :

// Conteneurs sequentiels
std::vector<int> vec = {1, 2, 3, 4, 5};
std::list<std::string> lst;
std::deque<double> deq;

// Conteneurs associatifs
std::map<std::string, int> ages;
ages["Alice"] = 25;
ages["Bob"] = 30;

std::set<int> unique_numbers = {1, 2, 3, 3, 4};  // {1, 2, 3, 4}

// Adaptateurs de conteneurs
std::stack<int> stack;
std::queue<int> queue;
std::priority_queue<int> pq;

Algorithmes :

#include <algorithm>

std::vector<int> numbers = {5, 2, 8, 1, 9};

// Tri
std::sort(numbers.begin(), numbers.end());

// Recherche
auto it = std::find(numbers.begin(), numbers.end(), 8);

// Transformation
std::transform(numbers.begin(), numbers.end(), numbers.begin(),
               [](int n) { return n * 2; });

// Accumulation
int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

8. Pointeurs intelligents (C++11)

Gestion automatique de la memoire :

#include <memory>

// Pointeur unique (propriete exclusive)
std::unique_ptr<int> ptr1 = std::make_unique<int>(42);

// Pointeur partage (propriete partagee)
std::shared_ptr<int> ptr2 = std::make_shared<int>(100);
std::shared_ptr<int> ptr3 = ptr2;  // Compteur de references = 2

// Pointeur faible (reference non proprietaire)
std::weak_ptr<int> weak = ptr2;

// Exemple avec des classes
class MyClass {
public:
    MyClass() { std::cout << "Constructeur\n"; }
    ~MyClass() { std::cout << "Destructeur\n"; }
    void doSomething() { std::cout << "Fait quelque chose\n"; }
};

std::unique_ptr<MyClass> obj = std::make_unique<MyClass>();
obj->doSomething();
// Destructeur appele automatiquement quand obj sort de la portee

9. Gestion des exceptions

Gestion robuste des erreurs :

class FileNotFoundException : public std::exception {
private:
    std::string message;

public:
    FileNotFoundException(const std::string& filename)
        : message("Fichier non trouve : " + filename) {}

    const char* what() const noexcept override {
        return message.c_str();
    }
};

void readFile(const std::string& filename) {
    try {
        std::ifstream file(filename);
        if (!file.is_open()) {
            throw FileNotFoundException(filename);
        }
        // Lire le fichier...
    } catch (const FileNotFoundException& e) {
        std::cerr << "Erreur : " << e.what() << std::endl;
        throw;  // Re-lancer
    } catch (const std::exception& e) {
        std::cerr << "Erreur inattendue : " << e.what() << std::endl;
    }
}

10. Patrons de conception

Solutions de conception logicielle courantes :

Patron Singleton :

class Database {
private:
    static Database* instance;
    Database() {}  // Constructeur prive

public:
    static Database* getInstance() {
        if (instance == nullptr) {
            instance = new Database();
        }
        return instance;
    }

    void connect() {
        std::cout << "Connexion a la base de donnees...\n";
    }
};

Patron Fabrique :

class ShapeFactory {
public:
    static std::unique_ptr<Shape> createShape(const std::string& type) {
        if (type == "circle") {
            return std::make_unique<Circle>("red", 5.0);
        } else if (type == "rectangle") {
            return std::make_unique<Rectangle>("blue", 4.0, 6.0);
        }
        return nullptr;
    }
};

PARTIE D : PARTIE ANALYTIQUE

Connaissances et competences mobilisees

• Comprehension des principes de la programmation orientee objet
• Implementation de classes avec une encapsulation correcte
• Utilisation efficace de l'heritage et du polymorphisme
• Gestion de la memoire avec RAII et les pointeurs intelligents
• Application des templates pour la programmation generique
• Utilisation des conteneurs et algorithmes de la STL
• Gestion correcte des exceptions
• Implementation de patrons de conception
• Debogage de programmes C++ complexes

Auto-evaluation

Ce cours etait exigeant mais enrichissant. Venant de la programmation en C, le passage a la pensee orientee objet a necessite un ajustement mental significatif. Le concept de classes et d'objets etait initialement abstrait, mais a travers des projets pratiques, j'ai acquis une comprehension solide.

La gestion de la memoire en C++ (notamment avec les pointeurs et l'allocation dynamique) etait delicate. Cependant, l'apprentissage du RAII et des pointeurs intelligents a rendu la gestion memoire beaucoup plus facile et sure. L'introduction des fonctionnalites C++11 comme la semantique de deplacement et les fonctions lambda etait particulierement interessante.

Les templates et la STL semblaient initialement ecrasants en raison de leur complexite, mais j'ai fini par apprecier leur puissance pour ecrire du code generique et reutilisable. Les messages d'erreur lies a la compilation des templates etaient souvent cryptiques et difficiles a deboguer.

J'ai trouve le polymorphisme et les fonctions virtuelles fascinants, notamment la maniere dont ils permettent une conception logicielle flexible et extensible. L'implementation de patrons de conception m'a aide a comprendre l'architecture logicielle professionnelle.

Mon avis

Le C++ est un langage puissant mais complexe. Ce cours a fourni une base solide en POO avec C++, bien que la maitrise du langage necessite une pratique continue. Le cours equilibrait bien la theorie et l'implementation pratique.

J'ai particulierement apprecie l'apprentissage des fonctionnalites modernes du C++ (C++11/14/17). Ces fonctionnalites rendent le C++ plus convivial tout en maintenant ses avantages en termes de performance. Comprendre la relation entre le C et le C++ m'a aide a apprecier quand utiliser les fonctionnalites du C++ par rapport a la programmation en style C.

Domaines que j'aurais aime explorer davantage :

• Multithreading et concurrence en C++
• Metaprogrammation par templates
• Patrons de conception plus complexes
• Techniques d'optimisation de performance
• Systemes de build et organisation de projets

Les projets ont aide a solidifier les concepts, bien que davantage d'applications du monde reel (comme la programmation de systemes embarques ou le developpement de jeux) auraient ete precieuses. Dans l'ensemble, ce cours m'a equipe de competences essentielles pour le developpement logiciel moderne.

Illustrations du Projet Gamelle Connectee

Figure : Diagramme de classes UML du projet Gamelle Connectee

Figure : Application Gamelle Connectee - interface client

Figure : Architecture serveur du projet Gamelle Connectee

Rapports et Projets

Documents de Cours