GUIA DE ESTUDIO

FUNCIONES AMIGAS

EJERCICIO #1

Diseñe una clase llamada ECUACION cuyos atributos sea X,Y, Xi( VALOR INICIAL) ,Xf(VALOR_FINAL)

pedido al usuario por un método de lectura. La ecuación a evaluar es:

𝑌 = 𝑠𝑒𝑛(𝑋) + 𝑋

Realice los siguientes:

Declare una función amiga que evalué la función y almacene los resultados de X y Y en arreglos

unidimensionales. Pedir el valor del incremento.

Desplegar en forma tabular.

Ejemplo de salida:

Introduce el valor inicial=-2

Introduce el valor final=2

Valor del incremento=0.5

x Y=sen(X)+X

-2
-1.5
-1
0.5
0
0.5
1
1.5
2
HERENCIA Y CLASES AMIGAS

EJERCICIO #2

Crear una clase llamada Persona formada por: Ejemplo de Salida:

 Boleta de estudiante –[20] char Cuantos alumnos quieres ingresar: 2
 Nombre-[60] char
 Especialidad –[30] char Datos del alumno 1
Escriba la boleta de estudiante: 96630061
Crear otra clase llamada Estudiante que está Escriba el nombre del estudiante : Luis Ivan
formada Escriba la especialidad del estudiante: Computo
por:
(La clase Persona hereda a la clase Estudiante)
 Número de materias-int Cuantas materias toma(1-15)? 5
 Califica -* doublé Calificación de materia 1:6
 Promedio(deberá calcularse) Calificación de materia 2:7
Calificación de materia 3:8
Crear una clase amiga de Estudiante llama Calificación de materia 4:9
Salon que se encuentra formada por: Calificación de materia 5:10
 Alumno -* Estudiante(apuntador a la
clase Estudiante memoria dinámica) Datos del alumno 2
 No. Alumnos. Escriba la boleta de estudiante: 201520348
Escriba el nombre del estudiante : José Pérez
Desarrolle los métodos necesarios para generar Escriba la especialidad del estudiante: Electronica
la salida basada en el ejemplo.
Cuantas materias toma(1-15)? 3
La función main debe ser como sigue: Calificación de materia 1:8
Calificación de materia 2:9
Calificación de materia 3:10
Int main()
{ ----DATOS DEL ESTUDIANTE 1------
Salon S1; Boleta del estudiante: 96630061
S1. Leer(); Nombre del estudiante: Luis Ivan
S1.Imprimir(); Especialidad: Computo
System(“pause”); Calificaciones:6,7,8,9,10
return 0; Promedio:8
} ----DATOS DEL ESTUDIANTE 1------

Boleta del estudiante: 96630061

Nombre del estudiante: Luis Ivan
Especialidad: Computo
Calificaciones:8,9,10
Promedio:9
HERENCIA Y CLASES AMIGAS

EJERCICIO #3

Crear una clase llamada Boleta Computadora Ejemplo de Salida:

formada por:
 Memoria-int Cuantos clientes quieres ingresar: 2
 Disco duro-int
 Tamaño monitor –int Ingresa Datos:
 Precio –double
Cliente: 1
Crear otra clase llamada Cliente la cual hereda Memoria: 4
de la clase Disco Duro: 512
computadora y esta formada por Tamanio Monitor:19
 Nombre- [30] char Precio: 5300
 RFC-[11] char
Cliente: 2
Se tiene una clase llamada Negocio amiga de
cliente y esta formada por: Memoria: 2
 Base de datos-*cliente Disco Duro: 2
 No. Clientes-int Tamanio Monitor:23
 Ventas-double Precio: 8500

Impresión negocio:
Desarrolle los métodos necesarios para
generar la salida
Cliente: 1
basada en el ejemplo
Memoria: 4
Disco Duro: 512
Int main()
Tamanio Monitor:19
{
Precio: 5300
Negocio C1;
C1. Leer();
Cliente: 1
C1.Imprimir();
Memoria: 4
System(“pause”);
return 0;
Disco Duro: 512
}
Tamanio Monitor:19
Precio: 5300

Venta total: 13800

SOBRECARGA DE OPERADORES

EJERCICIO #4

Crear una Clase llamada COMPLEJO formada por:

 Real:float
 Imag:float Int main()
{
Métodos de sobrecarga que deberán declararse para COMPLEJO
operar con operaciones sobre complejos :>>,<<,+,-,*,/, COMP1,COMP2,COMPR;
friend istream operato&>>(istream &L, COMPLEJO &comp) cout<<”COMPLEJO 1:”<<endl
friend ostream operato&<<(ostream &V, COMPLEJO cin>>COMP1;
&comp) cout<COMP1
cin>>COMP2;
COMPLEJO operator +(COMPLEJO &comp) cout<COMP2;
COMPLEJO operator -(COMPLEJO &comp) COMPR=COMP1+COMP2;
COMPLEJO operator *(COMPLEJO &comp) cout<<”SUMA DE COMPLEJO:”;
COMPLEJO operator /(COMPLEJO &comp) cout<<COMPR;
COMPR=COMP1-COMP2;
cout<<”RESTA DE COMPLEJO:”;
cout<<COMPR;
-
-
-
-
EJERCICIO #5

Defina la clase CadenaCar según las especificaciones que se muestran a continuación. Incluya la
sobrecarga de los siguientes operadores:==,!=,+,< y > de tal manera que dos objetos tipo
CadenaCar se puedan comparar(==,!=,<,>) o unir (+) usando los operadores indicados.

CadenaCar
Cadena:string
Constructor(es)
int operator == (CadenaCar Cad)
int operator ¡=(CadenaCar Cad)
int operator < (CadenaCar Cad)
int operator >(CadenaCar Cad)
CadenaCar operator + (CadenaCar Cad)
Void Imprime()
Salida:

Introduce cadena: Omar

Introduce cadena: Juan

Omar es diferente de Juan

Juan es menor que Juan

La cadena unida es: Omar Juan

a) Declare dos objetos tipo CadenaCar

b) Le asigne una cadena de caractes a cada uno de los objetos. La asignación puede ser a
través de una lectura o por medio del método constructor.
c) Compare los objetos e imprima un mensaje adecuado si los mismos son iguales. Si no lo
fueran, el mensaje además de indicar este caso, debe indicar cuál de las cadena es menor.
d) Enlace dos objetos tipo CadenaCar formando un tercer objeto del mismo tipo. Imprima el
objeto resultante.
EJERCICIO #6
Defina la clase Fruta según las especificaciones que se muestran en el diagrama de clases.
Incluya la sobrecarga del operador == para determinar si dos objetos tipo Fruta son
iguales. Dos frutas se considerarán iguales si los valores de todos sus atributos son iguales.
Además, sobrecargue los operadores de entrada(>>) y de salida(<<) para poder leer y
escribir objetos de tipo Fruta.

Fruta
NombreFruta:string
Color:string
Constructor(es)
int operator == (Fruta Cad)
friend istrem &operator >>(istream &L,Fruta &f)
friend ostream &operator<<(ostream &V, Fruta
&f)

El main deberá ser definido así:

Int main()
{
Fruta fruta1, fruta2;
cin>>fruta1;
cin>>fruta2;
cout<<”FRUTA 1”<<endl;
cout<<fruta1;
cout<<”FRUTA 2”<<endl;
cout<<fruta2;
if (fruta1==fruta2)
{
cout<<”Son iguales”<<endl;
}
else
cout<<”Son diferentes”<<endl;
getch();
return 0;
}
TEORICO 1.

¿Qué es una función amiga? Sintaxis

Una función amiga se define como una función no miembro normal. Sin embargo, dentro de la
declaración de clase para la que será una función amiga, está también incluido su prototipo,
precedido por la palabra clave friend.

Una función amiga no es un miembro de una clase, pero tiene acceso a sus elementos privados.

sintaxis

 Class nombre_clase {
Friend función_amiga();
{(sentencias)}//

2. ¿Qué es una clase amiga? Sintaxis

Una clase amiga (friend) es una clase cuyas funciones miembros son funciones miembros de la
clase; esto es, cuyas funciones miembros tienen acceso a otros miembros privados y protegidos de
la clase.

Sintaxis

 Friend <identificador>;

3. Características de la amistad

 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.

4. ¿Qué es sobrecarga de operadores? Sintáxis. Ejemplo

Se llama sobrecarga de operadores cuando reutilizando el mismo operador con un número de

usos diferentes, y el compilador decide como usar ese operador dependiendo sobre qué opera.

Sintaxis

 tipo operator + (lista de parámetros);

sintaxis para clases

 tipo nombre_clase::operator + (lista de parámetros);

Ejemplo

#include <iostream>

using namespace std;

//definicion de la clase Numero

class Numero

friend ostream& operator<<(ostream&salida , const Numero&a);

friend istream& operator>>(istream&salida, Numero &a);

friend Numero operator+(const Numero &a,const Numero &b);

friend Numero operator-(const Numero &a,const Numero &b);

friend Numero operator/(const Numero &a,const Numero &b);

friend Numero operator*(const Numero &a,const Numero &b);

public:

Numero(double x = 0);

void establecer(double x);

private:

double x;

};

//Constructor

Numero::Numero(double b)

{establecer( b );}

void Numero::establecer(double a)

{x = a;}

//Sobrecarga de operadores, mediante funciones friend

Numero operator+(const Numero &a ,const Numero &b) {

 Numero temporal;

temporal.x = a.x + b.x;

return temporal;

Numero operator-(const Numero &a ,const Numero &b) {

Numero temporal;

temporal.x = a.x - b.x;

return temporal;

Numero operator/(const Numero &a ,const Numero &b) {

if (b.x == 0){

cout << "error de division por 0. Detiene ejecucion." << endl;

exit(1);

Numero temporal;

temporal.x = a.x / b.x;

return temporal;

Numero operator*(const Numero &a ,const Numero &b) {

Numero temporal;

temporal.x = a.x * b.x;

return temporal;

ostream &operator<<(ostream& salida , const Numero& a){

salida << a.x ;

return salida;

istream &operator>>(istream& entrada, Numero & a){

entrada >> a.x;

 return entrada;

//Probamos la clase.

int main()

cout << "Tres numeros porfa: " << endl;

Numero A;

cin >> A;

Numero B;

cin >> B;

Numero C;

cin >> C;

cout << "A = " << A << ", B = " << B << ", C = " << C << endl;

Numero resultado;

resultado = A - B + C;

cout << "Resultado = A - B + C = " << resultado << endl;

resultado = A / B ;

cout << "Resultado = A / B = " << resultado << endl;

resultado = A * resultado;

cout << "Resultado = A * resultado = " << resultado << endl;

resultado = B * resultado / A;

cout << "Resultado = B * resultado / A = " << resultado << endl;

return 0;

}
5. ¿Porque surge la necesidad de sobrecarga un operador o una función?

Porque permite que puedan aceptar otro tipo de operandos (distintos de los tipos básicos) y seguir
otro comportamiento, al tiempo que conservan el sentido y comportamiento originales cuando se
usan con los operandos normales.

6. ¿Qué es una plantilla?

Una plantilla es una manera especial de escribir funciones y clases para que estas puedan ser
usadas con cualquier tipo de dato, similar a la sobrecarga, en el caso de las funciones, pero
evitando el trabajo de escribir cada versión de la función.

7. Tipos de plantillas.

Plantillas de función:

Es un modelo de función que el compilador de C++ usará para construir diferentes versiones de
una misma función, según los tipos de datos que se especifique al invocar la misma.

Plantillas de clases:

El sistema de plantillas nos permite definir una clase genérica que permita crear espelizaciones o
instancias de dicha plantilla para cualquier tipo especificado por un parámetro.

Plantillas en C++:

 la STL (standard template library) viene por defecto en los compiladores C++. Esta
biblioteca incluye un juego de contenedores genéricos especialmente: vectores y listas
encadenadas.
 La BGL (Bosst Graph Lybrary) proporciona clases de grafo genéricos y los algoritmos
correspondientes (algoritmo del camino más corto, algoritmo de flot..).

8. Sintáxis de plantilla para función. Ejemplo

Sintaxis

// Para una función, ambas opciones son equivalentes

template <class identificador> definición_de_función;

template <typename identificador> definición_de_función;

Ejemplo

template <class tipo>

tipo mayor(tipo dato1, tipo dato2){

 return (dato1 > dato2 ? dato1 : dato2);

int main(){

int a = 1, b = 2, n;

float c = 1.0, d = 0.5, m;

n = mayor <int> (a,b); // Usando enteros

m = mayor(c,d); // Usando reales

cout << "Entero mayor: " << n << endl;

cout << "Real mayor: " << m << endl;

return 0;

9. Sintáxis de pantilla de clases.Ejemplo

Sintaxis

template <class identificador> definición_de_clase;

// Para las funciones miembro definidas fuera de la clase
template <class identificador>
tipo_retorno nombre_clase<identificador>::nombre_función(argumentos){
// implementación
}

Ejemplo

template <class T> //identificador de tipo: T

class Coordenada{
private:

T x; //atributos de tipo T

T y;

public:

Coordenada(T x=0, T y=0); //parámetros de tipo T

T dameX(){return x};

T dameY(){return y}; //retorna un tipo T

void nuevoX(T x){this -> x = x};

void nuevoY(T y){this -> y = y};

template <class T>

Coordenada<T>::Coordenada(T x, T y){

this -> x = x;

this -> y = y;

Con esta clase podemos instanciar objetos que representan coordenadas de cualquier tipo de
dato, por ejemplo:

// Una coordenada de enteros

Coordenada <int> c1(1,2);

// Una coordenada de reales

Coordenada <float> c2(1.5, 0.5);

Para el caso de las clases, sí es necesario especificar explícitamente el tipo:

nombre_clase <tipo_dato> nombre_objeto(argumentos_constructor);

10. Ventajas de utilizar plantillas.

Las plantillas nos permiten parametrizar estas clases para adaptarlas a cualquier tipo de dato.

En el caso de las clases, ya que no se permite hacer sobrecarga de ellas y tendríamos que
decidirnos por una sola o hacer especializaciones usando la herencia, y al usar plantillas nos
evitamos de esto.