Langage c++

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Fonctions et classes amies en C++ - friend

L'un des concepts importants de la programmation orientée objet est la dissimulation de données, c'est-à-dire qu'une fonction non membre ne peut pas accéder aux données privées ou protégées d'un objet.

Mais parfois, cette restriction peut forcer le programmeur à écrire des codes longs et complexes. Heureusement, en c++, il existe un mécanisme de programmation pour accéder aux données privées ou protégées à partir de fonctions non membres.

Ceci est fait en utilisant une fonction amie ou/et une classe d'amie.

Fonction amie

Une fonction amie d'une classe est définie en dehors de la portée de cette classe, mais elle a le droit d'accéder à tous les membres privés et protégés de la classe. Même si les prototypes des fonctions d'amis apparaissent dans la définition de la classe, les amis ne sont pas des fonctions membres.

Pour déclarer une fonction en tant qu'une amie d'une classe, faites précéder le prototype de fonction dans la définition de la classe avec le mot-clé friend comme suit :

Syntaxe :
                                class nomClasse{
                                    ...
                                    friend type_retour nomFonction(liste des paramètres);
                                    ...
                                };
                            

Maintenant, vous pouvez définir la fonction amie comme une fonction normale pour accéder aux données de la classe. Aucun mot clé friend n'est utilisé dans la définition.

Syntaxe :
                                class nomClasse{
                                    ...
                                    friend type_retour nomFonction(liste des paramètres);
                                    ...
                                };

                                type_retour nomFonction(liste des paramètres){
                                    // Les données privées et protégées de nomClasse sont accessibles 
                                    // à partir de cette fonction car il s’agit d’une fonction amie de nomClasse.
                                }
                            
Exemple 1 :
                                #include <iostream >
                                using namespace std;
                                    
                                class Voiture
                                    {
                                    private:
                                        int Id;
                                        double Vitesse;
                                    
                                    public:
                                        Voiture();
                                        friend void rouler(Voiture, double);
                                };
                                // définition du constructeur
                                Voiture::Voiture()
                                {
                                    Id = 1;
                                    Vitesse = 240;
                                }
                                    
                                // fonction amie
                                void rouler(Voiture v, double vitesse)
                                {
                                    v.Vitesse += vitesse;
                                    cout << "la vitesse de v est " << v.Vitesse << endl;
                                }
                                    
                                int main()
                                {
                                    Voiture v1;
                                    rouler(v1, 24);
                                    return 0;
                                }
                            

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

la vitesse de v est 264

Bien que cet exemple vous donne une idée du concept de fonction amie, il ne montre aucune utilisation significative.

Une utilisation plus significative consiste à utiliser des objets de deux classes différentes. C'est à ce moment que la fonction amie peut être très utile.

Vous pouvez certainement utiliser deux objets de classes différentes sans utiliser la fonction amie, mais le programme sera long, complexe et difficile à comprendre.

Exemple 2 :

Le programme suivant déclare une fonction amie "addition" qui ajoute la valeur de deux classes A et B.

                                #include <iostream>
                                using namespace std;
                                    
                                class B; // déclaration de B
                                class A
                                {
                                    private:
                                        int nombre;
                                    
                                    public:
                                        A(int n) : nombre(n) {}
                                        friend void addition(A, B);
                                };
                                    
                                class B
                                {
                                    private:
                                        int val;
                                    
                                    public:
                                        B(int n) : val(n) {}
                                        friend void addition(A, B);
                                };
                                    
                                void addition(A a, B b)
                                {
                                    int res = a.nombre + b.val;
                                    cout << "le résultat est " << res << endl;
                                }
                                    
                                int main()
                                {
                                    A a(24);
                                    B b(10);
                                    addition(a, b);
                                    return 0;
                                }
                            

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

le résultat est 34

Pour que ce programme fonctionne correctement, une déclaration préalable d'une classe B doit être faite comme indiqué dans l'exemple ci-dessus.

En effet, la classe B est référencée dans la classe A dans l'instruction friend void addition(A, B);

Classe amie

De même, à l'instar d'une fonction amie, une classe peut également être transformée en amie d'une autre classe à l'aide du mot clé friend. Par exemple:

                                ...
                                class B;
                                class A{
                                    ...
                                    friend class B;
                                };
                                class B{
                                    ...
                                }
                                ...
                            

Lorsqu'une classe devient une classe amie, toutes les fonctions membres de cette classe deviennent des fonctions amies.

Dans le programme ci-dessus, toutes les fonctions membres de la classe B deviennent des fonctions amies de la classe A. Ainsi, toute fonction membre de la classe B peut accéder aux données privées et protégées de la classe A. Toutefois, les fonctions membres de la classe A ne peuvent pas accéder aux données de classe B.

Voici quelques points importants sur les fonctions et classes amies :

  •   Les amies ne devraient être utilisés qu’à des fins limitées. trop de fonctions ou de classes externes sont déclarées en tant que amies d'une classe avec des données protégées ou privées, ce qui diminue la valeur de l'encapsulation de classe
  •   L'amitié n'est pas réciproque. Si la classe A est une amie de B, alors B ne deviendra pas automatiquement une amie de A.
  •   L'amitié n'est pas héritée.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :