3 StaticConst

Membres statiques, constantes
Références, constructeur de recopie, affectation
Programmations Orientées Objet

Programmation en C++
Laila AMIR
IRISI & Licence SIR

Année universitaire 2013/2014
Laila AMIR Programmations Orientées Objet

Plan
1 Membres statiques, constantes

Membre donnée statique
Fonction membre statique
Membre donnée constant
Fonction membre constante
2 Références, constructeur de recopie, affectation

Passage des paramètres par référence
Passage des d’objets par référence
Le clonage d’objets : recopie et affectation
Le constructeur de recopie

Plan



Membres statiques, constantes Fonction membre statique
Références, constructeur de recopie, affectation Membre donnée constant
Plan



Le qualificatif static pour un membre donnée statique
Avec le qualificatif static devant un attribut d’une classe on peut

spécifier que cet attribut est commun à tous les objets de la
classe. Ce qu’on nomme un attribut (de classe).
Les membres données statiques sont des sortes de variables globales

dont la portée est limitée à la classe.
Un attribut sans le mot-clé static correspond à un attribut

(d’instance).

Exemple
class exp1{
class exp2{
int n;
static int n;
float x;
float x;
};
};
une déclaration telle que:exp1 a, b;
une déclaration telle que:exp2 a, b;
conduit à une situation que l’on
conduit à une situation que l’on
peut schématiser ainsi :
peut schématiser ainsi :
a et b possèdent ses propres

a et b partagent la donnée n
données n, x

Initialisation d’un membre donnée statique

Un membre donnée statique n’existe qu’en un seul exemplaire
indépendamment des objets (même si aucun objet n’a pas encore
été crée). Alors son initialisation ne peut plus être faite par le
constructeur de la classe.
On ne peut même pas initialiser un membre statique lors de sa
déclaration comme dans :
class exp2{
static int n = 2; //erreur
}
Un membre statique doit être initialisé (à l’extérieur de la déclaration
de la classe) par une instruction telle que : exp2::n = 2;
Cette initialisation est utilisable aussi bien pour les membres statiques
privés que publics

Méthode statique
L’orienté objet définit deux types de méthodes dans une classe :

les méthodes ”d’instance” : associées à une instance de la classe
les méthodes ”de classe” : non associables à une instance de la classe
mais associées à la classe toute entière
Le C++ permet ce genre de distinction avec le mot-clé static.
Ci-dessous, la fonction membre affichetout de la classe Point est statique

et la fonction membre affiche est normale.
class Point { ...
void affiche();
static void affichetout();
};

Membre constant
C++ offre la possibilité de définir des entités constantes (variables,

fonctions).
La valeur de ces entités ne peut alors plus être modifiée lors de
l’exécution du programme.
Puisqu’il sera impossible, une fois la constante déclarée, de modifier
sa valeur, il est indispensable de l’initialiser.
Donc l’expression const int A; produira un message d’erreur, alors
que const int A=5; sera accepté par le compilateur.
Ce concept de constante de variables s’étend aux classes, ce qui
signifie qu’on peut définir des objets constants.

Exemples d’utilisation
Des exemples typiques d’utilisation de cette fonctionnalité pour des

variables sont:
la représentation des bornes de boucles. C’est le cas de la variable
taille qui ne doit pas être modifiée une fois qu’elle est fixée ;
le passage de paramètres dans des fonctions qui ne sont pas sensées
modifier la valeur de ces paramètres. C’est le cas de la fonction
contient(paramètres) qui effectue une recherche et qui ne doit
pas modifier la valeur des paramètres qui lui sont fournis.
Toute tentative de modification du contenu d’une variable déclarée const
génère une erreur à la compilation : seules les opérations de lecture sont
autorisées.

Définition d’une fonction membre constante
Une fonction membre constante est une fonction déclarée (et définie)
avec le qualificatif const.
Exemple : void affiche () const.
Seules les fonctions membres constantes sont autorisées à opérer sur

des objets constants.

Propriétés d’une fonction membre constante
1) Elle est utilisable pour un objet déclaré constant
Avec les déclarations suivantes :

Exemple : point a;
class point{ const point b;
int x, y; les instructions suivantes sont correctes :
public : a.affiche();
point(...); b.affiche();
void affiche () const; a.deplace();
void deplace (...); l’instruction suivante est incorrecte : b est
} consant mais deplace() ne l’est pas.
b.deplace(); //erreur

Propriétés d’une fonction membre constante

2) Les instructions figurant dans sa définition ne doivent pas modifient
la valeur des données membres. Les membres statiques font exceptions de
cette règle.
Exemple :
class point{
float x, y;
static int n;
public :
point(...);
void affiche () const{
x++; //erreur
n++; //OK
};
}
Membres statiques, constantes Passage des d’objets par référence
Références, constructeur de recopie, affectation Le clonage d’objets : recopie et affectation
Plan



Passage des paramètres par valeur
Soit l’exemple suivant :

void f(int X) {
X=0;
};
main() {
int A=5;
f(A);
cout << ”A = ”<< A;
};
Résultat: A = 5
En effet, lorsque la variable A est passée à la fonction f, sa valeur est
recopiée dans la variable locale X. C’est la copie locale de X qui est
mise à zéro, elle sera détruite dès le retour de la fonction.

Passage des paramètres par adresse
Les programmeurs C ont l’habitude de palier à cet inconvénient du C en

passant l’adresse (pointeur) des paramètres d’une fonction au lieu de
passer la valeur. Ainsi, notre exemple sera écrit :
void f(int* X) {
*X=0;
};
main() {
int A=5;
f(&A);
cout << ”A = ”<< A;
};
Résultat: A = 0 Le résultat est correct mais il n’est utile de passer les
paramètres par pointeur que si le cas pointeur=NULL doit être envisagé :
il faudrait tester le pointeur : if (X == NULL) ... sinon ..

Cette manipulation de pointeurs est lourde à gérer pour le programmeur.

C++ palie à cet inconvénient en permettant le passage de paramètres par
référence ; le résultat est correct et la programmation devient plus légère,
parce que c’est lui qui minimise l’utilisation des signes tels que & ou *.
void f(int& X) {
X=0;
};
main() {
int A=5;
f(A);
cout << ”A = ”<< A;
};
Résultat: A = 0

En effet, la déclaration int& X dans le prototype de la fonction f

indique un passage des paramètres par référence. X est donc un
synonyme de la variable passée, et non plus une recopie. En
conséquence, la ligne X=0 dans f remet à 0 la variable A.
Passer un paramètre par référence revient donc à passer un paramètre

à la fonction, tout en laissant à celle-ci la possibilité de modifier
la valeur de la variable ainsi passée, donc d’en faire aussi une
valeur de retour.

Utilisation de références sur les objets
Les références sur les objets sont à considérer dans plusieurs cas :
Passage d’objets en paramètres;
Les fonctions ou méthodes qui renvoient des objets.

Passage d’objets par valeur
Considérons la fonction suivante :

void affichageObj(Point o)
{
o.affiche();
}
Examinons ce qui se passe lors de l’appel de cette fonction :
int main()
{
Point unObjet(...);
affichageObj(unObjet);
return 0;
}

Passage d’objets par valeur
Rappelons que dans le cas du passage de paramètre par valeur, il y a

recopie du paramètre sur la pile. Et cette opération peut s’avérer
particulièrement coûteuse.
Dans le cas d’un objet, cette recopie nécessite un appel à un

constructeur particulier, le constructeur de recopie que nous
allons étudier prochainement.
En outre, l’objet temporaire créé sur la pile devra être détruit à

la fin, ce qui implique un appel à un destructeur.

Passage d’objets par référence
Avec un appel par référence, il n’y a pas de recopie car l’on passe
l’adresse.
Au point de vue du code généré, passer un objet par référence ou un

pointeur sur cet objet revient exactement au même.
Les références sont une facilité apportée au programmeur afin de

limiter les erreurs.

Passage d’objets par référence
Avec un passage par référence, la fonction précédente et son appel

s’écrivent :
void affichageObj(Point &o)
{
o.affiche();
}
int main()
{
Point unObjet(...);
affichageObj(unObjet);
return 0;
}

Recopier un objet dans un autre est opération assez fréquente.
Deux fonctionnalités y sont dédiées en C++ :

le constructeur de recopie
l’opérateur d’affectation.

L’opérateur d’affectation
L’opérateur d’affectation et le constructeur de recopie sont très

proches dans le sens où ils sont requis dans les mêmes circonstances et
qu’ils effectuent la même opération : cloner un objet dans un autre.
Il y a tout de même une différence fondamentale :
L’opérateur d’affectation écrase le contenu d’un objet déjà existant et
donc totalement construit.
Syntaxe :
Le prototype de l’opérateur d’affectation d’une classe T est le suivant :
T & operator=(const T& o); (voir : surcharge d’opérateur)

Le constructeur de recopie est très important car il permet d’initialiser

un objet par clonage d’un autre.
En particulier, le constructeur par recopie est invoqué lors d’une:

transmission d’un objet par valeur en argument d’appel d’une fonction
transmission d’un objet par valeur en valeur de retour d’une fonction
Il est extrèmement important de passer l’objet recopié par référence.
Syntaxe :
La syntaxe du constructeur par recopie d’une classe T est la suivante :
T::T(const T& o); ou T::T(T& o);

Exemple :Initialisation ou affectation
Voici des exemples qui résument des cas d’initialisation (appel au

constructeur) et d’affectation (appel à l’opérateur) :
T t1; Initialisation par le constructeur par défaut T::T(void);

T t2(params); Initialisation par un constructeur défini T::T(liste params);
T t3(t1); Initialisation par le constructeur de recopie T::T(const T&);
T t4(); appel de la fonction t4 sans paramètre et de type de retour T.
T t5=t1; Initialisation par le constructeur de recopie T::T(const T&);
T t5(t1); Initialisation par le constructeur de recopie T::T(const T&);
t5=t2; Affectation par l’opérateur = T& T::operator=(const T&);

Le constructeur de recopie par défaut
Si vous ne fournissez pas explicitement de constructeur par

recopie, le compilateur en génère automatiquement. Celui-ci
effectue une recopie binaire optimisée de votre objet ... ce qui est
parfait si celui-ci ne contient que des éléments simples. En revanche,
si votre objet contient des pointeurs, ce sont les valeurs des pointeurs
qui vont être copiées et non pas les variables pointées, ce qui dans de
nombreux cas, conduira directement à des erreurs.
Vous devez fournir un constructeur de recopie dès lors que le clonage
d’un objet par recopie, en particulier dans la cas d’:
Utilisation de mémoire dynamique
Utilisation de ressources systèmes (fichiers, sockets, etc ...)

1)Exemple : Emploi du constructeur de recopie par défaut
class vecteur {
int nelem;
double * adr;
vecteur(int n);
˜vecteur(); main() {
}; vecteur a(5);
vecteur::vecteur(int n) { vecteur b(a);
adr = new double[nelem = n]; }
}
vecteur::˜vecteur() {
delete adr;
}

Explications : emploi du constructeur de recopie par défaut
La création de a : nelem vaut 5 et adr pointe sur un

tableau de double de longueur 5.
La création de b : nelem vaut 5 car recopié depuis

a, mais adr pointe aussi sur le tableau de double
créé lors de la création de a. Autrement dit, a.adr et
b.adr pointent tous les deux vers le même tableau.
Lors de la destruction de a, le destructeur détruit

le tableau pointé par adr et lors de la destruction
de b, même chose. Conclusion, le programme peut
se planter lors de la deuxième destruction.

2)Exemple : Emploi du constructeur de recopie
On ajoute à l’exemple précedent le constructeur de recopie suivant :
vecteur::vecteur(vecteur & v) {
nelem = v.nelem;
adr = new double[nelem];
for (int i = 0; i<nelem; i++)
adr[i] = v.adr[i];
cout << this << adr <<endl;
}

Explications : emploi du constructeur de recopie
Ici, Le programme exécute le corps du

constructeur par recopie ci-dessus.
Il met la valeur de a.nelem dans nelem,
c’est-a-dire 5, puis, au lieu de recopier a.adr
dans adr, il crée un nouveau tableau de
double de taille 5 et recopie un à un les cases
du tableau de double pointé par a.adr dans
les cases du nouveau tableau pointé par adr.
Ce qui fait que a.adr et b.adr pointent vers

des tableaux différents et aucun problème ne
pourra survenir lors de la destruction de a ou
de b.

3 StaticConst

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

3 StaticConst

Transféré par

Droits d'auteur :

Formats disponibles

Membres statiques, constantes

Références, constructeur de recopie, affectation

Programmations Orientées Objet

IRISI & Licence SIR

Laila AMIR Programmations Orientées Objet

1 Membres statiques, constantes

2 Références, constructeur de recopie, affectation

Laila AMIR Programmations Orientées Objet

1 Membres statiques, constantes

2 Références, constructeur de recopie, affectation

Laila AMIR Programmations Orientées Objet

1 Membres statiques, constantes

2 Références, constructeur de recopie, affectation

Laila AMIR Programmations Orientées Objet

Le qualificatif static pour un membre donnée statique

Avec le qualificatif static devant un attribut d’une classe on peut

Les membres données statiques sont des sortes de variables globales

Un attribut sans le mot-clé static correspond à un attribut

Laila AMIR Programmations Orientées Objet

a et b possèdent ses propres

Laila AMIR Programmations Orientées Objet

Initialisation d’un membre donnée statique

Laila AMIR Programmations Orientées Objet

L’orienté objet définit deux types de méthodes dans une classe :

Ci-dessous, la fonction membre affichetout de la classe Point est statique

Laila AMIR Programmations Orientées Objet

C++ offre la possibilité de définir des entités constantes (variables,

Laila AMIR Programmations Orientées Objet

Des exemples typiques d’utilisation de cette fonctionnalité pour des

Laila AMIR Programmations Orientées Objet

Définition d’une fonction membre constante

Seules les fonctions membres constantes sont autorisées à opérer sur

Laila AMIR Programmations Orientées Objet

Propriétés d’une fonction membre constante

1) Elle est utilisable pour un objet déclaré constant

Avec les déclarations suivantes :

Laila AMIR Programmations Orientées Objet

Propriétés d’une fonction membre constante

1 Membres statiques, constantes

2 Références, constructeur de recopie, affectation

Laila AMIR Programmations Orientées Objet

Passage des paramètres par valeur

Soit l’exemple suivant :

Laila AMIR Programmations Orientées Objet

Passage des paramètres par adresse

Les programmeurs C ont l’habitude de palier à cet inconvénient du C en

Laila AMIR Programmations Orientées Objet

Passage des paramètres par référence

Cette manipulation de pointeurs est lourde à gérer pour le programmeur.

Laila AMIR Programmations Orientées Objet

Passage des paramètres par référence

En effet, la déclaration int& X dans le prototype de la fonction f

Passer un paramètre par référence revient donc à passer un paramètre

Laila AMIR Programmations Orientées Objet

Utilisation de références sur les objets

Passage d’objets en paramètres;

Les fonctions ou méthodes qui renvoient des objets.

Laila AMIR Programmations Orientées Objet

Passage d’objets par valeur

Considérons la fonction suivante :

Laila AMIR Programmations Orientées Objet

Passage d’objets par valeur

Rappelons que dans le cas du passage de paramètre par valeur, il y a