Amistad mutua de Clases en C++ con Ejemplos

Prerrequisito: Clase amiga en C++
Una clase amiga puede acceder a miembros privados y protegidos de otras clases en las que se declara como amiga. A veces es útil permitir que una clase en particular acceda a miembros privados de otra clase. 
A continuación se muestra el programa para ilustrar la clase amiga: 
 

// C++ program to illustrate friend class
#include <iostream>
using namespace std;
 
// Class A
class A {
private:
    // Private member of Class A
    int a;
 
public:
    // Constructor to initialise private
    // member of class A
    A() { a = 0; }
 
    // Make friend class B using a friend
    // keyword
    friend class B;
};
 
// Class B
class B {
private:
    // Private members of class B
    int b;
 
public:
    // Members function of class B
    void showA(A& x)
    {
        // Since B is friend of A,
        // it can access private members
        // of class A
        cout << "Accessed Private "
             << "Member of class A\n";
        cout << "A::a = " << x.a;
    }
};
 
int main()
{
    // Object of class A
    A a;
 
    // Object of class B
    B b;
 
    // Member function of friend class B
    b.showA(a);
    return 0;
}

Accessed Private Member of class A
A::a = 0

Amistad mutua de clases: se dice que las clases A y B tienen amistad mutua si la clase A es una clase amiga de la clase B y la clase B es una clase amiga de la clase A. Debido al establecimiento de amistad entre estas dos clases, ambas las clases pueden acceder entre sí a miembros protegidos y privados utilizando sus propias funciones de miembro. Procediendo normalmente para declarar y definir funciones dentro de estas dos clases, se encontrará un error de sintaxis
común , que indica que la clase declarada primero no puede acceder a los miembros de datos de la clase siguiente, incluso cuando se hizo amigo. Por lo tanto, la amistad no es mutua . Si la clase A es amiga de B , entonces B
no se vuelve amigo de la clase A automáticamente.
Pero podemos hacer la amistad mutua de las clases evitando el error que ocurrió anteriormente, las funciones en la primera clase que acceden a los miembros de datos de la segunda clase se definen después de la segunda clase usando un operador de resolución de alcance .
Supongamos que la clase A se definió primero en el programa y la clase B se definió después de la clase A. Las funciones miembro de la clase A que acceden a los datos de la clase B deben definirse después de la clase B. Esto se hace para asegurarse de que el compilador lea primero la clase Bque a su vez proporcionará la información al compilador de que la clase A es amiga de la clase B y, por lo tanto, puede acceder a sus miembros.
A continuación se muestra el programa para ilustrar la amistad mutua de las clases:
 

// C++ program to illustrate mutual
// friendship of classes
#include <iostream>
using namespace std;
 
// Forward Declaration
class B;
 
// Class A
class A {
 
    // Member of class A
    int data;
 
public:
    // Make B as a friend of class A
    friend class B;
 
    // Constructor to initialise member
    // of class A
    A(int d) { data = d; }
 
    // Function to get data of friend
    // class B
    void get_data_B(B objb);
};
 
// Class B
class B {
 
    // Member of class B
    int dataB;
 
public:
    // Making A a friend of class B
    friend class A;
 
    // Constructor to initialise member of
    // class B
    B(int d) { dataB = d; }
 
    // Function to get the data of
    // friend class A
    void get_data_A(A obja)
    {
        cout << "Data of A is: "
             << obja.data;
    }
};
 
// Function for accessing friend class
// B's object
void A::get_data_B(B objb)
{
    cout << "Data of B is: "
         << objb.dataB;
}
 
// Driver Code
int main()
{
 
    // Object of class A
    A a(10);
 
    // Object of class B
    B b(20);
 
    // Print data of class A
    b.get_data_A(a);
    cout << endl;
 
    // Print data of class B
    a.get_data_B(b);
    return 0;
}

Data of A is: 10
Data of B is: 20

En el programa anterior, la clase A y la clase B son amigos mutuos. Por lo tanto, para acceder al miembro privado de la clase A también se puede hacer desde la función miembro de la clase B y para acceder al miembro privado de la clase B también se puede hacer desde la función miembro de la clase A.