Programmation Orientée Objet [600902]

Programmation Orientée Objet
chap 5: Propriétés des objets et des
fonctions

Dr. Ikbal Chammakhi Msadaa

Classes: TA 1 -3
S2 2014/2015

Programmation Orientée Objet 1

PROPRIÉTÉS DES OBJETS Section 1
Programmation Orientée Objet 2

Les objets
•En C++, il existe deux façons de créer des objets , c’est à dire
d’instancier une classe :
–De façon statique
–De façon dynamique
•La création statique
–Rappelons que la création statique consiste à créer un
objet en lui affectant un nom de la même façon qu’avec
une variable .
Nom_Classe Nom_Objet ;
–Ainsi , l’objet est accessible grâce à son nom .
Programmation Orientée Objet 3

L’allocation dynamique en C++
•Rappel : en C, la gestion dynamique de la mémoire se fait
grâce aux fonctions malloc () et free()
–Exemple :
int *t = ( int*) malloc (5*sizeof (int));
free(t );
•En langage C++, l’allocation dynamique se fait grâce à
l’opérateur new et la désallocation grâce à l’opérateur
delete .
•En C++, on n’utilise donc ni malloc ni free. D’ailleurs il n’est
même plus nécessaire d’utiliser sizeof .
•Le principe d’utilisation est le même pour les tableaux les
opérateurs new et delete sont remplacés par new[] et
delete [].
–Exemple :
int *t = new int[5];
delete [] t;
Programmation Orientée Objet 4

Les objets
•La création dynamique
–Dans ce cas la création d’un objet ne se fait pas en lui
attribuant un nom pour la manipuler directement mais en le
repérant par un pointeur .
–La création d’un objet dynamique se fait de la manière
suivante :
1.Définition d’un pointeur vers une classe
2.Création dynamique de l’objet grâce à new qui renvoie
l’adresse de l’objet nouvellement créé .
3.Affectation de cette adresse au pointeur .
Nom_Classe *Nom_Pointeur ;
Nom_Pointeur = new Nom_Classe ;
Programmation Orientée Objet 5

Les objets
•La création dynamique
–Tout objet créé dynamiquement devra impérativement être
détruit à la fin de son utilisation grâce au mot clé delete .
delete Nom_Pointeur ;
–Accès aux données membres d’un objet :
•En statique :
Nom_Objet .Nom_Attribut
Nom_Objet .Nom_Methode (param1 , param2, …)

•En dynamique :
Nom_Pointeur ->Nom_Attribut
Nom_Pointeur ->Nom_Methode (param1, param2, …)

Programmation Orientée Objet 6

Le pointeur courant this
•Dans toutes les classes, on dispose d’un pointeur ayant pour
nom this qui pointe vers l’objet courant .
•this est une variable système passée en tant que paramètre
caché de chaque fonction membre .
•Ainsi lorsque l’on désire accéeder à une donnée membre
d’un objetdu même objet, il suffit de faire précéder le nom
de la donnée membre par this->.
•this étant un pointeur sur un objet, *this est l’objet lui-
même .
Programmation Orientée Objet 7

Le pointeur courant this
•Exemple :

•En réalité , lorsque l’on donne
des noms différents aux
paramètres des fonctions
membre , l’usage de this est
implicite . C’est à dire que l’on
n’est pas obligé de le mettre
devant chaque donnée .

Programmation Orientée Objet 8
•Dans le cas où la fonction
membre doit retourner un
pointeur vers l’objet dans lequel
elle se trouve , l’utilisation de
this devient indispensable .

LES FONCTIONS EN C++ :
SURCHARGE ET VALEURS PAR DEFAUT Section 2
Programmation Orientée Objet 9

Programmation Orientée Objet 10 Les fonctions: la surcharge des fonctions
 Un des apports les plus intéressants de C++ par rapport au C (en
plus du paradigme Objet) est la possibilité d'appeler plusieurs
fonctions par le même nom, du moment que celles -ci ont des
arguments différents : en type et/ou en nombre .
Ce principe est appelé surcharge de fonctions . Il permet de
donner le même nom à des fonctions comportant des
paramètres différents et simplifie donc l'écriture de fonctions
ayant des paramètres différents mais qui sont sémantiquement
similaires .
En effet, une fonction est déterminée par ce que l’on appelle sa
signature , c’est -à-dire:
Son nom
Ses paramètres
Il est ainsi possible de définir une fonction réalisant la même
opération sur des variables différentes en nombre et/ou en
type.
L

Programmation Orientée Objet 11 Les fonctions: la surcharge des fonctions
Exemple :

Exercice :
Écrire un programme qui contient deux fonctions portant le nom surface :
•La 1ère calcule la surface d'un rectangle à partir de la valeur de la longueur
et de la largeur
•La 2ème calcule la surface d'un cercle à partir du rayon L

Les fonctions: valeur par défaut des arguments
Pour simplifier les appels de
fonctions comportant un
paramètre qui varie peu, le
C++ permet de déclarer des
fonctions avec des
paramètres qui ont des
valeurs par défaut .
La valeur par défaut d'un
paramètre est la valeur que
ce paramètre prend si
aucune valeur ne lui est
attribuée .
a = 2
b = 4
c = 0 Programmation Orientée Objet 12

Programmation Orientée Objet 13 Les fonctions: valeur par défaut des arguments
 L'appel de la fonction test(8) est valide. Comme on ne
précise pas le dernier paramètre, j est initialisé à 2. Le
résultat obtenu est donc 4.
De même, l'appel de test() est valide. Dans ce cas i vaut
0 et j vaut 2.
Toutefois, il est impossible d'appeler la fonction test en
ne précisant que la valeur de j.
Les valeurs par défaut doivent être les derniers de la
liste, c'est à dire ceux le plus à droite. Ainsi,
l'expression suivante est invalide:
int test (int i=0, int j) {…}
L

CONSTRUCTEURS ET DESTRUCTEURS :
TYPES ET PROPRIETES Section 3
Programmation Orientée Objet 14

Programmation Orientée Objet 15 Surcharge des constructeurs
•Comme n’importe quelle fonction ou fonction membre, il est
possible de surcharger les constructeurs , c’est -à-dire de
définir plusieurs constructeurs ayant le même nom mais
avec des arguments différents en nombre et/ou en type.
•Ainsi, il sera possible d’initialiser différemment un même
objet selon la méthode de construction utilisée .
•Imaginons par exemple que l’on veuille définir le sexe d’une
personne grâce à un entier valant 0 ou 1 et avoir également
la possibilité de passer en paramètre la lettre ‘M’ ou ‘F’ pour
désigner le sexe.
•On peut alors définir deux constructeurs pour lesquels le
3ème argument correspondant au sexe sera différent.

Surcharge des constructeurs
Programmation Orientée Objet 16

Programmation Orientée Objet 17 Types de constructeurs
–Il existe 3 types de constructeurs :
•Constructeur par défaut
•Constructeur paramétrique
•Constructeur par recopie
–Constructeur par défaut : Le constructeur par défaut ne possède aucun
argument . Il initialise un objet et ses attributs avec des valeurs par défaut .

–Utilisation : point B;
–L’utilisation de B.affiche (); affichera 0,0 sur l’écran. L’utilisation de
B.deplace (5,3) permettra à l’utilisateur de la classe d’initialiser le point
aux coordonnées souhaitées.

Programmation Orientée Objet 18 Types de constructeurs
–Constructeur paramétrique

–Utilisation : point A(3,8); point B(3);
–Les paramètres passés en argument sont copiés dans
les attributs correspondants de l’objet.

Programmation Orientée Objet 19 Types de constructeurs
–Un constructeur de recopie : est un constructeur qui initialise
un objet d’une certaine classe avec un autre objet de la même
classe .
•Exemples :
–point a( 3 , 8) ;
–point b(a) ; // utilisation du constructeur de recopie
–a.affiche() ; b.affiche() ;
•Le constructeur de copie est nécessaire pour:
1. La transmission par valeur d’un objet en argument d’une fonction :
void fct(point a);
2. Le retour par valeur d’un objet comme résultat d’une méthode ou
fonction: point fct(int h);
3. L’initialisation d’un objet à partir des caractéristiques d’un autre
objet.

Programmation Orientée Objet 20 Types de constructeurs
–Que se passe -t-il lorsqu’on a recours à une initialisation par
recopie?
Dans toute situation, il y a un appel d’un constructeur de recopie, mais il
faut distinguer deux cas principaux :
•1er cas: Il n’existe pas de constructeur approprié : Il y alors appel d’un
constructeur de recopie par défaut, généré automatiquement par le
compilateur . Ce constructeur se contente d’effectuer une copie de
chacun des membres .
•2ème cas: Il existe un constructeur approprié : on peut fournir
explicitement dans la classe en question un constructeur de recopie . Il
doit alors s’agir d’un constructeur public disposant d’un seul argument
du type de la classe et transmis obligatoirement par référence . Cela
signifie que son en-tête doit être obligatoirement de l’une de ces deux
formes (si la classe concernée se nomme Point) :
Point (Point &) Point (const Point &)
Le « const » indique simplement que l’on a pas le droit de modifier les
valeurs de l’objet à copier (c’est logique puisqu’on a juste besoin de lire les
valeurs de cet objet pour pouvoir les copier) .
•Application : Exercice 2 du TD N°2

Opérateur d’affectation
•L’opérateur d’affectation = joue un rôle particulier,
semblable à celui du constructeur de recopie,
puisqu’il permet d’initialiser un nouvel objet à partir
d’un objet déjà initialisé :
•point c(3,5), z;
•z = c;
•Attention : Ne pas confondre recopie et affectation
L’opérateur d’affectation = sert pour l’affectation
dans une expression. Le constructeur de recopie
sert à l’initialisation et pour le passage de
paramètres . Il construit l’objet. retourne un objet
par valeur ou par référence.
Programmation Orientée Objet 21

Programmation Orientée Objet 22 Constructeur avec valeurs par défaut
•Plutôt que de définir trois constructeurs comme dans
l’exemple précédent (surcharge – p 13), on peut utiliser des
valeurs par défaut dans les arguments :

•Ainsi, les trois manières de créer un objet point restent
possibles:
–point C(-2,8); => -2,8
–point B(4); => 4,0
–point A; => 0,0

Programmation Orientée Objet 23 Constructeur avec valeurs par défaut

•Notez bien :
les valeurs par défaut sont spécifiées uniquement dans le
prototype , pas dans la définition de la fonction !
•Si le code est découpé en plusieurs fichiers, alors il ne faut
spécifier les valeurs par défaut que dans le fichier d'en –
tête .h.
Si vous vous trompez, le compilateur vous indiquera une
erreur à la ligne de la définition de la fonction.

Programmation Orientée Objet 24 Destructeur
•Comme nous l’avons déjà vu, un destructeur est
une méthode appelée lorsque l’objet est supprimé
de la mémoire. Son principal rôle est de désallouer
la mémoire.
• Dans le cas d’une création statique de l’objet, le
destructeur est inutile . Par contre, on en a besoin
pour désallouer (via delete ) la mémoire allouée
dynamiquement (via new ) suite à une création
dynamique d’objets.
•Exemple 1:
–Déclaration: ~Point();
–Implémentation: Point::~Point() { delete this; }

Destructeur
Exemple 2: class Vect

Création d’une classe qui
gère un vecteur de
nombres réels dont la
taille est fixée par un
argument transmis au
constructeur .
Programmation Orientée Objet 25

FONCTIONS CONSTANTES ,
ACESSEURS ET MUTATEURS Section 4
Programmation Orientée Objet 26

Les accesseurs ( getters ) et les
mutateurs ( setters )
•Rappelons que les données membres portant
l’étiquette « private » ne peuvent pas être manipulées
en dehors des fonctions membres de la même classe.
•Ainsi, pour pouvoir manipuler ces données membres,
on doit prévoir lors de la création de la classe des
fonctions membres spéciales portant l’étiquette
« public ».
•Les fonctions membres permettant d’ accéder aux
données membres sont appelées des accesseurs ou
getters .
•Les fonctions membres permettant de modifier les
valeurs des attributs membres sont appelées mutateurs
ou setters .
Programmation Orientée Objet 27

Les accesseurs ( getters ) et les
mutateurs ( setters )
•Un accesseur doit avoir comme type de retour le
type de la variable à renvoyer (celle à laquelle on
veut accéder)
•Une convention de nommage veut que l’on
commence le nom d’un accesseur par le préfixe get
–Exemple:
Programmation Orientée Objet 28

Les accesseurs ( getters ) et les
mutateurs ( setters )
•Un mutateur doit avoir comme paramètre la valeur à
assigner à la donnée membre et ne doit pas nécessairement
renvoyer de valeur (il possède dans sa simple expression le
type void ).
•Une convention de nommage veut que l’on commence le
nom d’un mutateur par le préfixe set
–Exemple:
Programmation Orientée Objet 29

Les méthodes constantes
•Les méthodes constantes sont des méthodes de « lecture seule ».
Elles possèdent le mot-clé « const » à la fin de leur prototype et
de leur déclaration .
•En déclarant une méthode constante, on indique au compilateur
que la méthode en question ne modifie pas l’objet , c’est -à-dire
qu’elle ne modifie la valeur d’aucun de ses attributs .
•Déclaration : void maMethode (int) const ; // dans .h
•Implémentation :
void MaClasse ::maMethode (int parametre ) const //dans . cpp
{
…
}
•Exemple:

•jk
Programmation Orientée Objet 30

Les méthodes constantes
•Les méthodes constantes servent principalement à 3
choses :
–Pour vous : vous savez que votre méthode ne fait que lire les
attributs et vous vous interdisez dès le début de les modifier.
Si par erreur vous tentez d'en modifier un, le compilateur
plante en vous reprochant de ne pas respecter la règle que
vous vous êtes fixée .
–Pour les utilisateurs de votre classe : cela leur indique que la
méthode se contente de renvoyer un résultat et qu'elle ne
modifie pas l'objet. Dans une documentation, le mot –
clé const apparaît dans le prototype de la méthode et c'est un
indicateur de ce qu'elle fait, ou plutôt de ce qu'elle ne peut pas
faire (cela pourrait se traduire par : « cette méthode ne
modifiera pas votre objet »).
–Pour le compilateur : il est toujours recommandé de toujours
déclarer const ce qui peut l'être. Ici c’est pareil. Ainsi, on offre
des garanties aux utilisateurs de la classe et on aide le
compilateur à générer du code binaire de meilleure qualité.
Programmation Orientée Objet 31