C++ fonctions ami et les classes ami

Dans cet article, vous apprendrez à utiliser les ++créer des fonctions ami et des classes ami dans le langage C++ et les utiliser efficacement dans le programme.

OOPl'un des concepts importants est la dissimulation des données, c'est-à-direfonction non membrene peut pas accéder aux données privées ou protégées de l'objet.

Cependant, parfois, cette restriction peut obliger les programmeurs à écrire du code long et complexe. Par conséquent, C ++Le langage de programmation a intégré un mécanisme permettant d'accéder aux données privées ou protégées à partir de fonctions non membres.

C'est ce qui est réalisé en utilisant les fonctions ami et les classes ami.

C ++la fonction ami

Si vous définissez la fonction en tant que fonction ami, vous pouvez utiliserfonctionaccéder aux données privées et protégées de la classe.

En utilisant le mot-cléfriend，le compilateur sait que la fonction donnée est une fonction ami.

Pour accéder aux données, vous devez déclarer la fonction ami en interne de la classe en utilisant le mot-clé friend (elle peut être n'importe où dans la classe, que ce soit dans la partie private ou public).

C ++déclaration de la fonction ami

class class_name
{
　　　　...　..　...
　　　　friend return_type function_name(argument)/s);
　　　　...　..　...
}

Maintenant, vous pouvez définir une fonction ami en tant que fonction ordinaire accédant aux données de la classe. La définition friend ne utilise aucun mot-clé.

class className
{
　　　　...　..　...
　　　　friend return_type functionName(argument)/s);
　　　　...　..　...
}
return_type functionName(argument/s)
{
　　　　...　..　...
　　　　//　On peut accéder aux données privées et protégées de className à partir de cette position
　　　　　//Car cette fonction est une fonction amie de className.
　　　　...　..　...
}

示例1：Fonctionnement des fonctions amies

/*　C　++Ce programme montre le fonctionnement des fonctions amies.*/
#include <iostream>
using namespace std;
class Distance
{
　　　　private:
　　　　　　　　int meter;
　　　　public:
　　　　　　　　Distance(): meter(0) { }
　　　　　　　　//Fonction amie
　　　　　　　　friend int addFive(Distance);
};
//　Définition de la fonction amie
int addFive(Distance d)
{
　　　　//Accès aux données privées à partir de la fonction non membre
　　　　d.meter　+=　5;
　　　　return d.meter;
}
int main()
{
　　　　Distance D;
　　　　cout << "Distance: \t" << addFive(D);
　　　　return 0;
}

Résultat de la sortie

Distance:　5

Ici, la fonction amie addFive() est déclarée dans la classe Distance. Par conséquent, on peut accéder aux données privées à partir de cette fonction.

Bien que cet exemple vous ait donné une idée du concept de fonction amie, il n'a pas montré une utilisation significative.

Lorsque vous devez manipuler des objets de classes différentes, il y a une utilisation plus significative. À ce moment-là, la fonction amie sera très utile.

Vous pouvez parfaitement manipuler des objets de classes différentes sans utiliser de fonction amie, mais ce programme serait très long, complexe et difficile à comprendre.

示例2：Ajout de membres de classes différentes en utilisant une fonction amie

#include <iostream>
using namespace std;
//　Pré-déclaration
class B;
class A {
　　　　private:
　　　　　　int numA;
　　　　public:
　　　　　　A(): numA(12) { }
　　　　　　//Déclaration de fonction amie
　　　　　　friend int add(A, B);
};
class B {
　　　　private:
　　　　　　　int numB;
　　　　public:
　　　　　　　B(): numB(1) { }
　　　　　　　//　Déclaration de fonction amie
　　　　　　　friend int add(A, B);
};
//La fonction add() est une fonction amie des classes A et B
//Accès aux variables membres numA et numB
int add(A objectA, B objectB)
{
　　　return (objectA.numA　+　objectB.numB);
}
int main()
{
　　　　A objectA;
　　　　B objectB;
　　　　cout << "Somme: \t" << add(objectA, objectB);
　　　　return 0;
}

Résultat de la sortie

Somme:　13

Dans ce programme, les classes A et B ont déclaré add() comme fonction amie. Par conséquent, cette fonction peut accéder aux données privées de ces deux classes.

Ici, la fonction add() ajoute les données privées numA et numB de deux objets objectS et object et les renvoie à la fonction main.

为了使这个程序正常工作，应该像上面的实例中所示的那样，对一个类B进行前置声明。

这是因为使用以下代码在class A中引用了class B的友元函数：friend int add（A，B）;

C ++编程中的友元类(friend class)

类似地，像一个友元函数一样，一个类也可以使用关键字friend成为另一个类的友元类。例如：

...　..　...
class B;
class A
{
　　　//　class B 是 class A的友元类
　　　friend class B;
　　　...　..　...
}
class B
{
　　　...　..　...
}

当一个类成为另一个类的friend类（友元类）时，这就意味着这个类的所有成员函数都是另一个类的友元函数。

在这个程序中，B类的所有成员函数都是A类的朋友函数，因此B类的任何成员函数都可以访问A类的私有和受保护的数据，但是A类的成员函数不能访问B类的数据。

C ++编程中如何互为友元类

如何实现classA与B互为友元，即A可以访问B的私有，B也可以访问A的私有呢？案例如下：

#include <iostream>
using namespace std;
//必须提前声明class B不然编译会报错
class B;
class A {
private:
　　　　int a;
public:
　　　　friend class B;
　　　　A() {
　　　　　　　　cout << " 类A被构造" << endl;
　　　　　　　　a =;　20;
　　　　}
　　　　~A() {
　　　　　　　　cout << " 类A被析构" << endl;
　　　　}
　　　　void show(B &b);
};
class B {
private:
　　　　int b;
public:
　　　　friend class A;
　　　　B() {
　　　　　　　　cout << " 类B的构造" << endl;
　　　　　　　　b =;　12;
　　　　}
　　　　~B() {
　　　　　　　　cout << " 类B被析构" << endl;
　　　　}
　　　　void show(A &a) {
　　　　　　　　cout << " a=" << a.a;
　　　　　　　　cout << " b=" << b << endl;
　　　　}
};
//函数不能放在class A中，否则会编译报错
void A::show(B &b) {
　　　　cout << " a=" << a;
　　　　cout << " b=" << b.b << endl;
}
int main() {
　　　　A a;
　　　　B b;
　　　　a.show(b);
　　　　b.show(a);
　　　　return 0;
}

La construction de la classe A
La construction de la classe B
a=20　b=12
a=20　b=12
La classe B est détruite
La classe A est détruite

La méthode de faire des classes amies est de déclarer friend class B; dans la classe A, et de déclarer friend class A; dans la classe B;

Attention :Les endroits où la classe A utilise la classe B doivent être définis après la déclaration de la classe B, et ne peuvent être déclarés que dans la classe A. Par exemple, la fonction show de la classe A à gauche ne peut pas être définie directement dans la classe A, mais doit être placée après la déclaration de la classe B.