Les fonctions amies
Introduction
La P.O.O. pure impose l’encapsulation des données : les membres privés (données ou
fonctions) ne sont accessibles qu’aux fonctions membres (publiques ou privées) et seuls les
membres publics sont accessibles « de l’extérieur ».
L’unité de protection est la classe, c’est-à- dire qu’une même fonction membre peut accéder
à tous les objets de sa classe. En revanche, ce même principe d’encapsulation interdit à une
fonction membre d’une classe d’accéder à des données privées d’une autre classe. Or cette
contrainte s’avère gênante dans certaines circonstances. (Exemple classe vecteur et
classe matrice). Grâce aux fonctions amies, on pourra accéder aux membres privés d’une
classe, autrement que par le biais de ses fonctions membres.
[Link] UCA/FPS/MIPS4/CPP 1
Les fonctions amies
Les fonctions amies proposent une solution intéressante, sous la forme d’un compromis entre
encapsulation formelle des données privées et des données publiques. Lors de la définition
d’une classe, il est en effet possible de déclarer qu’une ou plusieurs fonctions (extérieures à
la classe) sont des « 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.
L’avantage de cette méthode est de permettre le contrôle des accès au niveau de la classe
concernée : on ne peut pas s’imposer comme fonction amie d’une classe si cela n’a pas été
prévu dans la classe.
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.
2
[Link] UCA/FPS/MIPS4/CPP
Les fonctions amies
Fonction indépendante amie d’une classe
#include <iostream>
using namespace std;
class point{
int x, y ;
public :
point (int abs=0, int ord=0){
x=abs ; y=ord ;
}
friend int coincide (point, point) ;
} ;
int coincide (point p, point q) {// définition de coincide
if ((p.x == q.x) && (p.y == q.y)) return 1 ;
else return 0 ;
}
int main() {
point a(1,0), b(1), c ;
if (coincide (a,b)) cout << "a coincide avec b \n" ;
else cout << "a et b sont differents \n" ;
if (coincide (a,c)) cout << "a coincide avec c \n" ;
else cout << "a et c sont differents \n" ;
}
3
[Link] UCA/FPS/MIPS4/CPP
Remarques
• L’emplacement de la déclaration d’amitié au sein de la classe point est absolument
indifférent.
• Il n’est pas nécessaire de déclarer la fonction amie dans la fonction ou dans le fichier
source où on l’utilise, car elle est déjà obligatoirement déclarée dans la classe concernée.
• Ici, les deux arguments de coincide sont transmis par valeur. Ils pourraient l’être par
référence ; notez que, dans le cas d’une fonction membre, l’objet appelant la fonction est
d’office transmis par référence (sous la forme de this).
• Généralement, une fonction amie d’une classe possédera un ou plusieurs arguments ou
une valeur de retour du type de cette classe (c’est ce qui justifiera son besoin d’accès aux
membres privés des objets correspondants). Ce n’est toutefois pas une obligation :
[Link] UCA/FPS/MIPS4/CPP 4
Les différentes situations d’amitié
Fonction membre d’une classe, amie d’une autre classe
class A class B
{ {
private: //…
//... int f (char, A) ;
public: //….
friend int B::f (char, A) ; } ; } ;
//...
};
int B::f (char , A)
{
// on a accès ici aux membres privés
// de tout objet de type A
}
Fonction (f ) d’une classe (B), amie d’une autre classe (A)
[Link] UCA/FPS/MIPS4/CPP 5
Les différentes situations d’amitié
Fonction amie de plusieurs classes
class A{ class B{
private: private:
//..... //.....
public: public:
//..... //.....
friend void f(A,B) ; friend void f(A,B) ;
}; //...
};
void f(A, B){
// on a accès ici aux membres privés
// de n’importe quel objet de type A ou B}
Fonction indépendante (f) amie de deux classes (A et B)
[Link] UCA/FPS/MIPS4/CPP 6
Les différentes situations d’amitié
Toutes les fonctions d’une classe amies d’une autre classe
Pour dire que toutes les fonctions membres de la classe B sont amies de la classe A, on placera,
dans la classe A, la déclaration :
friend class B ;
Exemple :
Le produit d’un vecteur (objet de classe vect) par une matrice (objet de classe matrice).
Les fonctions membres:
• un constructeur pour vect et pour matrice ;
• une fonction d’affichage (affiche) pour matrice.
• prod est indépendante et amie des deux classes vect et matrice ;
• prod est membre de matrice et amie de la classe vect.
[Link] UCA/FPS/MIPS4/CPP 7
Fonction amie, membre d’une classe
#include<iostream>
using namespace std;
class matrice ;
// *********** La classe vect *******************
class vect {
double v[3] ; // vecteur à 3 composantes
public :
vect (double v1=0, double v2=0, double v3=0){ // constructeur
v[0] = v1 ; v[1]=v2 ; v[2]=v3 ;
}
friend vect prod (matrice, vect) ; // prod = fonction amie indépendante
void affiche (){
int i ; for (i=0 ; i<3 ; i++) cout << v[i] << " " ;cout<< endl;
}
} ;
#include<iostream>
using namespace std;
class matrice {
double mat[3] [3] ; // matrice 3 X 3
public :
matrice (double t[3][3]){ // constructeur, à partir d’un tableau 3 x 3
int i ; int j ;
for (i=0 ; i<3 ; i++)
for (j=0 ; j<3 ; j++)
mat[i] [j] = t[i] [j] ;
}
friend vect prod (matrice, vect) ; // prod = fonction amie indépendante
} ;
[Link] UCA/FPS/MIPS4/CPP 8
Fonction amie, membre d’une classe
vect prod (matrice m, vect x){
int i, j ; double som ;
vect res ; // pour le résultat du produit
for (i=0 ; i<3 ; i++){
for (j=0, som=0 ; j<3 ; j++)
som += [Link][i] [j] * x.v[j];
res.v[i] = som ;
}
return res ;
}
int main(){
vect w (1,2,3) ; vect res ;
double tb [3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
matrice a = tb ;
res = prod(a, w) ;
[Link] () ;
}
[Link] UCA/FPS/MIPS4/CPP 9