Instituto Politécnico

Nacional
Escuela Superior de Ingeniería Mecánica y Eléctrica
Unidad Culhuacán

“Ingeniería en Computación”

Programación Orientada a Objetos

“Funciones Amigas”
“Clases Amigas”
“Métodos Amigos”

Integrantes:
Hernández Nava María José
Mendoza Fuentes Karina Araceli
Cruz Pérez Edgar
Rodríguez Méndez Ariel

Grupo: 2CX41 Turno: Matutino Fecha de Entrega: /10/2015

INDICE TEMÁTICO

INTRODUCCIÓN ............................................................................................................................... 3

JUSTIFICACIÓN ............................................................................................................................... 4

OBJETIVOS DE APRENDIZAJE ...................................................................................................... 5

DESARROLLO DEL TEMA .............................................................................................................. 6

FUNCIONES AMIGAS ............................................................................................................... 6

CLASES AMIGAS ...................................................................................................................... 8

MÉTODOS AMIGOS................................................................................................................ 11

CONCLUSIÓN................................................................................................................................. 14

GLOSARIO ..................................................................................................................................... 15

BIBLIOGRAFÍA ............................................................................................................................... 16

2
INTRODUCCIÓN
En el presente trabajo, definiremos lo que son las funciones amigas y sus clases, así mismo como los
métodos de las cuales se componen. Una función amiga es una función no miembro de una clase que
puede tener acceso a las partes privadas de una clase; se debe declarar como amiga de la clase
mediante la palabra reservada friend.
Las funciones amigas se declaran situando su prototipo de función en la clase de la que son amiga
precediéndola con la palabra reservada friend.
Las razones fundamentales para utilizar funciones amigas es que algunas funciones necesitan acceso
privilegiado a más de una clase. Una segunda razón es que las funciones amigas pasan todos sus
argumentos a través de la lista de argumentos y cada valor de argumento se somete a la conversión
de asignación.
Una función amiga de una clase se define por fuera del alcance directo de los miembros privados de
dicha clase, pero aun así tiene el derecho de acceso a los miembros private de la clase. Se puede
declarar una función o toda una clase como friend de otra clase. Para declarar una función como friend
en una clase, en la definición de clase procede el prototipo de la función con la palabra reservada
friend.
No sólo puede ser una función amiga de una clase, también una clase completa puede ser amiga de
otra clase. En este caso todas las funciones de la clase amiga pueden acceder a las partes privadas
de la otra clase.
De este modo en cada una de ellas existirán los métodos, que pueden implementarse dentro de las
mismas, también se pueden implementar los métodos fuera.

3
JUSTIFICACIÓN
Ya sabemos que los miembros privados de una clase no son accesibles para funciones y clases
exteriores a dicha clase. Este es uno de los conceptos de POO, el encapsulamiento, que tiene como
objetivo hacer que lo que pase en el interior de cada objeto sea inaccesible desde el exterior, y que
el comportamiento de otros objetos no pueda influir en él. Cada objeto sólo responde a ciertos
mensajes y proporciona determinadas salidas.
Pero, en ciertas ocasiones, necesitaremos tener acceso a determinados miembros de un objeto de
una clase desde otros objetos de clases diferentes, pero sin perder ese encapsulamiento para el
resto del programa, es decir, manteniendo esos miembros como privados. C++ proporciona un
mecanismo para sortear el sistema de protección. En otros capítulos veremos la utilidad de esta
técnica, pero de momento sólo explicaremos en qué consiste.
Declaraciones friend
El modificador friend puede aplicarse a clases o funciones para inhibir el sistema de protección.
Las relaciones de "amistad" entre clases son parecidas a las amistades entre personas:
 La amistad no puede transferirse, si A es amigo de B, y B es amigo de C, esto no implica que
A sea amigo de C.
 La amistad no puede heredarse. Si A es amigo de B, y C es una clase derivada de B, A no es
amigo de C.
 La amistad no es simétrica. Si A es amigo de B, B no tiene por qué ser amigo de A.
Dentro de esta investigación encontraremos más información respecto a este tema que lleva por
nombre: CLASES, FUNCIONES Y METODOS AMIGOS.

4
OBJETIVOS DE APRENDIZAJE

1. Entender la importancia del modificador friend en un programa que usa clases y funciones con
diferentes nombres.

2. Saber cómo se implementa el modificador friend dentro de una función.

3. Saber cómo se implementa el modificador friend dentro de una clase.

4. Distinguir los diferentes tipos de métodos que existen al usar una Función amiga.

5. Distinguir los diferentes tipos de métodos que existen al usar una Clase amiga.

5
DESARROLLO DEL TEMA
FUNCIONES AMIGAS
Una función amiga es una función no miembro de una clase que puede tener acceso a las partes
privadas de una clase; se debe declarar como amiga de la clase mediante la palabra reservada friend.
Las funciones amigas se declaran situando su prototipo de función en la clase de la que son amiga
precediéndola con la palabra reservada friend. Por ejemplo:
class cosa
{
private:
int datos;
public:
friend void cargar (cosa& t, int x);
};
void cargar(cosa& t, int x)
{
t.datos=x;
}
Como la función cargar se declara amiga de la clase cosa puede acceder al miembro privado datos.
Las razones fundamentales para utilizar funciones amigas es que algunas funciones necesitan acceso
privilegiado a más de una clase. Una segunda razón es que las funciones amigas pasan todos sus
argumentos a través de la lista de argumentos y cada valor de argumento se somete a la conversión
de asignación.

6
Un ejemplo más para las funciones amigas:

#include <iostream>

class A
{ // clase anfitriona
char c; // privado por defecto
static int sti;
char getC(void); // función privada
public:
friend void finv(A* aptr, char ch ); // L.9: finv es función invitada
void func(A* aptr, char ch); // L.10: func es función miembro
};
int A::sti = 33; // inicia miembro estático
char A::getC(void)
{
return c;
} // define función privada
void finv (A* aptr, char ch)
{ // L.16: define función
aptr->c = ch;
cout << "valor de c: " << aptr -> getC() << endl;
cout << "valor de sti: " << A::sti << endl;
}
void A::func (A* aptr, char ch)
{ // L.22: define función miembro
aptr->c = ch;
cout << "valor de c: " << aptr->getC() << endl;
cout << "valor de sti: " << A::sti << endl;
}
int main() { // =========================
A a1; // instancia A
finv(&a1, 'Y'); // L.30: invocar función
a1.func(&a1, 'Z'); // L.31: invocar función-miembro
cin.get();
}

7
 CLASES AMIGAS
Ya sabemos que los miembros privados de una clase no son accesibles para funciones y clases
exteriores a dicha clase.
Este es uno de los conceptos de POO, el encapsulamiento, que tiene como objetivo hacer que lo que
pase en el interior de cada objeto sea inaccesible desde el exterior, y que el comportamiento de otros
objetos no pueda influir en él. Cada objeto sólo responde a ciertos mensajes y proporciona
determinadas salidas.
Pero, en ciertas ocasiones, necesitaremos tener acceso a determinados miembros de un objeto de
una clase desde otros objetos de clases diferentes, pero sin perder ese encapsulamiento para el resto
del programa, es decir, manteniendo esos miembros como privados.
C++ proporciona un mecanismo para sortear el sistema de protección.
Modificador friend
El modificador friend puede aplicarse a clases o funciones para inhibir el sistema de protección.
Las relaciones de "amistad" entre clases son parecidas a las amistades entre personas:
 La amistad no puede transferirse, si A es amigo de B, y B es amigo de C, esto no implica que
A sea amigo de C. (La famosa frase: "los amigos de mis amigos son mis amigos" es falsa en
C++, y probablemente también en la vida real).
 La amistad no puede heredarse. Si A es amigo de B, y C es una clase derivada de B, A no es
amigo de C. (Los hijos de mis amigos, no tienen por qué ser amigos míos. De nuevo, el símil
es casi perfecto).
 La amistad no es simétrica. Si A es amigo de B, B no tiene por qué ser amigo de A. (En la vida
real, una situación como esta hará peligrar la amistad de A con B, pero de nuevo me temo que
en realidad se trata de una situación muy frecuente, y normalmente A no sabe que B no se
considera su amigo).
El caso más sencillo es el de una relación de amistad con una función externa. Veamos un ejemplo
muy sencillo:
#include <iostream> // de la clase A, ya que ha sido declarada
using namespace std; "amiga" de A
cout << Xa.a << endl;
class A { }
public:
A(int i=0) : a(i) {} int main() {
void Ver() { cout << a << endl; } A Na(10);
private:
int a; Ver(Na); // Ver el valor de Na.a
friend void Ver(A); // "Ver" es amiga de la Na.Ver(); // Equivalente a la anterior
clase A
}; return 0;
void Ver(A Xa) { }
// La función Ver puede acceder a miembros
privados

8
Como se puede ver, la función "Ver", que no pertenece a la clase A puede acceder al miembro privado
de A y visualizarlo. Incluso podría modificarlo.
En el caso de las clases amigas, al declarar dos diferentes clases dentro de un programa podemos
necesitar en algún momento que, por llamar a la primera clase A y a la segunda clase B, la clase B
ocupe los atributos de la clase A.
Pero hay que recordar que si solo mandamos a llamar los atributos de la clase A para usarlos en la
clase B sin usar ningún modificador nunca lograremos correr el programa.
Esto se debe a que no existe ninguna relación entre ambas clases, por lo cual se nos proporciona el
modificador friend el cual hace que exista una relación entre ambas clases volviéndolas amigas y
logrando que se puedan usar los atributos de una clase en otra. Este modificador nos permite usar,
modificar y proyectar los atributos de otra clase y este lo podemos codificar al final de cada clase, en
la parte pública o en la parte privada de nuestra clase.
Por ejemplo tenemos el siguiente programa:
#include <iostream> public:
persona ()
class punto {
{ p.x = 1.0;
private: p.y = 2.0;
double x,y; };
public:
punto(double a = 0.0, double b = 0.0) void imprime ()
{ {
x = a; cout<<p.x<<" , "<<p.y<<endl;
y= b; };
};
}persona;
friend class persona;
}; main ()
{
class persona persona.imprime ();
{ cin.get();
private: }
punto p;

Notemos que la clase punto declara que es amiga de la case persona al colocar dentro de sus métodos
la siguiente línea:
friend class persona;
Esto le da permiso a la clase persona a tomar sus atributos (variables) para usarlas en sus métodos
propios.
Entonces es importante decir que las clases amigas son muy útiles usar y modificar ciertas variables
que forman parte de los atributos de cases diferentes.

9
Un ejemplo más para las clases amigas:
#include <iostream>

class A
{ // clase anfitriona
char c; // privado por defecto
char getC(void); // función privada
static int sti; // miembro estático
public:
friend class B; // L.9: declara B clase invitada
};
int A::sti = 33; // inicia miembro estático
char A::getC(void)
{
return c;
} // define función privada
class B { // L.14: define clase invitada
public:
void setAc(class A&, char); // método-1
static void getA(class A*); // método-2
};
void B::setAc(class A& aref, char ch)
{ // L.19 define método-1
aref.c = ch;
}
void B::getA(class A* aptr)
{ // L.22 define método-2
cout << "valor de c: " << aptr->getC() << endl;
cout << "valor de sti: " << A::sti << endl;
}

int main()
{ // =========================
A a1; // L.28: instancia A
B b1; // instancia B
A& aref = a1; // define referencia de clase A
b1.setAc(aref, 'Y'); // L.31: invoca método público de objeto
b1.getA(&a1);
B::getA(&a1);
cin.get();
}

10
 MÉTODOS AMIGOS

En C++ podemos asociar las operaciones con los datos simplemente incluyendo las funciones dentro
de la definición de la estructura. Las funciones declaradas de esta forma se llaman métodos o
funciones miembros.

Para ejecutar estos métodos, se ha de utilizar una variable de esa

estructura con el operador punto . (Acceso habitual a miembros)

Los métodos pueden implementarse dentro de la clase: se llaman funciones insertadas. También se
pueden implementar los métodos fuera la de la clase.
El Conjunto de métodos son función miembro: Permite que los objetos cambien de estado,
dependiendo del estado anterior que tuviera el objeto.

11
Los métodos se definen de la misma forma que las funciones normales. Lo normal es que dentro del
cuerpo de la clase, solo aparezcan los prototipos, y la implementación de las funciones fuera. Así los
detalles de la implementación permanecen ocultos y la interfaz queda mucho más clara.

Implementación de los métodos fuera de la clase

Esta es la opción más correcta. La implementación del método ingresar sería el siguiente:

Se pone el nombre de la clase delante del

nombre del método, porque podemos
tener varias clases con el mismo método.

La implementación del método dar_saldo sería

el siguiente:

12
En el código de los métodos se puede usar todo lo que está declarado en la clase: lo público y lo
privado. Los métodos o función miembro deben ser públicos
Los métodos describen el comportamiento de los objetos de una clase. Representan las operaciones
que se pueden realizar con los objetos de la clase. La ejecución de un método puede conducir a
cambiar el estado del objeto.

Los métodos en las funciones pueden incluirse:

• Declaraciones de variables locales.
• Asignaciones a variables.
• Operaciones matemáticas.
• Llamados a otros métodos.
• Estructuras de control.
• Excepciones.

13
CONCLUSIÓN
Gracias a la palabra reservada “friend” se pueden declarar relaciones de confianza que existen entre
clases, y de esta manera permitir que una clase o función amiga pueda acceder a los atributos y
métodos privados de esa clase. Aunque es muy útil, cabe resaltar que esta relación que existe entre
clases solo funciona con una sola dirección, ósea que las funciones miembro de la clase amiga pueden
acceder a las variables privadas de una clase cualquiera, siempre y cuando sea solo una clase.
Gracias a las funciones amigas se pueden resolver operaciones con objetos de dos clases distintas,
ya sea comunicando estas dos clases o más, accediendo a datos privados de las mismas e incluso
burlando el escondite de datos de las clases.
Tampoco las funciones o clases se pueden auto-declararse amigas y acceder a la privacidad de otra
clase sin que él programador lo autorice

14
GLOSARIO
Abstracto.- Que significa alguna cualidad con exclusión del sujeto.
Agregar.- Añadir algo a lo ya dicho, escrito o creado.
Atributo.- Especificación que define una propiedad de un Objeto, elemento o archivo. También puede
referirse o establecer el valor específico para una instancia determinada de los mismos.
Clase.- En programación es un tipo de datos creados por el usuario que encapsula datos y métodos o
funciones.
Código.- Conjunto de líneas de texto que son las instrucciones que debe seguir la computadora para
ejecutar un programa.
Datos.- Cualquier representación de hechos, información o conceptos de una forma que permita el
tratamiento informático, incluido un programa diseñado para que un sistema informático ejecute una
función
Depender.- Relación de origen o conexión.
Encapsulamiento.- Ocultamiento del estado, es decir, de los datos miembro de un objeto de manera
que sólo se pueda cambiar mediante las operaciones definidas para ese objeto.
Estructura.- Distribución y orden con que está compuesta una obra de ingenio, como un poema, una
historia, etc.
Función.- Subalgoritmo que forma parte del algoritmo principal, el cual permite resolver una tarea
específica.
Interfaz.- Es el desarrollo que sirve de enlace entre dos sistemas, de tal manera que la información
que recibe del sistema origen, lo convierte en la misma sintaxis que maneja el sistema destino y de
hecho, incorpora los datos recibidos del sistema origen en el sistema destino.
Método.- Algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución se desencadena
tras la recepción de un "mensaje". Desde el punto de vista del comportamiento, es lo que el objeto
puede hacer. Un método puede producir un cambio en las propiedades del objeto, y/o la generación
de un "evento" con un nuevo mensaje para otro objeto del sistema.
Miembro.- Parte o apartado que, junto con otros, forman un conjunto o sistema.
Modificador.- Conjunto de funciones de programación del lenguaje C que se aplican a las variables
dentro de la estructura de un programa antes de que éste sea mostrado.
Objeto.- Todo lo que puede ser materia de conocimiento o sensibilidad de parte del sujeto, incluso este
mismo.
Operación.- Instrucción para que sea concretada por una clase o función.
Private.- Miembros privados de una clase que sólo son accesibles por los propios miembros de la clase
y en general por objetos de la misma clase, pero no desde funciones externas o desde funciones de
clases derivadas.
Public.- Miembros que son accesibles desde cualquier parte donde sea accesible el propio objeto.
Variables.- Espacio que contiene una cantidad o información conocida o desconocida, es decir un
valor.

15
BIBLIOGRAFÍA
- http://www.nebrija.es/~abustind/Informatica/MetodologiaII/Claseamigas.pdf

- http://www.nebrija.es/~abustind/Informatica/MetodologiaII/Introduccion.pdf

- http://c.conclase.net/curso/?cap=032

- http://decsai.ugr.es/~jfv/ed1/c++/cdrom3/TIC-CD/web/tema18/teoria_7.htm

16