Funciones y clases amigas en C++: dominando el control de acceso

Funciones y clases amigas en C++: dominando el control de acceso

Este tutorial demuestra cómo declarar y usar funciones amigas y clases amigas en C++, completo con ejemplos claros.

El ocultamiento de datos es una piedra angular de la programación orientada a objetos, impidiendo que código externo acceda directamente a los miembros privados de una clase. Los miembros protegidos solo son visibles para las clases derivadas y permanecen inaccesibles desde el mundo exterior.

Considere el siguiente ejemplo:

class MiClase {
private:
    int miembro1;
};

int main() {
    MiClase obj;
    // ¡Error! No se puede acceder a miembros privados desde aquí.
    obj.miembro1 = 5;
}

A pesar de esta restricción, C++ ofrece un mecanismo llamado funciones amigas que puede eludir el control de acceso habitual y operar sobre los miembros privados y protegidos de una clase.

Una clase amiga es un concepto similar, permitiendo que una clase entera actúe como amiga. Ambas características son herramientas poderosas cuando se usan con criterio, mejorando el encapsulamiento sin comprometer la flexibilidad.

---

Función amiga en C++

Una función amiga puede leer y modificar los miembros privados y protegidos de una clase. Se declara con la palabra clave friend dentro de la definición de la clase.

class NombreClase {
    // ...
    friend tipoRetorno nombreFuncion(argumentos);
    // ...
}

---

Ejemplo 1: Función amiga básica

// Programa en C++ para demostrar el funcionamiento de función amiga
#include <iostream>
using namespace std;

class Distancia {
private:
    int metro;
    // función amiga
    friend int sumarCinco(Distancia);
public:
    Distancia() : metro(0) {}
};

// definición de función amiga
int sumarCinco(Distancia d) {
    // accediendo a miembros privados desde la función amiga
    d.metro += 5;
    return d.metro;
}

int main() {
    Distancia D;
    cout << "Distancia: " << sumarCinco(D);
    return 0;
}

Salida

Distancia: 5

La función sumarCinco() demuestra que una función amiga puede acceder libremente al campo privado metro. Aunque este ejemplo es simple, ilustra la idea central de las funciones amigas.

---

Ejemplo 2: Operando con dos clases

// Sumar miembros de dos clases diferentes usando funciones amigas
#include <iostream>
using namespace std;

// declaración adelantada
class ClaseB;

class ClaseA {
public:
    // constructor para inicializar numA a 12
    ClaseA() : numA(12) {}
private:
    int numA;
    // declaración de función amiga
    friend int sumar(ClaseA, ClaseB);
};

class ClaseB {
public:
    // constructor para inicializar numB a 1
    ClaseB() : numB(1) {}
private:
    int numB;
    // declaración de función amiga
    friend int sumar(ClaseA, ClaseB);
};

// acceder a miembros de ambas clases
int sumar(ClaseA objetoA, ClaseB objetoB) {
    return (objetoA.numA + objetoB.numB);
}

int main() {
    ClaseA objetoA;
    ClaseB objetoB;
    cout << "Suma: " << sumar(objetoA, objetoB);
    return 0;
}

Salida

Suma: 13

En este programa, tanto ClaseA como ClaseB declaran la función sumar() como amiga. Esto otorga a la función acceso a los datos privados de ambas clases, permitiendo la suma de numA y numB.

Observe que la declaración amiga en ClaseA referencia ClaseB antes de que esté definida. Una declaración adelantada class ClaseB; resuelve esta dependencia.

---

Clase amiga en C++

Declarar una clase entera como amiga da a todas sus funciones miembro acceso a los miembros privados y protegidos de la clase anfitriona. La sintaxis es sencilla:

class ClaseB;
class ClaseA {
    // ClaseB es una clase amiga de ClaseA
    friend class ClaseB;
    // ...
}
class ClaseB {
    // ...
}

Como ClaseB es amiga de ClaseA, cualquier método dentro de ClaseB puede leer o modificar libremente los datos privados de ClaseA. Lo contrario no es cierto; ClaseA no puede acceder a los miembros privados de ClaseB a menos que declare ClaseB como amiga.

---

Ejemplo 3: Clase amiga en acción

// Programa en C++ para demostrar el funcionamiento de clase amiga
#include <iostream>
using namespace std;

// declaración adelantada
class ClaseB;

class ClaseA {
private:
    int numA;
    // declaración de clase amiga
    friend class ClaseB;
public:
    // constructor para inicializar numA a 12
    ClaseA() : numA(12) {}
};

class ClaseB {
private:
    int numB;
public:
    // constructor para inicializar numB a 1
    ClaseB() : numB(1) {}
    // función miembro para sumar numA de ClaseA y numB de ClaseB
    int sumar() {
        ClaseA objetoA;
        return objetoA.numA + numB;
    }
};

int main() {
    ClaseB objetoB;
    cout << "Suma: " << objetoB.sumar();
    return 0;
}

Salida

Suma: 13

El método sumar() en ClaseB puede acceder al miembro privado numA de ClaseA porque ClaseA declaró a ClaseB como amiga. Este ejemplo muestra cómo las clases amigas permiten cooperación estrecha preservando el encapsulamiento.

En general, las funciones amigas y clases amigas son herramientas valiosas en C++ cuando necesita acceso controlado a través de límites de clase. Úselas con moderación y solo cuando el diseño se beneficie de tales excepciones a las reglas de acceso habituales.