Cours Programmation Orientée Objet – C++ L2 -2020/2021

Chapitre 1
Les Classes et les objets

Les objectifs : A la fin de ce chapitre l’étudiant sera capable de :

• Créer une classe ;
• Instancier une classe ;
• Manipuler les spécificateurs d’accès aux membres d’une classe ;
• Manipuler les pointeurs d’objet ;

Il existe aujourd'hui deux méthodes de programmation courantes ue :

• La programmation procédurale ;
• La programmation orientée objet (ou POO) ;

La programmation procédurale est une méthode d'écriture de logiciel centrée sur les
procédures ou les actions qui se déroulent dans un programme.
La programmation orientée objet est centrée sur les objets. Ces objets sont créés à partir de
types de données abstraits qui encapsulent les données et les fonctions ensembles.

I- Introduction aux classes

En C ++, la classe est la construction principale utilisée pour créer des objets. Sa déclaration
est similaire à celle des structures.
Une classe est un type de données défini par le programmeur. Elle est composée de variables et
de fonctions membres. Voici le format général d'une déclaration de classe :

class nomDeLaClasse{

... // Déclarations des données membres et des fonctions membres

};

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Important :
Le point-virgule à la fin de la déclaration d’une classe est très très très très important.

Exemple : le code suivant déclare une classe nommée Rectangle avec deux variables membres
: largeur et Longueur.

Il y a cependant un problème avec cette classe. Contrairement aux structures, les membres d'une
classe sont privés par défaut. Les membres de classe privés ne sont pas accessibles par des
instructions de programmation en dehors de la classe, ils sont protégés du code extérieur. Ainsi,
aucune instruction en dehors de cette classe Rectangle ne peut accéder aux membres Longueur
et Largeur.

a- Spécificateurs d'accès
C ++ fournit des mots clés :
• Private ;
• Public ;
• Protected ;
appelés spécificateurs d'accès que l’on utilise dans les déclarations de classe et qui permettent
de spécifier comment les membres de la classe peuvent être accessibles.
Voici le format général d'une déclaration de classe qui utilise les spécificateurs d'accès privé,
public et protégé.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

class nomDeLaClasse{
private :
... // placer ici les membres privés
public :
... // placer ici les membres publics
protected :
... // placer ici les membres privés
};

b- Les fonctions membres publics

Pour autoriser l'accès aux variables membres privées d'une classe, vous devez créer des
fonctions membres publiques qui manipuleront les variables membres privées. Par exemple,
considérez la classe Rectangle. Pour permettre l'accès aux variables membres Largeur et
Longueur d'un objet Rectangle, nous allons ajouter les fonctions membres suivantes :

Important :
Notez que les spécificateurs d'accès sont suivis de deux points (:), puis d'une ou plusieurs
déclarations de membre. Dans ce format général, le spécificateur d'accès private est utilisé
en premier. Toutes les déclarations qui le suivent, jusqu'au spécificateur d'accès public,
sont destinées aux membres privés. Ensuite, toutes les déclarations qui suivent le
spécificateur d'accès public sont destinées aux membres publics. Toutes les déclarations
qui le suivent, jusqu'au spécificateur d'accès protected, sont destinées aux membres public.
Enfin, toutes les déclarations qui suivent le spécificateur d'accès protected sont destinées
aux membres protégés.

Fonctions
Description
membres
SetLargeur Cette fonction accepte un argument, qui permet de modifier la variable membre Largeur
setLongueur Cette fonction accepte un argument, qui permet de modifier la variable membre Longueur
getLargeur Cette fonction renvoie la valeur stockée dans la variable membre Largeur.
getLongueur Cette fonction renvoie la valeur stockée dans la variable membre Longueur.
Cette valeur correspond à l'aire du rectangle. Cette fonction renvoie le produit des
getSurface
variables membres Largeur fois Longueur.
getPerimetre Cette valeur correspond au Perimètre du rectangle.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Pour le moment, nous ne définirons pas réellement les fonctions décrites. Nous ne ferons que
les déclarations des prototypes des fonctions dans la déclaration de la classe Rectangle :

Dans cette déclaration, la largeur et la longueur des variables membres sont déclarées comme
privées, ce qui signifie qu’elles ne sont accessibles que par les fonctions membres de la classe.
Les fonctions membres, cependant, sont déclarées comme publiques, ce qui signifie qu'elles
peuvent être appelées à partir d'instructions externes à la classe. Si le code en dehors de la classe
doit stocker une largeur ou une longueur dans un objet Rectangle, il doit le faire en appelant les
fonctions membres setLargeur ou setLongueur de l'objet. De même, si du code externe à la
classe doit récupérer une largeur ou une longueur stockée dans un objet Rectangle, il doit le
faire avec les fonctions membres getLargeur ou getLongueur de l'objet. Ces fonctions
publiques fournissent une interface pour le code en dehors de la classe pour utiliser des objets
Rectangle.

Important :
Même si l'accès par défaut à une classe est privé, il est toujours judicieux d'utiliser le
mot clé privé pour déclarer explicitement les membres privés. Cela documente
clairement la spécification d'accès de tous les membres de la classe.

c- Utilisation de const avec les fonctions membres

Notez que le mot clé const apparaît dans les déclarations des fonctions membres getLargeur,
getLongueur, getSurface et getPerimetre, comme présenté ci-dessus.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Lorsque le mot clé const apparaît après les parenthèses dans une déclaration d’une fonction
membre, il spécifie que la fonction ne modifiera aucune donnée stockée dans l'objet appelant.
Si vous écrivez par inadvertance du code dans la fonction qui modifie les données de l'objet
appelant, le compilateur générera une erreur.

Important :
Lorsque vous marquez une fonction membre comme const, le mot clé const doit
apparaître à la fois dans l'en-tête et dans la déclaration de la fonction. Étant donné que
cela diminue les chances d'avoir des bogues dans votre code, il est recommandé de
marquer toutes les fonctions d'accesseur comme const.

d- Définition des fonctions membre

Dans chaque définition de fonction, Rectangle:: précède le nom de chaque fonction :
Rectangle::
Les deux points sont appelés opérateur de résolution de portée. Lorsque Rectangle:: apparaît
avant le nom d'une fonction dans un en-tête de la fonction, il identifie la fonction en tant que
membre de la classe Rectangle.
Voici le format général de l'en-tête de fonction de toute fonction membre définie en dehors de
la déclaration d'une classe :

typeDeRetourDeLaFonction nomDeLaClasse::NomDeLaFonction(ListePArametres)

La déclaration de la classe Rectangle contient les déclarations ou les prototypes des fonctions
membres.
Les définitions de ces fonctions sont écrites en dehors de la déclaration de la classe :

~TP : Ecrire les autres fonctions membres~

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

e- Accesseurs et mutateurs
Comme mentionné précédemment, il est courant de rendre privées toutes les variables membres
d'une classe et de fournir des fonctions membres publiques pour y accéder et les modifier. Cela
garantit que l'objet propriétaire des variables membres contrôle toutes les modifications qui y
sont apportées.
Une fonction membre qui obtient une valeur de la variable membre d'une classe mais ne la
modifie pas est appelée accesseur.
Une fonction membre qui stocke une valeur dans une variable membre ou modifie la valeur
d'une variable membre est appelée mutateur.
Dans la classe Rectangle, les fonctions membres getLongueur et getLargeur sont des
accesseurs et les fonctions membres setLongueur et setLargeur sont des mutateurs.
Certains programmeurs se réfèrent aux mutateurs comme des fonctions de définition parce
qu'ils définissent la valeur d'un attribut et aux accesseurs comme des fonctions de lecture parce
qu'ils obtiennent la valeur d'un attribut.

II- Définition d'une instance d'une classe

Les objets de classe doivent être définis après la déclaration de la classe.
Comme les variables de structure, les objets de classe ne sont pas créés en mémoire tant qu'ils
ne sont pas définis. En effet, une déclaration de classe en elle-même ne crée pas d'objet, mais
est simplement la description d'un objet. Nous pouvons l'utiliser pour créer un ou plusieurs
objets, qui sont des instances de la classe.
Les objets de classe sont créés avec des instructions de définition simples, tout comme les
variables. Voici le format général d'une simple instruction de déclaration d'objet :

nomDeLaClasse nomDeLObjet ;

Exemple :
Rectangle R1;

La définition d'un objet de classe s'appelle l'instanciation d'une classe. Dans cette instruction,
R1 est une instance de la classe Rectangle.

a- Accéder aux membres d'un objet

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

L'objet R1 que nous avons précédemment défini est une instance de la classe Rectangle.
Supposons que nous voulions changer la valeur de la variable Largeur de l'objet R1. Pour ce
faire, nous devons utiliser l'objet R1 pour appeler la fonction membre setLargeur, comme
indiqué ci-dessous :
R1.setLargeur(9.15);
Tout comme vous utilisez l'opérateur point pour accéder aux membres d'une structure, vous
utilisez l'opérateur point pour appeler les fonctions membres d'une classe. Cette instruction
utilise l'objet R1 pour appeler la fonction membre setLargeur, en passant 9.15 comme
argument. Par conséquent, la variable de largeur de l’objet R1 sera définie sur 9,15.
~TP : Ecrivez un programme demandant à un user la longueur et la largeur du rectangle,
ensuite les affiche, ainsi que son périmètre et sa surface~

b- Pointeurs vers des objets

Vous pouvez également définir des pointeurs vers des objets de classe. Par exemple,
l'instruction suivante définit une variable de type pointeur nommée ptrRect :
Rectangle *ptrRect = nullptr;
La variable ptrRect n'est pas un objet, mais elle peut contenir l'adresse d'un objet Rectangle. Le
code suivant montre un exemple :

Le pointeur ptrRect peut ensuite être utilisé pour appeler des fonctions membres à l'aide de
l'opérateur ->. Les déclarations suivantes montrent des exemples :

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Nous voyons que l’instruction de la ligne 11 appelle la fonction membre setLargeur, en passant
9.15 comme argument. Étant donné que ptrRect pointe vers l’objet monRectangle, cela
entraînera le stockage de 9.15 dans la variable de largeur de l’objet monRectangle. De même à
la ligne 12 l’instruction appelle la fonction membre setLongueur, en transmettant 2.4 comme
argument. Cela entraînera le stockage de 2.4 dans la variable de longueur de l'objet
monRectangle.

Les pointeurs d'objet de classe peuvent être utilisés pour allouer dynamiquement des objets.
Nous pouvons reécrire le code ci-dessus comme suit :

La ligne 10 définit ptrRect comme un pointeur de type Rectangle. La ligne 13 utilise l'opérateur
new pour allouer dynamiquement un objet Rectangle et affecter son adresse à ptrRect. Les

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

lignes 16 et 17 stockent les valeurs dans les variables Largeur et Longueur de l’objet alloué
dynamiquement.
La ligne 12 supprime l'objet de la mémoire et la ligne 13 replace le pointeur à l'adresse null,
cela empêche le code d'utiliser par inadvertance le pointeur pour accéder à la zone mémoire qui
a été libérée. Il empêche également les erreurs de se produire si la suppression du nouveau le
pointeur est accidentellement appelée.
~TP~

c- Utilisation de pointeurs intelligents pour allouer des objets

Le chapitre sur les pointeurs aborde le type de données de pointeur intelligent unique_ptr, qui
a été introduit avec le C++11. L’on peut utiliser un unique_ptr pour allouer dynamiquement de
la mémoire, sans vous soucier de la suppression de la mémoire lorsque vous avez fini de
l'utiliser.
Un unique_ptr supprime automatiquement un morceau de mémoire allouée dynamiquement
lorsque la mémoire n'est plus utilisée. Cela permet d'éviter les fuites de mémoire.
Pour utiliser le type de données unique_ptr, vous devez inclure le fichier d'en-tête de mémoire
:
#include <memory>
Voici un exemple de syntaxe pour définir un unique_ptr qui pointe vers un objet Rectangle
alloué dynamiquement :
unique_ptr<Rectangle> ptrRect (new Rectangle);
Cette instruction définit un unique_ptr nommé ptrRect qui pointe vers un objet Rectangle
alloué dynamiquement. Voici quelques détails sur la déclaration :
• La notation <Rectangle> qui apparaît immédiatement après unique_ptr indique que le
pointeur peut pointer vers un Rectangle ;
• Le nom du pointeur est ptrRect ;
• L'expression new Rectangle qui apparaît entre parenthèses alloue un morceau de
mémoire pour contenir un Rectangle. L'adresse du bloc de mémoire sera affectée au
pointeur ptrRect.

Une fois que vous avez défini un unique_ptr, vous pouvez l'utiliser de la même manière qu'un
pointeur normal.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

À la ligne 3, nous avons une directive #include pour le fichier d'en-tête de la mémoire. La ligne
9 définit un unique_ptr, nommé ptrRect, qui pointe vers un rectangle alloué dynamiquement.
Notez qu'il n'y a pas d'instructions de suppression à la fin de la fonction main pour libérer la
mémoire allouée dynamiquement. Il n'est pas nécessaire de supprimer l’objet Rectangle alloué
dynamiquement car le pointeur intelligent les supprimera automatiquement à la fin de la
fonction.

III- Les membres private ?

Dans la programmation orientée objet, un objet doit protéger ses données importantes en les
rendant privées et en fournissant une interface publique pour accéder à ces données. Vous
pouvez vous demander pourquoi les fonctions membres ont été définies pour des tâches aussi
simples que la modification et l’acquisition des variables membres. Après tout, si les variables
membres étaient déclarées comme publiques, les fonctions membres ne seraient pas
nécessaires.
Comme mentionné précédemment dans ce chapitre, les classes ont généralement des variables
et des fonctions destinées uniquement à être utilisées en interne. Ils ne sont pas destinés à être
accessibles par des instructions en dehors de la classe. Cela protège les données critiques contre
toute modification accidentelle ou utilisation d'une manière qui pourrait nuire à l'état de l'objet.
Lorsqu'une variable membre est déclarée comme privée, le seul moyen pour une application de
stocker des valeurs dans la variable est d’utiliser une fonction membre publique. De même, le

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

seul moyen pour une application de récupérer le contenu d'une variable membre privée est
d’utiliser une fonction membre publique. En substance, les membres publics deviennent une
interface avec l'objet. Ce sont les seuls membres auxquels toute application utilisant l'objet peut
accéder.

IV- Les fonctions membres inline

Lorsque le corps d'une fonction membre est écrit dans une déclaration de classe, il est déclaré
inline. Rappellez-vous que lorsque le corps d'une fonction membre est petit, il est généralement
pratique de placer sa définition, au lieu de son prototype, dans la déclaration de classe. Par
exemple, dans la classe Rectangle, les fonctions membres getLargeur, getLongueur,
getSurface et getPerimetre n'ont chacune qu'une seule instruction. Alors ces fonctions
membres pourront être déclarées inline.
Notez que, comme les définitions de fonction sont dans la classe, il n'est pas nécessaire d'utiliser
l'opérateur de résolution de portée et le nom de classe dans l'en-tête de la fonction.
Notez que les fonctions getLargeur, getLongueur, getSurface et getPerimetre sont déclarées
inline, mais pas les fonctions setLargeur et setLongueur. Ils sont toujours définis en dehors de
la déclaration de la classe.
~TP : Réécrire ces fonctions getters~

a- Fonctions inline et leur performance

Chaque fois qu'une fonction est appelée, un certain nombre d’éléments spéciaux, tels que
l’adresse de retour de la fonction dans le programme et les valeurs des arguments, sont stockées
dans une section de mémoire appelée pile. En outre, des variables locales sont créées et un
emplacement est réservé pour la valeur de retour de la fonction. Toute cette surcharge, qui
prépare le terrain pour un appel de fonction, prend un temps précieux au processeur. Bien que
le temps nécessaire soit minuscule, il peut s'additionner si une fonction est appelée plusieurs
fois, comme dans une boucle.
Les fonctions inline sont compilées différemment des autres fonctions. Dans le code
exécutable, les fonctions inline ne sont pas « appelées » au sens conventionnel. Dans un
processus connu sous le nom d'expansion en ligne, le compilateur remplace l'appel d’une
fonction inline par le code de la fonction elle-même. Cela signifie que la surcharge nécessaire
pour un appel de fonction conventionnel n'est pas nécessaire pour une fonction inline et peut
entraîner une amélioration des performances.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

V- Les Constructeurs
Un constructeur est une fonction membre qui est automatiquement appelée lorsqu'un objet de
classe est créé. Il porte le même nom que la classe et est automatiquement appelé lorsque l'objet
est créé en mémoire ou instancié. Il est utile de considérer les constructeurs comme des routines
d'initialisation. Ils sont très utiles pour initialiser les variables membres ou effectuer d'autres
opérations de configuration.

Notez que l’en-tête de la fonction du constructeur est différent de celui d’une fonction membre
régulière. Il n'a pas de type de retour, même pas void. Cela est dû au fait que les constructeurs
ne sont pas exécutés par des appels de fonction explicites et ne peuvent pas renvoyer de valeur.
L’en-tête de fonction d’une définition externe d’un constructeur a la forme suivante :

nomDeLaClasse::nomDeLaClasse(listeParametres)

Dans le format général, nomDeLaClasse est le nom de la classe et listeParametres est une liste
facultative de déclarations de la liste de paramètres.

Nous tenons à préciser par l’exemple ci-dessous qu’un constructeur lorsqu’il est déclaré et
défini, est automatiquement appelé lors de l’instanciation de la classe.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Dans le programme ci-dessus, le constructeur de l’Object R1 s’exécute automatiquement

lorsque l’objet est défini.

a- Le constructeur par défaut

Tous les exemples que nous avons examinés dans cette section montrent des constructeurs par
défaut. Un constructeur par défaut est un constructeur qui ne prend aucun argument. Comme
les fonctions normales, les constructeurs peuvent accepter des arguments, avoir des arguments
par défaut, être déclarés inline et être surchargés. Nous en verrons des exemples au fur et à
mesure que nous progressons dans le chapitre.
Si vous écrivez une classe sans aucun constructeur, lorsque la classe est compilée, C++ écrira
automatiquement un constructeur par défaut qui ne fait rien. Par exemple, la première version
de la classe Rectangle n'avait pas de constructeur ; Ainsi, lorsque la classe a été compilée, C++
a généré le constructeur suivant :
Rectangle :: Rectangle ()
{}

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

b- Constructeurs par défaut et objets alloués dynamiquement

Nous avons expliqué précédemment comment les objets de classe peuvent être alloués
dynamiquement en mémoire. Par exemple, supposons que le pointeur suivant soit défini dans
un programme :
Rectangle * rectPtr = nullptr;
Cette instruction définit ptrRect comme un pointeur sur un Rectangle. Il peut contenir l'adresse
de n'importe quel objet Rectangle. Mais comme cette instruction ne crée pas réellement un objet
Rectangle, le constructeur ne s'exécute pas. Supposons que nous utilisions le pointeur dans une
instruction qui alloue dynamiquement un objet Rectangle, comme indiqué dans le code suivant.
ptrRect = new Rectangle;
Cette instruction crée un objet Rectangle. Lorsque l'objet Rectangle est créé par l'opérateur new,
son constructeur par défaut est automatiquement exécuté.

VI- Passer des arguments aux constructeurs

Un constructeur peut avoir des paramètres et peut accepter des arguments lorsqu'un objet est
créé.
Les constructeurs peuvent accepter des arguments de la même manière que les autres fonctions.
Lorsqu'une classe a un constructeur qui accepte des arguments, vous pouvez transmettre des
valeurs d'initialisation au constructeur lorsque vous créez un objet.
Par exemple, le code suivant montre encore une autre version de la classe Rectangle. Cette
version a un constructeur qui accepte des arguments pour la largeur et la longueur du rectangle.

Fichier Rectangle.h

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Fichier Rectangle.cpp

Fichier main.cpp :

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

a- Utilisation d'arguments par défaut avec des constructeurs

Comme d'autres fonctions, les constructeurs peuvent avoir des arguments par défaut. Rappelez-
vous que les arguments par défaut sont passés aux paramètres automatiquement si aucun
argument n'est fourni dans l'appel de fonction.

b- En savoir plus sur le constructeur par défaut

Il a été mentionné précédemment que lorsqu'un constructeur n'accepte pas d'arguments, il est
connu comme le constructeur par défaut. Si un constructeur a des arguments par défaut pour
tous ses paramètres, il peut être appelé sans argument explicite. Il devient alors le constructeur
par défaut.
Rectangle(double a = 1, double b = 2) ;
Ce constructeur a des arguments par défaut pour chacun de ses paramètres. En conséquence, le
constructeur peut être appelé sans argument, comme illustré ici:
Rectangle R1 ;
Cette déclaration définit un objet Sale. Aucun argument n'a été passé au constructeur, donc les

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Important : Classes sans constructeur par défaut

Lorsque tous les constructeurs d’une classe nécessitent des arguments, la classe n’a pas de
constructeur par défaut. Dans un tel cas, vous devez transmettre les arguments requis au
constructeur lors de la création d'un objet. Sinon, une erreur du compilateur se produira.

VII- Destructeurs
Un destructeur est une fonction membre qui est automatiquement appelée lorsqu'un objet est
détruit.
Les destructeurs sont des fonctions membres portant le même nom que la classe, précédées d'un
caractère tilde (~). Par exemple, le destructeur de la classe Rectangle serait nommé ~Rectangle.
Les destructeurs sont automatiquement appelés lorsqu'un objet est détruit. De la même manière
que les constructeurs configurent les objets lors de la création d'un objet, les destructeurs
exécutent des procédures d'arrêt lorsque l'objet cesse d'exister. Par exemple, une utilisation
courante des destructeurs consiste à libérer de la mémoire allouée dynamiquement par l'objet
de classe.

Important :
En plus du fait que les destructeurs sont automatiquement appelés lorsqu'un objet est
détruit, les points suivants doivent être mentionnés :
• Comme les constructeurs, les destructeurs n'ont pas de type de retour.
a- Destructeurs et objets de classe alloués dynamiquement
• Les destructeurs ne peuvent pas accepter d'arguments, ils n'ont donc jamais de
liste de paramètres.
Si un objet de classe a été alloué dynamiquement par l'opérateur new, sa mémoire doit être
libéré lorsque l'objet n'est plus nécessaire.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Important :
Si vous avez utilisé un pointeur intelligent tel que unique_ptr (introduit dans C++11)
pour allouer un objet, l'objet sera automatiquement supprimé et son destructeur sera
appelé lorsque le pointeur intelligent sortira de la portée. Il n'est pas nécessaire
d'utiliser delete avec un unique_ptr.

VIII- Tableaux d'objets

Vous pouvez définir et travailler avec des tableaux d'objets de classe.

Comme pour tout autre type de données en C++, vous pouvez définir des tableaux d'objets de
classe. Un tableau d'objets de type Rectangle peut être crééS. Voici un exemple d'une telle
définition :

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

Cette instruction définit un tableau de 12 objets de type Rectangle. Le nom du tableau est tR et
le constructeur par défaut est appelé pour chaque objet du tableau.
Si vous souhaitez définir un tableau d'objets et appeler un constructeur nécessitant des
arguments, vous devez spécifier les arguments de chaque objet individuellement dans une liste
d'initialiseurs. Voici un exemple :

Le compilateur traite chaque élément de la liste d’initialiseurs comme un argument du

constructeur d’un élément de tableau.

Proposé par : M CHATCHUIN DJOKO Dassy

Cours Programmation Orientée Objet – C++ L2 -2020/2021

ATTENTION :
Si la classe n'a pas de constructeur par défaut, vous devez fournir un initialiseur pour chaque
objet du tableau.

Si vous ne fournissez pas d'initialiseur pour tous les objets d'un tableau, le constructeur par
défaut sera appelé pour chaque objet qui n'a pas d'initialiseur. Par exemple, l'instruction suivante
définit un tableau de trois objets, mais ne fournit des initialiseurs que pour les deux premiers.
Le constructeur par défaut est appelé pour le troisième objet.
En résumé, si vous utilisez une liste d'initialiseurs pour les tableaux d'objets de classe, il y a
trois choses à retenir :
• S'il n'y a pas de constructeur par défaut, vous devez fournir un initialiseur pour chaque
objet du tableau.
• S'il y a moins d'initialiseurs dans la liste que d'objets dans le tableau, le constructeur par
défaut sera appelé pour tous les objets restants.
• Si un constructeur requiert plus d'un argument, l'initialiseur prend la forme d'un appel
de fonction constructeur.

b- Accès aux membres des objets dans un tableau

Les objets d'un tableau sont accessibles via leurs indices, comme tout autre type de données
d'un tableau. Par exemple, pour appeler la fonction membre getSurface() de l'objet tR[1],
l'instruction suivante peut être utilisée :

Nous avons donc à la ligne 14 : cout<<"La surface est : "<<tR[1].getSurface();

Proposé par : M CHATCHUIN DJOKO Dassy