Introduction aux Classes et ses Membres

Dr SIDIBE A. MA, ENI-ABT

Définition
Une classe est simplement une collection de variables, souvent de types différents, combinées à un
ensemble de fonctions associées.
Les variables de la classe sont appelées variables membres ou données membres. Les fonctions de la
classe sont appelées fonctions membres ou méthodes. Elles déterminent ce que votre classe peut faire. Les
fonctions membres de la classe manipulent généralement les variables membres.
Exemple:
Une classe Voiture peut avoir des variables membres représentant les sièges, le type de radio, les pneus, etc.
Une façon de penser à une voiture est comme un ensemble de roues, de portes, de sièges, de fenêtres, etc. -
Une autre façon consiste à réfléchir à ce qu'une voiture peut faire : elle peut se déplacer, accélérer, ralentir,
s'arrêter, se garer, etc. Par exemple, les méthodes de la classe Voiture peuvent inclure les fonctions membre
: Start() et Brake(). Une classe Cat peut avoir des données membres qui représentent l'âge et le poids ; ses
méthodes peuvent inclure Sleep(), Meow() et ChaseMice().
NB: Une classe peut être constituée de n'importe quelle combinaison des types de variables et
également d'autres types de classe.
Déclaration d’une classe
La déclaration d'une classe informe le compilateur de la classe. Pour déclarer une classe, utilisez le mot-clé
class suivi du nom de la classe, d'une accolade ouvrante, puis d'une liste des données membres et des
méthodes de cette classe. Terminez la déclaration par une accolade fermante et un point-virgule. Un
exemple de définition de classe est la suivante :
class Circle // En-tête
{
private:
double radius; // Déclaration de donnée membere
public:
double getRadius () const; // Déclaration de fonction membre
double getArea () const; // Déclaration de fonction membre
double getPerimeter () const; // Déclaration de fonction membre
void setRadius (double value); // Déclaration de fonction membre
}; // le point virgule est nécessaire à la fin de la déclaration de classe
Déclaration d’une classe
Déclarer cette classe n'alloue pas de mémoire pour un Circle. Il indique simplement au compilateur ce
qu'est un Circle, les données membres qu'il contient et ce qu'il peut faire. Bien que la mémoire ne soit pas
allouée, elle permet au compilateur de connaître la taille d'un Circle, c'est-à-dire la quantité d'espace que
le compilateur doit réserver pour chaque Circle que l’on créera.
Déclaration des Données Membres
Une partie de la déclaration de classe déclare les données membres de la classe, les variables ou
les constantes des types intégrés ou d'autres types de classe précédemment définis. Les données
membres d'une classe simulent les attributs des objets qui sont instanciés à partir de la
classe. Cependant, dans tout objet, on peut avoir plusieurs attributs, dont certains
dépendent des autres et peuvent être calculés compte tenu des autres attributs.
Parmi les attributs dépendants, on doit sélectionner les plus simples et les plus
élémentaires. Par exemple, dans notre classe Circle, nous avons trois attributs: rayon, aire et
périmètre. Chacun d'eux peut être calculé à partir de l'un des deux autres, mais le rayon est le
plus simple et le plus basique. Donc, on a choisi le rayon comme donnée membre.
NB : Les données membres d'une classe ne doivent pas dépendre les unes des autres.
Déclaration de Fonctions Membres

La deuxième partie de la déclaration de classe déclare les fonctions membres de la classe ;

c'est-à-dire qu'il déclare toutes les fonctions utilisées pour simuler le comportement de la
classe. La déclaration des fonctions membres est similaire à la déclaration de prototype de
fonctions. Cependant, Il y a une différence : certaines fonctions ont le qualificatif const à la
fin et d'autres non. Ceux qui changent quelque chose dans l'objet ne peuvent pas utiliser ce
qualificatif ; ceux qui ne sont pas autorisés à changer quoi que ce soit ont besoin du
qualificatif const.
Modificateurs d'accès
Le modificateur d'accès détermine comment une classe peut être accessible. La déclaration
des données membres et des fonctions membres dans une classe est par défaut privée. Ces
données membres et fonctions membres ne sont pas accessibles pour la récupération ou la
modification.

NB : Lorsqu'il n'y a pas de modificateur d'accès pour un membre, il est privé par défaut.

Pour contourner cette limitation, C++ définit trois modificateurs d'accès. Le concepteur d'une
classe peut appliquer un modificateur d'accès à la déclaration d'un membre pour contrôler
l'accès à ce membre.
Modificateurs d'accès
C++ utilise trois modificateurs à cette fin : private, public et protected, comme illustré à la figure ci-
dessous.

Figure 1: Modificateurs d'accès

Modificateurs d'accès
Le tableau suivant donne l'idée générale derrière chaque modificateur.

Modificateur Accès depuis la Accès depuis la Accès depuis

même classe sous-classe n'importe où
d'accès

Private Oui Non Non

Protected Oui Oui Non
Public Oui Oui Oui

Lorsqu'un membre est privé, il n'est accessible qu'à l'intérieur de la classe (via les fonctions membres).
Lorsqu'un membre est public, il est accessible de n'importe où (à l'intérieur de la même classe, à
l'intérieur des sous-classes et dans l'application). Nous discuterons des membres protected lorsque
nous aborderons la notion d’héritage (les sous-classes).
Modificateurs d'accès pour les données membres
Les modificateurs des données membres sont normalement définis sur private pour la mise en
évidence (bien qu'aucun modificateur ne signifie privé). Cela signifie que les données membres ne
sont pas accessibles directement. Ils doivent être accessibles via les fonctions membres. Cependant,
une donnée membre privé est visible, mais il n'est pas accessible, sauf via une fonction membre.
NB : Les données membres d'une classe sont normalement définies sur private.

Modificateurs d'accès pour les fonctions membres

Pour fonctionner sur les données membres, l'application doit utiliser des fonctions membres, ce qui
signifie que la déclaration des fonctions membres doit généralement être définie sur public.
NB : Les fonctions membres d'instance d'une classe sont normalement définies sur public.
Cependant, le modificateur d'une fonction membre doit parfois être défini sur private, par exemple
lorsqu'une fonction membre doit aider d'autres fonctions membres mais n'est pas autorisée à être
appelée par des fonctions extérieures à la classe.
Modificateur d’accès de groupe
Nous pouvons remarquer que nous n'avons utilisé qu'un seul mot-clé, private, et un seul mot-
clé, public, dans toute la déclaration de la classe. C'est ce qu'on appelle le modificateur de
groupe. Nous avons rassemblé tous les données membres dans un groupe et avons utilisé le
mot-clé private suivi de deux points pour dire que tous les mots-clés sont private. Nous avons
également regroupé toutes les fonctions membres et utilisé un mot-clé public suivi de deux-
points pour indiquer qu'elles sont toutes publiques. En d'autres termes, un modificateur est
valide jusqu'à ce que nous en rencontrions un nouveau. Nous aurions pu définir le
modificateur suivi de deux points pour chaque données membre ou fonction membre, mais ce
n'est pas nécessaire. L'indentation après le modificateur est juste pour plus de clarté.
Définition des fonctions membres

La déclaration d'une fonction membre donne son prototype ; chaque fonction membre a
également besoin d'une définition. Généralement la définition d'une fonction est faite séparément,
c’est-à-dire en dehors de la déclaration de la classe.

La définition de chaque fonction membre est similaire à la définition d’une fonction, mais elle
diffère de celle-ci avec deux aspects. Le premier aspect est que le qualificatif (const) peut être
appliqué à la définition de la fonction membre. Le second aspect est le nom de la fonction
qui doit être qualifié avec le nom de la classe.

NB: Il faut aussi notez que dans la définition de la fonction membre, le type de retour de la
fonction doit précéder le nom entier de la fonction membre.
Définition des fonctions membres
Ci-dessous nous présentons une définition pour chaque fonction membre de la classe Circle
précédemment définie.
double Circle :: getRadius () const
{ return radius;
}
double Circle :: getArea () const
{ const double PI = 3.14;
return (PI * radius * radius);
}
double Circle :: getPerimeter () const
{ const double PI = 3.14;
return (2 * PI * radius);
}
void Circle :: setRadius (double value)
{ radius = value;
}
Les Fonctions inline
Lorsque le corps d'une fonction est court, le temps d'exécution impliqué dans l'appel de la fonction
(stockage des arguments, transfert du contrôle, récupération de l'argument et stockage de la valeur de
retour) peut être supérieur à l'exécution du code à l'intérieur de la fonction. Pour améliorer les
performances du programme, nous pouvons déclarer une fonction en tant que fonction inline
pour indiquer que le compilateur peut remplacer l'appel de fonction par le code réel de la
fonction.
Instanciation d’Objet
Une instance est un objet qui encapsule les données membres définis dans la déclaration de
classe. Avant d'utiliser une fonction membre, nous devons instancier un objet de la classe
comme indiqué ci-dessous :

Circle circle1;

Après cette ligne, nous avons un objet nommé cercle1 qui encapsule une seule donnée membre
(ou variable) nommé rayon de type double, qui contient les ordures laissées par l'opération
précédente. Il faut changer la valeur de cette variable avant de l'utiliser.
Application d'une opération sur des objets

Après instanciation, nous pouvons laisser l'objet appliquer sur lui-même une ou plusieurs
opérations définies dans la définition de la fonction membre.

circle1.setRadius (10.0);
cout << "Radius: " << circle1.getRadius() << endl;
cout << "Area: " << circle1.getArea() << endl;
cout << "Perimeter: " << circle1.getPerimeter() << endl << endl;

La première ligne définit le rayon du cercle1. La deuxième ligne obtient la valeur du rayon du
cercle. Les deux lignes suivantes calculent et impriment l'aire et le périmètre de l'objet nommé
cercle1.
Sélection des membres
Le point utilisé entre le nom de l'objet et la fonction membre censée opérer sur l'objet est
appelé l'opérateur de sélection de membre. En d'autres termes, nous pouvons appliquer la
même fonction sur différents objets en utilisant cet opérateur comme indiqué ci-dessous :

circle1.getRadius(); // circle1 est censé obtenir son rayon

circle2.getRadius(); // circle2 est censé obtenir son rayon

Constructeurs et Destructeurs
Dans la programmation orientée objet, une instance est un objet qui encapsule les données
membres définis dans la déclaration de classe. Lorsque nous voulons qu'un objet effectue
certaines opérations sur lui-même, nous devons d'abord créer l'objet et initialiser ses
données membres. La création de l’objet est effectuée lorsqu'une fonction membre spéciale
nommée constructeur est appelée dans l'application ; l'initialisation de l’objet est effectuée
lorsque le corps d'un constructeur est exécuté.

D'autre part, lorsque nous n'avons plus besoin d'un objet, l'objet doit être nettoyé (ou detruit)
et la mémoire occupée par l'objet doit être recyclée. Le nettoyage de l’objet est
automatiquement effectué lorsqu'une autre fonction membre spéciale nommée destructeur est
appelée, l'objet sort de la portée et le corps du destructeur est exécuté ; le recyclage de la
mémoire est effectué à la fin du programme.
Constructeurs et Destructeurs
NB : Un constructeur est une fonction membre spéciale qui crée et initialise un objet. Un
destructeur est une fonction membre spéciale qui détruit un objet et libère l’espace mémoire qu’il
occupe (recyclage).

En d'autres termes, comme le montre la figure suivante, un objet passe par cinq étapes. Il est créé et
initialisé par une fonction membre spéciale appelée constructeur. Il applique certaines opérations
demandées par l'application sur elle-même. Il est nettoyé et recyclé par une autre fonction membre
spéciale appelée destructeur.

Figure : Les étapes qu’un Objet passe par

Constructeurs
Un constructeur est une fonction membre qui crée un objet lorsqu'il est appelé et initialise les données
membres d'un objet lorsqu'il est exécuté. La déclaration des données membres dans la déclaration de la
classe n'initialise pas les données membres ; la déclaration donne juste les noms et les types des
données membres.
Un constructeur a deux caractéristiques : il n'a pas de valeur de retour et son nom est le même
que le nom de la classe. Un constructeur ne peut pas avoir de valeur de retour (pas même void)
car il n'est pas conçu pour retourner quoi que ce soit ; son but est différent. Il crée un objet et
initialise les données membres. Un constructeur peut également effectuer d'autres tâches, telles que la
validation de valeurs, ces tâches sont également considérées comme faisant partie de l'initialisation.
Lorsqu’un constructeur n'est pas déclaré dans la classe, il est créé automatiquement. Si la classe a
plusieurs constructeurs, alors le mécanisme de surcharge de fonction est utilisé, c'est-à-dire que les
constructeurs doivent être distingués par les listes de paramètres.
Les Différents Types de Constructeurs

On distingue trois types de constructeurs dans une classe : les constructeurs de paramètres,
les constructeurs par défaut et les constructeurs de copie.
Constructeur de Paramètres

Normalement, nous avons un constructeur de paramètres qui initialise les données membres
de chaque instance (objet) avec des valeurs spécifiées. Le constructeur de paramètres peut
être surchargé, ce qui signifie qu’on peut avoir plusieurs constructeurs de paramètres
chacun avec une signature différente. L'avantage du constructeur de paramètres est que
nous pouvons initialiser les données membres de chaque objet avec une valeur
spécifique. En d'autres termes, si nous utilisons un constructeur de paramètres, le rayon d'un
cercle peut être initialisé à 3,1, un autre à 4,6, et ainsi de suite.

NB : Le constructeur de paramètres peut être surchargé pour une classe.

Constructeur par défaut

Le constructeur par défaut est un constructeur sans paramètres. Il est utilisé pour créer
des objets avec chaque données membre pour tous les objets définis sur des valeurs littérales
ou des valeurs par défaut. Il faut noter que nous ne pouvons pas surcharger le constructeur par
défaut car il n'a pas de liste de paramètres et n'est donc pas éligible à la surcharge.

NB : Le constructeur par défaut ne peut pas être surchargé pour une classe.
Constructeur de copier
Parfois, nous voulons initialiser chaque donnée membre d'un objet à la même valeur qu'une
donnée membre correspondant d'un objet créé précédemment. On peut utiliser un constructeur
de copie dans ce cas. Un constructeur de copie permet de copier les valeurs des données
membres de l'objet donné dans le nouvel objet qui vient d'être créé. Après avoir appelé le
constructeur de copie, les objets source et destination ont exactement la même valeur
pour chaque membre de données, bien qu'il s'agisse d'objets différents. Le constructeur
de copie n'a qu'un seul paramètre qui reçoit l'objet source par référence. Le modificateur
const devant le type de paramètre garantit que le passage par référence ne peut pas modifier
l'objet source.
Constructeur de Copier

Rappelons que le passage par référence a deux caractéristiques. Tout d'abord, il n'est pas
nécessaire de copier physiquement l'objet. Deuxièmement, un changement dans la destination
signifie le même changement dans la source. En utilisant le modificateur const, on garde la
première caractéristique, mais on interdit la seconde.

A noter également qu’on ne peut pas surcharger le constructeur de copie car la liste des
paramètres est fixe et nous ne pouvons pas avoir de forme alternative.

NB : Le constructeur de copie ne peut pas être surchargé pour une classe.

Déclaration du Constructeur
Un constructeur est une fonction membre de la classe, ce qui signifie qu'il doit être déclaré dans la
définition de la classe. Un constructeur n'a pas de valeur de retour, son nom est le même que le nom de
la classe et il ne peut pas avoir le qualificatif const car le constructeur initialise la valeur des données
membres (plus à ce sujet plus tard). Dans l’exemple suivant on montre comment nous ajoutons la
déclaration de trois constructeurs à notre classe Circle.
class Circle
{ …
public:
Circle (double radius); // Constructeur de paramètres
Circle (); // Constructeur par défaut
Circle (const Circle& circle); // Constructeur de copie
…
}

NB : Tous les constructeurs de la classe sont normalement publics, donc l'application peut appeler
n'importe lequel des constructeurs pour initialiser un objet de la classe.
Définition du Constructeur
Un constructeur est une fonction membre, mais spéciale. Il ne peut pas avoir de valeur de retour et
son nom est le même que le nom de la classe. Ce qui suit montre la définition des trois
constructeurs pour la classe Circle.
Définition du constructeur de paramètre Définition du constructeur par défaut

Circle :: Circle (double rds) Circle :: Circle ()

: radius (rds) // la liste d’initialisation : radius (1.0) // la liste d’initialisation. S'il est manquant, le rayon est défin
{ // sur des valeurs parasites
// tout autres instructions
{
}
// tout autres instructions
}
Définition du Constructeur
Définition du constructeur de copie

Circle :: Circle (const Circle& cr)

: radius (cr.radius) // la liste d’initialisation

// tout autres instructions

}

La principale différence entre la définition d'un constructeur et la définition d'autres fonctions

membres est qu'un constructeur peut avoir une liste d'initialisation après l'en-tête pour
initialiser les données membres. La liste d'initialisation est placée après l'en-tête et avant
le corps du constructeur et commence par deux-points.
Définition du Constructeur
Dans notre classe Circle, nous n'avons qu’une seule donnée membre à initialiser. Si nous
devons initialiser plus d’une donnée membre, l'initialisation de chaque donnée membre de
doit être séparée par une virgule des autres données membres. En général, la liste
d'initialisation a le format suivant :

: donnéeMembre(paramètre), … , donnéeMembre (paramètre)

Définition du Constructeur
On peut considérer chaque initialisation comme une instruction d'affectation qui affecte le paramètre
au donnée membre, tel que dataMember = parameter. Il n'y a pas de terminateur pour la liste
d'initialisation. La ligne suivante est le corps du constructeur. Le nom dataMember doit être le même
que celui défini dans la déclaration de la donnée membre, mais le nom de chaque paramètre est
déterminé par le programmeur.
Un autre point important est qu'une donnée membre constante d'un objet doit être initialisée lors de la
création de l'objet. On ne peut pas changer une constante entité après qu'elle a été déclarée, mais C++
nous permet de l'initialiser dans la section d'initialisation d'un constructeur.
Parfois, cependant, nous devons utiliser le corps du constructeur pour initialiser des données
membres complexes (via des affectations) qui ne peuvent pas être simplement initialisés dans la liste
d'initialisation. Le corps d'un constructeur peut également être utilisé pour un traitement
supplémentaire, comme la validation d'un paramètre, l'ouverture de fichiers si nécessaire ou même
l'impression d'un message pour vérifier que le constructeur a été appelé.
Destructeurs
Comme un constructeur, un destructeur a deux caractéristiques spéciales. Premièrement, le nom du
destructeur est le nom de la classe précédé d'un symbole tilde (~).

Deuxièmement, comme un constructeur, un destructeur ne peut pas avoir de valeur de retour

(pas même void) car il ne renvoie rien. Un destructeur est assuré d'être automatiquement
appelé et exécuté par le système lorsque l'objet instancié à partir de la classe sort de la portée.
En d'autres termes, si nous avons instancié cinq objets de la classe, le destructeur est
automatiquement appelé cinq fois pour garantir que tous les objets sont nettoyés. Une fois le
programme terminé, la mémoire allouée est recyclée. Un destructeur ne peut prendre aucun
argument, ce qui signifie qu'il ne peut pas être surchargé.

NB : Un destructeur est une fonction membre spéciale sans paramètre et est conçu pour
nettoyer et recycler un objet.
Déclaration du destructeur
Ce qui suit montre la déclaration du destructeur dans la définition de classe.

class Circle
{
...
public:
...
~Circle (); // le destructeur

}
Définition du destructeur
La définition d'un destructeur est similaire à la définition des trois autres fonctions membres,
mais il doit avoir un tilde (~) devant le prénom. Un destructeur doit être public comme
tous les constructeurs.

// Définition d’un destructeur

Circle :: ~Circle ()

// toute instruction nécessaire

}
Création et Destruction des Objets
L'appel d'un constructeur crée un objet. Lorsque le constructeur est exécuté, il initialise les
données membres. De même, lorsqu'un destructeur est exécuté, les données membres sont
nettoyées. Lorsque le programme est terminé, les emplacements de mémoire sont libérés.
La figure suivante montre la syntaxe pour appeler un constructeur de paramètre, un
constructeur par défaut et un constructeur de copie. Il n'y a pas de syntaxe pour appeler un
destructeur car il est appelé par le système.
Constructeur de Paramètre : Circle circle1 (5.1);
Constructeur par Défaut : Circle circle2; // pas de parenthèse
Constructeur de Copie: Circle circle3 (aCircle); // aCircle est un objet qui existe
Destructeur : il est appelé par le système.

Figure : Construction et destruction d'objets pour un type de classe