Funciones Amigas

El lenguaje C++ es compatible y hereda todas las características del lenguaje C. El lenguaje C es un
lenguaje estructurado y solo permite definir funciones (no existen las clases).

En C++ seguimos pudiendo definir funciones independientes fuera de una clase pero no es conveniente
para una buena organización de nuestro código.

En algunas situaciones puede ser conveniente definir una función independiente pero que tenga acceso a
los atributos privados y protegidos de una clase, esto se logra con las funciones amiga (friend)

Para definir una función amiga debemos anteceder la palabra clave friend y cuando la llamamos como
realmente no pertenece a la clase sino que es amiga la invocamos por su nombre y no antecedemos un
nombre de objeto.

Problema:

Crear una clase llamada Temperatura que permita inicializar la temperatura mínima, máxima y actual.
Definir una función amiga que reciba dos objetos de la clase Temperatura y retorne la temperatura
promedio actual.

Programa:
#include<iostream>

using namespace std;

class Temperatura {
double minima, maxima, actual;
public:
Temperatura(double min, double max, double act){
minima = min; maxima = max; actual = act;
}
friend double temperaturaMedia(const Temperatura &t1, const Temperatura &t2);
};

double temperaturaMedia(const Temperatura &t1, const Temperatura &t2)

{
double pro =(t1.actual + t2.actual)/2;
return pro;
}

int main()
{
Temperatura temperatura1(10.0, 20.0, 15.0);
Temperatura temperatura2(12.0, 25.0, 17.0);
cout << "La temperatura promedio de las temperaturas actuales es:";
cout << temperaturaMedia(temperatura1, temperatura2);
return 0;
}
Hemos definido tres atributos en la clase Temperatura y como vemos son privados ya que no le
antecedemos ningún modificador de acceso (private, public, protected):

class Temperatura {
double minima, maxima, actual;

El constructor inicializa los tres atributos con los valores de los parámetros y lo definimos inline (es decir
lo codificamos en la misma declaración de la clase):

public:
Temperatura(double min, double max, double act)
{
minima = min; maxima = max; actual = act;
}

La función amiga la declaramos dentro de la clase pero realmente no pertenece a la misma, pero puede
acceder a los atributos, recibe como parámetros dos objetos de la clase Temperatura:

friend double temperaturaMedia(const Temperatura &t1, const Temperatura &t2);

La codificación de la función amiga nos deja bien en claro que no pertenece a la clase Temperatura y por
lo mismo no le antecedemos dicho nombre:

double temperaturaMedia(const Temperatura &t1, const Temperatura &t2)

{
double pro = (t1.actual + t2.actual)/2.0;
return pro;
}

Dentro del algoritmo de la función temperaturaMedia podemos acceder al atributo actual de cada objeto
de la clase Temperatura gracias a que esta función es amiga (friend) de dicha clase.

Si no declaramos a esta función friend de la clase Temperatura se genera un error sintáctico cuando
tratamos de acceder a los atributos t1.actual+t2.actual.

En la función main creamos dos objetos de la clase Temperatura:

Temperatura temperatura1(10, 20, 15);

Temperatura temperatura2(12, 25, 17);

Y es muy importante entender que cuando llamamos a una función amiga lo hacemos directamente por su
nombre y no le antecedemos ningún nombre de objeto:

cout << temperaturaMedia(temperatura1, temperatura2);

Es decir, la función temperaturaMedia es una función que no pertenece a la clase Temperatura pero se le
ha dado el privilegio de poder acceder a sus atributos en el caso que defina o reciba como parámetros
objetos de la clase Temperatura.