Université Sid Mohammed Ben Abdellah

Ecole Nationale des Sciences Appliquées

Fès

Programmation Orientée Objet

C++

Pr. Nabil EL AKKAD

A. U: 2023/2024
Fonctions et classes
amies

2
 Notions de fonction amie : friend

La POO impose

Exemple:
• On définit une classe Vector et une classe Matrix.
• Produit matrice-vecteur nécessite l’accès aux données privées des 2 classes
3
 Notions de fonction amie : friend (2)

• Solutions
Soit:

– Déclarer les données dans la partie public;

– Utiliser des méthodes publiques pour accéder aux données

privées;

– Utiliser des fonctions amies dans ses classes.

4
 Notions de fonction amie : friend (3)
• Solutions:
– Déclarer les données dans la partie public;
– Perte du bénéfice de l’encapsulation (protection des données).
– Utiliser des méthodes publiques pour accéder aux données privées;
– Oui, mais pas toujours optimal pour protéger les données d’un objet.
– Utiliser des fonctions amies dans ses classes.

• Fonction amie :
• Fonction extérieure à la classe ayant accès aux données privées de la classes;
• Contraire à la P.O.O. mais utile dans certains cas.

5
 Notions de fonction amie : friend (4)
• Il existe plusieurs situations d’amitié:
– Fonction indépendante (ordinaire) amie d’une classe;
– Fonction membre d’une classe et amie d’une autre classe;
– Fonction amie de plusieurs classes;
– Toutes les fonctions membre d’une classe, amies d’une autre classe.

• Syntaxe
friend typeRetour NomFonction (arguments) ;
// A déclarer dans la classe amie

6
 Fonctions et classes amies
• Une fonction ordinaire peut être déclarée amie d ’une classe.
– A accès à tous les membres privés de cette classe.
• Une fonction membre d’une classe A peut être déclarée amie d’une classe B;
– Cette fonction a accès à tous les membres privés de cette classe B.
• Une classe A toute entière peut être déclarée amie d’une classe B.
– Toutes les fonctions membres de la classe A ont accès à tous les membres
privés de la classe B.

La notion d ’amitié casse l’encapsulation des membres privés.

7
 Fonctions et classes amies (2)
Fonction indépendante amie d’une classe

class Point{ point.h

int x, y ;
public :
Point (int abs=0, int ord=0) { x=abs ; y=ord ; } // un constructeur
// déclaration fonction amie (indépendante) nommée egal
friend bool egal(Point, Point) ;
};

// programme d'essai point.cpp

#include « point.h »
main() {
Point a(1,0), b(1), c ; bool egal(Point p, Point q) // absence de point::
if (egal(a,b)) cout << "a et b sont égaux\n" ; { return ((p.x == q.x) && (p.y == q.y)) ;
else cout << "a et b sont differents \n" ; }
if (egal(a,c)) cout << " a et c sont égaux\n " ; ….
else cout << "a et c sont differents \n" ;
} 8
 Fonctions et classes amies (3)
Fonction indépendante amie d’une classe (suite)
Remarques:
• Les arguments de la fonction egal() sont transmis par valeurs, on pourrait les
transmettre par référence.

• L’emplacement de la déclaration d’amitié à l’intérieur de la classe n’a pas

d’importance.

• On ne peut pas utiliser l’argument implicite (this) dans une fonction amie, car
elle n’appartient pas à la classe;

• En général, une fonction amie possède 1 ou plusieurs arguments et/ou une

valeur de retour du type de la classe ( qui justifie la déclaration d’amitié);

• Il n'est pas nécessaire de déclarer la fonction amie dans le fichier source (main)
où on l'utilise;

– Car elle est déjà obligatoirement déclarée dans la classe concernée.

9
 Fonctions et classes amies (4)
Exercice d’application
Soit la classe point suivante :
class point
{ int x, y ;
public :
point (int x1=0, int y1=0) { x = x1; y = y1; }
};
Écrire une fonction indépendante affiche, amie de la classe point, permettant
d’afficher les coordonnées d’un point.
On fournira séparément :
– Un fichier source contenant la nouvelle déclaration (définition) de point ;
– Et un fichier source contenant la définition de la fonction affiche.
Écrire un programme (main) qui crée un point de classe automatique et un point
de classe dynamique et qui en affiche les coordonnées.

10
 Fonctions et classes amies (5)
Solution: Exercice d’application

/* fichier Point.h */
class Point
{ int x, y ;
public : #include « Point.h"
friend void affiche (const Point &) ; main() {
//const protège les valeurs du point reçu point a(1,5) ; //statique
Point (int abs=0, int ord=0) { affiche (a) ;
x=abs ; y=ord ; point * adp ;
} adp = new point (2, 12) ; //dynamique
}; affiche (*adp) ; // attention *adp et non adp
}
Point.cpp
#include « Point.h » // nécessaire pour compiler affiche
#include <iostream>
using namespace std ;

void affiche (const Point & p) //absence de Point::

{ cout << "Coordonnées : " << p.x << " " << p.y << endl; 11
}
 Fonctions et classes amies (6)
Fonction membre d’une classe et amie d’une autre classe

• Cas particulier de la situation précédente;

• Indiquer dans la déclaration d’amitié à quelle classe elle appartient
• Utilise l’opérateur de résolution de portée ::
• La fonction amie f () doit pouvoir accéder aux membres privés de A, elle
sera déclarée amie au sein de la classe A.

12
 Fonctions et classes amies (7)
Fonction membre d’une classe et amie d’une autre classe (suite )

friend int B::f (char, A);

Le compilateur a besoin de connaître les

caractéristiques de la classe B pour compiler celle de A.

int f (char, A);

Le compilateur a besoin de savoir que la classe A

existe, mais sans connaître ses caractéristiques.
• On fournira l'information voulue au compilateur
en faisant précéder la déclaration de A de :
class A ;
13
 Fonctions et classes amies (8)
Fonction membre d’une classe et amie d’une autre classe (suite)

Code correcte:
class A ;
class B
{ .....
int f(char, A) ;
.....
} ;

class A
{ .....
friend int B::f(char, A) ;
.....
} ;

int B::f(char..., A...)

{ .....
} 14
 Fonctions et classes amies (9)
Fonction amie de plusieurs classes

class B;
class A{
int x,y;
class B{
public: double r;
friend void f(A, B) ; ..... .....
..... ..... // partie publique
} ; friend void f(A, B) ;
..... .....
} ;

void f(A a, B b){

// on a accès ici aux membres privés a.x ou a.y
// de n’importe quel objet de type A ou B : b.r
}

15
 Fonctions et classes amies (10)

Toutes les fonctions d'une classe amies d'une autre classe

• C’est la généralisation de la notion de fonctions amies;

• On pourrait déclarer toutes les fonctions d’une classe B comme amies
d’une classe A, mais il est plus simple de le faire de manière globale dans
la class A :
Class A{...
friend class B;
...
}

16
 Fonctions et classes amies (11)
Exercice d’application
Créer deux classes (dont les membres , données, sont privés) :
• L’une, nommée Vecteur, permettant de représenter des vecteurs à 3 composantes de
type double ; elle comportera un constructeur et une fonction membre d’affichage ;
• L’autre, nommée Matrice, permettant de représenter des matrices carrées de
dimension 3 x 3 ; elle comportera un constructeur avec un argument (adresse d’un
tableau de 3 x 3 valeurs) qui initialisera la matrice avec les valeurs correspondantes.
Réaliser une fonction indépendante prod permettant de fournir le vecteur
correspondant au produit d’une matrice par un vecteur. Écrire un programme de test.
On fournira séparément les deux déclarations de chacune des classes, leurs définitions,
la définition de prod et le programme de test.

17
 Fonctions et classes amies (12)
Solution
// *********** La classe Matrice.h *****************
class Vecteur; // pour pouvoir compiler la déclaration de matrice
class Matrice{
double mat[3] [3] ; // matrice 3 X 3
public :
Matrice (double t[3][3]) ;// constructeur, à partir d'un tableau 3 x 3
friend Vecteur prod (Matrice, Vecteur) ; // prod = fonction amie indépendante
};
// ***La définition prod nécessite l’inclusion de Vecteur.h et de Matrice.h*****
#include " Vecteur.h"
#include "Matrice.h"
Vecteur prod (Matrice m, Vecteur x) {
double som ; Matrice (double t[3][3]) // constructeur, à
Vecteur res ;// pour le résultat du produit //partir d'un tableau 3 x 3
for (int i=0 ; i<3 ; i++) {
{ for (int j=0, som=0 ; j<3 ; j++) for (int i=0 ; i<3 ; i++)
som += m.mat[i] [j] * x.v[j] ; for (int j=0 ; j<3 ; j++)
res.v[i] = som ; mat[i] [j] = t[i] [j] ;
} }
return res ; } 18
 Fonctions et classes amies
Solution (suite)
#include <iostream>
using namespace std ;
class Matrice ; // pour pouvoir compiler la déclaration de Vecteur
// *********** La classe vect *******************
class Vecteur{
double v[3] ; // vecteur à 3 composantes
public :
Vecteur (double v1=0, double v2=0, double v3=0) // constructeur
{ v[0] = v1 ; v[1]=v2 ; v[2]=v3 ;
}

friend Vecteur prod (Matrice, Vecteur) ; // prod = fonction amie indépendante

void affiche (){

int i ;
for (i=0 ; i<3 ; i++) cout << v[i] << " " ;
cout << "\n" ;
}
}; 19
 Fonctions et classes amies
Solution (suite): la classe de test
#include " Vecteur.h"
#include " Matrice.h"
main() { //main.cpp
Vecteur w (1,2,3) ;
Vecteur res ;
double tb [3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
Matrice a = tb ;
res = prod(a, w) ;
res.affiche () ;
}

20