Vous êtes sur la page 1sur 7

La Programmation Orientée Objet

(POO) en C++

AUTORÉFÉRENCE
Eléments Statiques
&
Focntion et classe amies
AUTORÉFÉRENCE : LE MOT CLÉ THIS

this est un pointeur sur l’objet courant. Celui-ci, utilisable uniquement


au sein d’une fonction membre, qui désigne un pointeur sur l’objet
l’ayant appelée.
Ainsi dans la classe Personne, si l’on veut avoir (afficher) l’adresse de
l’objet lui-même on ajoute :
cout << “Adresse de l’objet : ” << this->adresse << endl;
ELÉMENTS STATIQUES (MÉTHODES ET ATTRIBUTS)
On peut déclarer des objets, attributs ou méthodes static dans une classe.
Ces éléments seront alors communs à tous les objets de cette classe.
=>La particularité des méthodes statiques est qu’elles ne peuvent pas accéder
aux attributs de la classe.
class MaClasse
{ public:
MaClasse();
static void maMethode();
};
Pour les utiliser, il n'est pas nécessaire de créer un objet. Il suffit de faire
précéder le nom de la méthode du nom de la classe suivi d'un double deux-
points
MaClasse::maMethode();
Il existe aussi des attributs statiques, qui appartiennent à la classe et non aux objets
créés à partir de la classe. Ainsi, un attribut static aura la même valeur pour tous les
objets de cette classe. Si l'un des objets change cet attribut static, il sera modifié
pour tous les autres objets.
class MaClasse
{ public:
MaClasse();
private:
static int monAttribut;
};
=>L’utilisation la plus courante des attributs statiques est la création d'un compteur
d'instances. Parfois on a besoin de connaître le nombre d'objets d'une classe donnée
qui ont été créés. Pour se faire, on crée alors un attribut statique compteur privé que
l'on initialise à zéro. On incrémente ensuite ce compteur dans les constructeurs de la
classe et, bien sûr, on le décrémente dans le destructeur.
class Personne {
public:
Personne(string nom);
~Personne();
static int nombreInstances(); //Renvoie le nombre d'objets créés
private:
string m_nom;
static int compteur;
}
int Personne::compteur = 0; //On initialise notre compteur à 0
Personne::Personne(string nom) : m_nom(nom){
++compteur; //Quand on crée un personnage, on ajoute 1 au compteur
}
Personne::~Personne(){
--compteur; //Et on enlève 1 au compteur lors de la destruction
}
int Personne::nombreInstances(){
return compteur; //On renvoie simplement la valeur du compteur
}
cout <<" Il y a actuellement" <<Personne::nombreInstances()<<"personnes." << endl;
FONCTIONS ET CLASSES AMIES
Le principe d’encapsulation interdit à une fonction membre d’une classe d’accéder à des
données privées d’une autre classe.
=>Supposons par exemple que nous ayons défini une classe vecteur et une classe matrice. Il
est probable que nous souhaiterons alors définir une fonction permettant de calculer le
produit d’une matrice par un vecteur.
=>Or, avec ce qu’on connait actuellement de C++, on ne pourrait définir cette fonction ni
comme fonction membre de la classe vecteur, ni comme fonction membre de la classe
matrice, et encore moins comme fonction indépendante (membre d’aucune classe).
=>On peut toujours rendre publiques les données de nos deux classes, mais on perdrait
alors le bénéfice de leur protection.
=>La solution la plus adéquate est d’utiliser la notion de fonction amie qui propose un
compromis entre l’encapsulation formelle des données privées et des données publiques.
=>Lors de la définition d’une classe, il est possible de déclarer une ou plusieurs fonctions
(extérieures à la classe) «amies» ; une telle déclaration d’amitié les autorise alors à accéder
aux données privées, au même titre que n’importe quelle fonction membre.
Il existe plusieurs situations d’amitiés :
• fonction indépendante, amie d’une classe ;
• fonction membre d’une classe, amie d’une autre classe ;
• fonction amie de plusieurs classes ;
• toutes les fonctions membres d’une classe, amies d’une autre classe.
Class Departement
class Etudiant : public Personne {
...
friend int Fonction1 (parametre, ...); //fonction indépendante amie de la classe
friend void Departement::Fonction2 (parametre, ...); // fonction membre d’une
... // classe et amie d’une autre classe
}
=> On peut aussi déclarer une classe A amie d'une classe B : toute les méthodes de la
classe A auront accès aux membres privés de la classe B.
class B{ …
friend class A;

};