函数和类友元C++

In questo articolo, imparerai a creare funzioni amiche e classi amiche in C++ e a usarle efficacemente nei tuoi programmi.

OOPuno dei concetti importanti è la mascheramento dei dati, ossiafunzione non memberNon è possibile accedere ai dati privati o protetti dell'oggetto.

Ma a volte questa limitazione può costringere i programmatori a scrivere codice lungo e complesso. Pertanto, il linguaggio di programmazione C++ ha integrato un meccanismo che permette di accedere ai dati privati o protetti da funzioni non member.

Questo è fatto utilizzando funzioni amiche e classi amiche.

funzioni amiche in C++

Se definisci la funzione come funzione amica, puoi usarefunzioneper accedere ai dati privati e protetti della classe.

attraverso l'uso della parola chiaveamico, il compilatore sa che la funzione fornita è una funzione amica.

Per accedere ai dati, dovresti dichiarare la funzione amica all'interno della classe utilizzando la parola chiave friend (può essere in qualsiasi parte interna della classe, sia nella parte privata che nella parte pubblica).

Dichiarazione delle funzioni amiche in C++

class nomeClasse
{
　　　　...　..　...
　　　　amico return_type nomeFunzione(argumento/i);
　　　　...　..　...
}

Ora puoi definire la funzione amica come una funzione normale che accede ai dati della classe. La definizione amica non utilizza alcuna parola chiave.

class nomeClasse
{
　　　　...　..　...
　　　　amico return_type funzioneNome(argumento/i);
　　　　...　..　...
}
return_type funzioneNome(argumento/i)
{
　　　　...　..　...
　　　　// Puoi accedere ai dati privati e protetti di className da questa posizione
　　　　　// Poiché questa funzione è un funzione amica di className.
　　　　...　..　...
}

Esempio 1: Funzionamento delle funzioni amiche

/* Programma C++ che dimostra il funzionamento delle funzioni amiche. */
#include <iostream>
using namespace std;
class Distance
{
　　　　private:
　　　　　　　　int meter;
　　　　public:
　　　　　　　　Distance(): meter(0) {}
　　　　　　　　// Funzione amica
　　　　　　　　friend int addFive(Distance);
};
// Definizione funzione amica
int addFive(Distance d)
{
　　　　// Accesso ai dati privati da una funzione non membro
　　　　d.meter += 5;
　　　　return d.meter;
}
int main()
{
　　　　Distance D;
　　　　cout << "Distanza: " << addFive(D);
　　　　return　0;
}

Risultato dell'output

Distanza: 5

In questo caso, la funzione amica addFive() è dichiarata nella classe Distance. Pertanto, è possibile accedere ai dati privati da questa funzione.

Nonostante questo esempio ti fornisca idee sul concetto di funzione amica, non mostra alcun uso significativo.

Quando devi operare con oggetti di classi diverse, c'è un uso più significativo. In quel caso, la funzione amica sarà molto utile.

Puoi operare con oggetti di classi diverse senza utilizzare la funzione amica, ma questo programma sarebbe molto lungo, complesso e difficile da comprendere.

Esempio 2: Somma di membri di classi diverse utilizzando funzione amica

#include <iostream>
using namespace std;
// Dichiarazione anticipata
class B {
class A {
　　　　private:
　　　　　　int numA;
　　　　public:
　　　　　　A(): numA(12) {}
　　　　　　// Dichiarazione funzione amica
　　　　　　friend int add(A, B);
};
class B {
　　　　private:
　　　　　　　int numB;
　　　　public:
　　　　　　　B(): numB(1) {}
　　　　　　　// Dichiarazione funzione amica
　　　　　　　friend int add(A, B);
};
// La funzione add() è un funzione amica della classe A e B
// Accesso ai variabili membro numA e numB
int add(A objectA, B objectB)
{
　　　return (objectA.numA + objectB.numB);
}
int main()
{
　　　　A objectA;
　　　　B objectB;
　　　　cout << "Somma: " << add(objectA, objectB);
　　　　return　0;
}

Risultato dell'output

Somma: 13

In questo programma, le classi A e B hanno dichiarato add() come funzione amica. Pertanto, questa funzione può accedere ai dati privati di queste due classi.

In questo contesto, la funzione add() somma i dati privati numA e numB di due oggetti objectS e object e li restituisce alla funzione main.

Per far funzionare correttamente questo programma, come nell'esempio sopra indicato, è necessario fare una dichiarazione anticipata della classe B.

Questo è perché è stato utilizzato il seguente codice per fare riferimento alla funzione amica della classe B nella classe A: friend int add(A, B);

Classi amiche (friend class) nel programming C++

Allo stesso modo, come una funzione amica, una classe può utilizzare la parola chiave friend per diventare la classe amica di un'altra classe. Ad esempio:

...　..　...
class B {
class A
{
　　　// class B è la classe amica di class A
　　　friend class B;
　　　...　..　...
}
class B
{
　　　...　..　...
}

Quando una classe diventa la classe friend di un'altra classe (classe amica), questo significa che tutte le funzioni dei membri di questa classe sono funzioni amiche dell'altra classe.

In questo programma, tutti i membri delle funzioni della classe B sono amici delle funzioni della classe A, quindi tutte le funzioni dei membri della classe B possono accedere ai dati privati e protetti della classe A, ma le funzioni dei membri della classe A non possono accedere ai dati della classe B.

Come diventare classA e B amicizia reciproca nel programming C++

Come implementare classA e B come amicizia reciproca, ossia A può accedere ai dati privati di B e B può accedere ai dati privati di A? Ecco un esempio:

#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;
}

类A被构造
构造类B
a=20　b=12
a=20　b=12
类B被析构
类A被析构

互为友元类的做法就是，在class A中声明friend class B;在classB 中声明friend class A;

注意：在类B的声明后定义，在类A中只能声明，类A中使用到了类B的地方必须在类B的声明后定义。例如左边类A中的show函数，不能在类A中直接定义，只能放在类B的声明之后定义。