Classes et objets en C++ : Guide pratique avec exemples de code

Tout comme un plan de maison spécifie l'emplacement des portes, fenêtres et pièces, une classe décrit la disposition de ses membres de données et les opérations qui peuvent les manipuler. Plusieurs maisons (objets) peuvent être construites à partir du même plan.

Dans l'illustration ci-dessus, le prototype unique produit deux maisons distinctes avec des caractéristiques différentes.

Dans ce tutoriel, vous apprendrez :

• Ce qu'est une classe et pourquoi elle est importante en C++
• Exemples concrets de classes
• Le rôle des modificateurs d'accès private et public
• Comment créer des objets (instanciation)
• Accéder aux membres de données en toute sécurité
• Fonctions membres à l'intérieur et à l'extérieur de la définition de classe
• Constructeurs et destructeurs en action

Déclaration de classe

Déclarer une classe est simple : utilisez le mot-clé class suivi du nom de la classe et encadrez le corps entre accolades.

Syntaxe

class nomClasse { // membres de données // fonctions membres };

• nomClasse – l'identifiant pour votre classe.
• Les membres de données sont généralement déclarés comme variables.
• Les fonctions membres fournissent le comportement.

Modificateurs d'accès : private vs public

Les modificateurs d'accès contrôlent la visibilité des membres de classe.

• private – les membres ne sont accessibles qu'à l'intérieur de la classe ou de ses amies.
• public – les membres peuvent être accédés de n'importe où où l'objet est visible.

Création d'objets (Instanciation)

Les objets sont des instances d'une classe. Déclarer un objet suit le même motif que déclarer une variable : nomClasse nomObjet;

Syntaxe

nomClasse nomObjet;

• nomClasse – la classe à partir de laquelle l'objet est créé.
• nomObjet – l'identifiant pour le nouvel objet.

L'instanciation alloue de la mémoire pour l'objet et peut déclencher son constructeur.

Accès aux membres de données

Les membres de données publics sont accédés en utilisant l'opérateur point (.).

Exemple

#include <iostream>
using namespace std;
class Phone {
public:
    double cost;
    int slots;
};
int main() {
    Phone Y6;
    Phone Y7;
    Y6.cost = 100.0;
    Y6.slots = 2;
    Y7.cost = 200.0;
    Y7.slots = 2;
    cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
    cout << "Cost of Huawei Y7 : " << Y7.cost << endl;
    cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
    cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;
    return 0;
}

Sortie :

Pourquoi utiliser des Getters/Setters ?

Accéder ou modifier les données directement peut briser l'encapsulation. L'utilisation de fonctions membres getter et setter fournit un accès contrôlé.

Exemple avec encapsulation

#include <iostream>
using namespace std;
class ClassA {
public:
    void setA(int val);
    int getA() const;
private:
    int a;
};
int ClassA::getA() const {
    return a;
}
void ClassA::setA(int val) {
    a = val;
}
int main() {
    ClassA obj;
    obj.setA(20);
    cout << "Value of a is: " << obj.getA();
    return 0;
}

Sortie :

Membres protégés et héritage

Les membres protégés sont accessibles dans la classe et par les classes dérivées, permettant un héritage contrôlé.

Exemple

#include <iostream>
using namespace std;
class ParentClass {
protected:
    int value;
};
class ChildClass : public ParentClass {
public:
    void setId(int x) {
        value = x;
    }
    void displayValue() {
        cout << "Value is: " << value << endl;
    }
};
int main() {
    ChildClass c;
    c.setId(21);
    c.displayValue();
    return 0;
}

Sortie :

Fonctions membres à l'intérieur vs à l'extérieur de la classe

Les fonctions membres peuvent être définies en ligne dans la classe ou déclarées à l'intérieur et définies plus tard en utilisant l'opérateur de résolution de portée ::.

Exemple

#include <iostream>
#include <string>
using namespace std;
class Guru99 {
public:
    string tutorial_name;
    int id;
    void printName();
    void printId() {
        cout << "Tutorial id is: " << id;
    }
};
void Guru99::printName() {
    cout << "Tutorial name is: " << tutorial_name;
}
int main() {
    Guru99 guru;
    guru.tutorial_name = "C++";
    guru.id = 1001;
    guru.printName();
    cout << endl;
    guru.printId();
    return 0;
}

Sortie :

Constructeurs et destructeurs

Les constructeurs initialisent les objets quand ils sont créés, tandis que les destructeurs nettoient juste avant qu'un objet ne soit détruit.

Exemple

#include <iostream>
using namespace std;
class ClassA {
public:
    ClassA() {
        cout << "Class constructor called" << endl;
    }
    ~ClassA() {
        cout << "Class destructor called" << endl;
    }
};
int main() {
    ClassA a; // constructeur appelé
    int p = 1;
    if (p) {
        ClassA b; // constructeur appelé, destructeur appelé à la fin du bloc
    } // destructeur pour 'a' appelé ici
    return 0;
}

Sortie :

Points clés à retenir

• Le C++ est fondamentalement orienté objet ; les classes sont les blocs de construction.
• Une classe regroupe données et fonctions associées, créant un plan réutilisable.
• Utilisez public, private et protected pour imposer l'encapsulation.
• Instanciez des objets avec le nom de la classe suivi du nom de l'objet.
• Accédez aux membres publics via l'opérateur point ; utilisez getters/setters pour les données privées.
• Les fonctions membres peuvent être définies en ligne ou à l'extérieur de la classe avec ::.
• Les constructeurs initialisent les objets ; les destructeurs gèrent le nettoyage.