Función amiga de C++ y Clases amigas

Función amiga de C++ y Clases amigas

En este tutorial, aprenderemos a crear funciones amigas y clases amigas en C++ con la ayuda de ejemplos.

La ocultación de datos es un concepto fundamental de la programación orientada a objetos. Restringe el acceso de miembros privados desde fuera de la clase.

Del mismo modo, solo las clases derivadas pueden acceder a los miembros protegidos y no se puede acceder a ellos desde el exterior. Por ejemplo,

class MyClass {
    private:
        int member1;
}

int main() {
    MyClass obj;

    // Error! Cannot access private members from here.
    obj.member1 = 5;
}

Sin embargo, hay una función en C++ llamada funciones de amigos que rompen esta regla y nos permiten acceder a funciones miembro desde fuera de la clase.

Del mismo modo, hay una clase de amigos también, que aprenderemos más adelante en este tutorial.

---

Función amigo en C++

Una función de amigo puede acceder a la privada y protegido datos de una clase. Declaramos una función amiga usando el friend palabra clave dentro del cuerpo de la clase.

class className {
    ... .. ...
    friend returnType functionName(arguments);
    ... .. ...
}

---

Ejemplo 1:funcionamiento de la función amigo

// C++ program to demonstrate the working of friend function

#include <iostream>
using namespace std;

class Distance {
    private:
        int meter;
        
        // friend function
        friend int addFive(Distance);

    public:
        Distance() : meter(0) {}
        
};

// friend function definition
int addFive(Distance d) {

    //accessing private members from the friend function
    d.meter += 5;
    return d.meter;
}

int main() {
    Distance D;
    cout << "Distance: " << addFive(D);
    return 0;
}

Salida

Distance: 5

Aquí, addFive() es una función de amigo que puede acceder tanto a privados y público miembros de datos.

Aunque este ejemplo nos da una idea sobre el concepto de una función de amigo, no muestra ningún uso significativo.

Un uso más significativo sería operar sobre objetos de dos clases diferentes. Ahí es cuando la función de amigo puede ser muy útil.

---

Ejemplo 2:agregar miembros de dos clases diferentes

// Add members of two different classes using friend functions

#include <iostream>
using namespace std;

// forward declaration
class ClassB;

class ClassA {
    
    public:
        // constructor to initialize numA to 12
        ClassA() : numA(12) {}
        
    private:
        int numA;
        
         // friend function declaration
         friend int add(ClassA, ClassB);
};

class ClassB {

    public:
        // constructor to initialize numB to 1
        ClassB() : numB(1) {}
    
    private:
        int numB;
 
        // friend function declaration
        friend int add(ClassA, ClassB);
};

// access members of both classes
int add(ClassA objectA, ClassB objectB) {
    return (objectA.numA + objectB.numB);
}

int main() {
    ClassA objectA;
    ClassB objectB;
    cout << "Sum: " << add(objectA, objectB);
    return 0;
}

Salida

Sum: 13

En este programa, ClassA y ClassB han declarado add() como función de amigo. Así, esta función puede acceder a privados datos de ambas clases.

Una cosa a tener en cuenta aquí es la función de amigo dentro de ClassA está usando el ClassB . Sin embargo, no hemos definido ClassB en este punto.

// inside classA 
friend int add(ClassA, ClassB);

Para que esto funcione, necesitamos una declaración directa de ClassB en nuestro programa.

// forward declaration
class ClassB;

---

Clase amiga en C++

También podemos usar una Clase amiga en C++ usando el friend palabra clave. Por ejemplo,

class ClassB;

class ClassA {
   // ClassB is a friend class of ClassA
   friend class ClassB;
   ... .. ...
}

class ClassB {
   ... .. ...
}

Cuando una clase se declara como clase amiga, todas las funciones miembro de la clase amiga se convierten en funciones amigas.

Desde ClassB es una clase amiga, podemos acceder a todos los miembros de ClassA desde dentro ClassB .

Sin embargo, no podemos acceder a los miembros de ClassB desde dentro ClassA . Es porque la relación de amistad en C++ solo se otorga, no se toma.

---

Ejemplo 3:Clase amiga de C++

// C++ program to demonstrate the working of friend class

#include <iostream>
using namespace std;

// forward declaration
class ClassB;

class ClassA {
    private:
        int numA;

        // friend class declaration
        friend class ClassB;

    public:
        // constructor to initialize numA to 12
        ClassA() : numA(12) {}
};

class ClassB {
    private:
        int numB;

    public:
        // constructor to initialize numB to 1
        ClassB() : numB(1) {}
    
    // member function to add numA
    // from ClassA and numB from ClassB
    int add() {
        ClassA objectA;
        return objectA.numA + numB;
    }
};

int main() {
    ClassB objectB;
    cout << "Sum: " << objectB.add();
    return 0;
}

Salida

Sum: 13

Aquí, ClassB es una clase amiga de ClassA . Entonces, ClassB tiene acceso a los miembros de classA .

En ClassB , hemos creado una función add() que devuelve la suma de numA y numB .

Desde ClassB es una clase amiga, podemos crear objetos de ClassA dentro de ClassB .