Introduction à la Programmation Orientée Objet en C++

Introduction

La programmation orientée objet (POO) est une approche qui facilite l'organisation, la maintenance et l'évolutivité des programmes. En C++, elle repose sur trois principes fondamentaux :

• Encapsulation
• Héritage
• Polymorphisme

Dans cet article, nous allons explorer ces concepts de base et les illustrer avec des exemples simples pour vous initier à la POO.

1. Encapsulation : Protéger les données

L'encapsulation consiste à regrouper les données (attributs) et les fonctions (méthodes) dans une classe tout en contrôlant l'accès à ces données. Elle permet de protéger les données en restreignant leur accès direct.

Exemple simple : Encapsulation

#include <iostream>
#include <string>
 
class Personne {
private:
    std::string nom;
    int age;
 
public:
    // Méthodes pour définir les attributs
    void setNom(const std::string& n) { nom = n; }
    void setAge(int a) { age = a; }
 
    // Méthode pour afficher les informations
    void afficher() const {
        std::cout << "Nom : " << nom << ", Âge : " << age << std::endl;
    }
};
 
int main() {
    Personne p1;
    p1.setNom("Alice");
    p1.setAge(30);
    p1.afficher();  // Affiche : Nom : Alice, Âge : 30
 
    return 0;
}

Avantages de l'encapsulation :

1. Protège les données sensibles en empêchant l'accès direct.
2. Permet de contrôler les modifications via des méthodes dédiées (getter et setter).
3. Améliore la maintenabilité du code.

2. Héritage : Réutiliser le code

L'héritage permet à une classe enfant de hériter des propriétés et méthodes d'une classe parent. Cela favorise la réutilisation du code et facilite son extension.

Exemple simple : Héritage

#include <iostream>
#include <string>

// Classe parent
class Animal {
public:
    void manger() const {
        std::cout << "Je mange." << std::endl;
    }
};

// Classe enfant
class Chien : public Animal {
public:
    void aboyer() const {
        std::cout << "Je fais : Wouf Wouf !" << std::endl;
    }
};

int main() {
    Chien monChien;
    monChien.manger();  // Méthode héritée de la classe Animal
    monChien.aboyer();  // Méthode propre à la classe Chien

    return 0;
}

Points clés de l'héritage :

1. Une classe enfant peut hériter des attributs et méthodes publiques ou protégées de la classe parent.
2. Permet de structurer le code en hiérarchie.
3. Facilite l'extension des fonctionnalités existantes.

3. Polymorphisme : Adapter le comportement

Le polymorphisme permet de redéfinir le comportement d’une méthode dans une classe enfant, tout en conservant une interface commune. Cela permet d'écrire du code flexible et adaptable.

Exemple simple : Polymorphisme avec redéfinition

#include <iostream>
#include <string>

// Classe parent
class Animal {
public:
    virtual void faireDuBruit() const {
        std::cout << "Je fais un bruit général." << std::endl;
    }
};

// Classe enfant
class Chat : public Animal {
public:
    void faireDuBruit() const override {
        std::cout << "Je fais : Miaou !" << std::endl;
    }
};

// Classe enfant
class Chien : public Animal {
public:
    void faireDuBruit() const override {
        std::cout << "Je fais : Wouf !" << std::endl;
    }
};

int main() {
    Animal* monAnimal;
    Chat monChat;
    Chien monChien;

    monAnimal = &monChat;
    monAnimal->faireDuBruit();  // Affiche : Je fais : Miaou !

    monAnimal = &monChien;
    monAnimal->faireDuBruit();  // Affiche : Je fais : Wouf !

    return 0;
}

Types de polymorphisme :

1. Polymorphisme statique (surcharge) : Plusieurs fonctions avec le même nom mais des signatures différentes.
2. Polymorphisme dynamique (redéfinition) : Utilise des fonctions virtuelles pour adapter le comportement.

Voir l'article sur les fonctions avancées et notamment les surcharge de fonctions, paramètres par défaut, les fonctions inline et les lambdas.

4. Synthèse : Comment ces principes interagissent-ils ?

Les trois principes de la programmation orientée objet interagissent pour créer un code sécurisé, réutilisable et flexible.

• L'encapsulation protège les données sensibles.
• L'héritage simplifie la réutilisation et l'extension du code.
• Le polymorphisme permet d'adapter le comportement sans modifier le code existant.

5. Exercice pratique

Énoncé Créez un programme avec les classes suivantes :

Une classe Vehicule (parent) avec une méthode seDeplacer(). Deux classes enfants Voiture et Velo qui redéfinissent la méthode seDeplacer() pour afficher des comportements différents. Utilisez le polymorphisme pour manipuler les objets Voiture et Velo à travers un pointeur de type Vehicule.

Conclusion

La programmation orientée objet est un pilier du langage C++ et de nombreux autres langages modernes. En comprenant ses trois principes fondamentaux (encapsulation, héritage, polymorphisme), vous serez en mesure d'écrire un code plus organisé, maintenable et extensible.

C++ vous offre un contrôle total sur ces concepts, faisant de lui un langage puissant pour des projets de toutes tailles.

À propos de pointerlab

pointerlab s’inspire des fonctions lambda en C++, symbole de code concis, flexible et performant. C’est cette philosophie, mêlant rigueur et modernité, que nous mettons au service des défis de nos clients.

Experts C++ et Qt, nous maîtrisons des technologies de pointe comme Qt, OpenGL, OpenCV et Unreal Engine 5 pour concevoir des solutions logicielles sur mesure et robustes. Présents dans des secteurs exigeants tels que la simulation 3D, le médical ou l’aéronautique, nous allions innovation et expertise pour relever les défis les plus complexes.

• Vous avez un projet ? Contactez-nous dès maintenant pour discuter de vos besoins et découvrir comment nous pouvons collaborer.
• Vous êtes ingénieur logiciel C++ ? Rejoignez-nous ! Découvrez nos opportunités ici.
• Envie d’échanger avec la communauté des passionnés de C++ ? Rejoignez le Discord C++ France : CPP France By pointerlab.