Unidad I – Programación Orientada a Objetos en C++

Polimorfismo en C++
Programación I - 0416202
 Polimorfismo
Contenido

Esta lección abarca los siguientes temas:

 Polimorfismo
 Sobrecarga de métodos
 Sobrecarga de operadores
 Basado en herencia
 Clases abstractas
 Type ID
 Números aleatorios
 Polimorfismo
Polimorfismo
 El polimorfismo se refiere a la propiedad por la que es posible
enviar mensajes sintácticamente iguales a objetos de tipos
distintos. El único requisito que deben cumplir los objetos que
se utilizan de manera polimórfica es saber responder al
mensaje que se les envía.
Equipo Encender
Energizado Apagar
 Polimorfismo
Polimorfismo
 El polimorfismo en en C++, puede ser usado de tres maneras
fundamentales:

 Polimorfismo en sobrecarga de Métodos.

 Polimorfismo en sobrecarga de operadores.
 Polimorfismo basado en la Herencia
 Polimorfismo
Sobrecarga de métodos
 Una de las formas que utiliza C++ para obtener el polimorfismo
es a través de la sobrecarga de funciones.

 Permite que dos o más funciones compartan el mismo nombre

siempre que la declaración de sus parámetros sea diferente.

 El compilador sabe distinguir el tipo de función a utilizar según

sea el tipo de dato enviado en el argumento de la llamada de
la función.
 Polimorfismo
Sobrecarga de métodos
class trabajador{
char nombre[40];
long numero;
float sueldo;
public:
void leer(char * cad, char *c);
void leer(char * cad, long *l);
void leer(char * cad, float *f);
void set_nom(char *c){strcpy(nombre,c);}
void set_num(long l){numero=l;}
void set_sue(float s){sueldo=s;}
};

void trabajador::leer(char *cad, char *n)

{ cout<<cad;
cin>>n; }
void trabajador::leer(char *cad, long *l)
{ cout<<cad;
cin>>*l; }
void trabajador::leer(char *cad, float *s)
{ cout<<cad;
cin>>*s; }
Polimorfismo
Sobrecarga de métodos

void main (void){

char n[40];
long l;
float s;
trabajador T;
T.leer(“Ingrese una cadena de caracteres”, n);
T.set_nom(n);
T.leer(“Ingrese un numero largo”,&l);
T.set_num(l);
T.leer(“Ingrese un numero flotante”,&s);
T.set_sue(s);
}
 Polimorfismo
Sobrecarga de constructores
libro::libro(){
strcpy(titulo, “”);
strcpy(autor, “”);
nro_ejemplares=0;
class libro{ }
char titulo[50]; libro::libro(char * t, char * a, int n){
char autor[40]; strcpy(titulo, t);
int nro_ejemplares; strcpy(autor, a);
public: nro_ejemplares=n;
libro(); }
libro(char * t, char * a, int n);
libro::libro(int n){
libro(int n);
nro_ejemplares=n;
void mostrar();
}
};
void libro::mostrar(){
cout<<“\nLibro: ”<<titulo;
cout<<“\nAutor: ”<<autor;
cout << “\nCantidad de ejemplares:”
<< nro_ejemplares;
}
 Polimorfismo
Sobrecarga de constructores
void main(){
libro a; Objeto a
cout<<“\nObjeto a”; Libro:
Autor:
a.mostrar();
Cantidad de ejemplares: 0

libro b(“Programacion en C++”, ”Luis Joyanes Aguilar”, 5);

cout<<“\n\nObjeto b”;
b.mostrar(); Objeto b
Libro: Programacion en C++
Autor: Luis Joyanes Aguilar
Cantidad de ejemplares: 5

libro c(3);
Objeto c
cout<<“\n\nObjeto c”;
Libro:
c.mostrar();
Autor:
Cantidad de ejemplares: 3
getch();
}
 Polimorfismo
Sobrecarga de operadores
 La sobrecarga de operadores es el proceso de cambiar el
significado de un operador para su uso con objetos de una
clase específica.

 Cuando se sobrecarga un operador, se específica una función

que C++ invoca cada vez que la clase utiliza el operador
sobrecargado.

 Los operadores se pueden sobrecargar escribiendo una

definición de función (con encabezado y cuerpo), excepto que
ahora el nombre de la función es la palabra reservada
operator, seguida del símbolo del operador que se desea
sobrecargar.
 Polimorfismo
Sobrecarga de operadores
 Un ejemplo recientemente utilizado es con los operadores >> y
<<, que además de ser usados por C++ para desplazamiento de
bits también permiten realizar operaciones de E/S por consola.
Esto es posible porque en la librería iostream.h, estos
operadores son sobrecargados.

 Los operadores sobrecargados toman un significado adicional

para la clase con la que está directamente relacionada y
además, sigue teniendo todos sus significados anteriores.
 Polimorfismo
Sobrecarga de operadores
 C++ permite cambiar el significado de la mayoría de los
operadores básicos como + - * / =
 Sin embargo C++ solo permite este cambio si los “operandos”
no son tipos básicos (int, float, double, etc), sino que son
objetos de clases creadas por nosotros
 Por ejemplo, imagine que tenemos dos objetos de una clase
Trabajador y queremos sumarlos.

Trabajador obj1, obj2

obj1+obj2

 Para poder realizar la operación anterior, tendríamos que

sobrecargar el operador + porque éste solo suma números y
strings.
Polimorfismo
Sobrecarga de operadores

class trabajador{
char nombre[40];
int edad;
float sueldo;
public:
//Constructores
trabajador();
trabajador(char * n, int e, float s);

//Función que sobrecarga el operador +

trabajador operator+ (trabajador obj);

//Otras funciones miembro

void mostrar();
};
 Polimorfismo
Sobrecarga de operadores

trabajador::trabajador(){ }
trabajador::trabajador(char * n, int e, float s){
strcpy(nombre,n);
edad=e;
sueldo=s;
}
trabajador trabajador::operator+ (trabajador obj){
trabajador obj_aux; sueldo, edad y nombre son
los atributos del objeto que
obj_aux.sueldo = sueldo + obj.sueldo;
invoca
obj_aux.edad = edad + obj.edad;
strcpy(obj_aux.nombre, strcat(nombre, obj.nombre));
return obj_aux;
}
void trabajador::mostrar(){
cout<<“\nNombre: ”<<nombre;
cout<<“\nEdad: ”<<edad;
cout<<“\nSueldo: ”<<sueldo;
}
Polimorfismo
Sobrecarga de operadores

void main(){
trabajador obj1(“Luis”, 36, 700);
trabajador obj2(“Ana”, 30, 900);

obj1 = obj1 + obj2;

Objeto Objeto
que que
invoca Se envía
como
argumento

obj1.mostrar();
getch(); Nombre: LuisAna
} Edad: 66
Sueldo: 1600
 Polimorfismo
Basado en Herencia
 En POO, el polimorfismo permite que diferentes objetos
respondan de modo diferente al mismo mensaje (invocación
de método).
 El polimorfismo adquiere su máxima potencia cuando se utiliza
en unión de la herencia.
 El polimorfismo en C++ se ejecuta utilizando funciones
virtuales.

 Existen dos formas de trabajar con funciones virtuales

 Funciones virtuales puras
 Funciones virtuales normales
 Polimorfismo
Basado en Herencia

Reglas para usar polimorfismo en C++

 Crear una jerarquía de clases en donde las operaciones

importantes se definan en funciones miembros declaradas
como virtuales en las clases base pero sin implementación
alguna.

 Implementar las funciones virtuales en las clases derivadas.

Cada clase derivada puede tener su propia versión de las
funciones.

 Las instancias de éstas clases se manipulan a través de

punteros.
 Polimorfismo
Basado en Herencia

Funciones virtuales puras

 Cuando una función virtual es pura, el método de la clase

madre se convierte en un método abstracto, por lo que la clase
se hace abstracta, y solo se puede implementar en las clases
hijas.

 Para hacer una función virtual pura se coloca

virtual void nombrefuncion() =0;

 Polimorfismo
Basado en Herencia

Funciones virtuales normales

 Cuando una función virtual es normal, el método de la clase

madre se puede sobre escribir en las clases hijas (No hay clases
abstractas)

 Para hacer una función virtual se coloca

virtual void nombrefuncion();

Polimorfismo
Basado en Herencia

#include <iostream>
#include <cstring>
class Jugador{
char nombre[40];
char equipo[40] ;
float average;
public:
//Constructores
Jugador();
Jugador(char * n, char * e);

//Función virtual
virtual void calcular_average();

//Otras funciones miembro

void setAverage(float a);
};
 Polimorfismo
Basado en Herencia
Jugador::Jugador(){
strcpy(nombre, ” ”);
strcpy(equipo, ” ”);
average = 0.0;
}

Jugador::Jugador(char * n, char * e){ En la clase base, la función virtual se

strcpy(nombre, n); puede implementar pero no se le
strcpy(equipo, e); coloca la palabra virtual.
average = 0.0;
}

void Jugador::calcular_average(){
cout<<“\nCalcular_average de Jugador”<<endl;
}

void Jugador::setAverage(float a){

average = a;
}
Polimorfismo
Basado en Herencia

class Bateador: public Jugador{

int nro_veces_bate;
int nro_boletos_recibidos;
int nro_hits;
public:
//Constructores
Bateador();
Bateador(char * n, char * e, int v, int b, int h);

//Sobreescritura de la funcion virtual

virtual void calcular_average();
};
 Polimorfismo
Basado en Herencia
Bateador::Bateador() : Juagador(){
nro_veces_bate=0;
nro_boletos_recibidos=0;
nro_hits=0;
}

Bateador::Bateador(char * n, char * e, int v, int b, int h ) : Jugador(n, e){

nro_veces_bate = v;
nro_boletos_recibidos = b;
nro_hits = h;
}

void Bateador::calcular_average(){
float x;
x = (float) nro_hits / (nro_veces_bate – nro_boletos_recibidos) * 1000;
set_average(x);
cout<<“\nEl average del Bateador fue: ”<<x;
//Si necesita ejecutar calcular_average de la clase Padre (Jugador)
Jugador::calcular_average();
}
 Polimorfismo
Basado en Herencia

void main(){

Jugador a(“Robert Perez”, ”Cardenales”);

Bateador b(“Cesar Isturiz”, ”Cardenales”, 50, 8, 17);
Jugador *p;

p=&a;
Calcular average de Jugador
p->calcular_average();

p=&b; El average del Bateador fue: 404.762

p->calcular_average(); Calcula average de Jugador

cout<<“\n\nPresione una tecla para continuar”<<endl;

getch();
}
 Polimorfismo
Basado en Herencia

void main(){

Jugador * vector[]={new Jugador("Robert Perez", "Cardenales"),

new Bateador("Cesar Isturiz", "Cardenales",
50, 8, 17) };

vector[0]->calcular_average(); Calcular average de Jugador

vector[1]->calcular_average();
El average del Bateador fue: 404.762
Calcula average de Jugador
cin.get();
}
 Polimorfismo
Clases abstractas
 Una clase con funciones virtuales se hace abstracta al declarar
una o más de sus funciones virtuales como puras.

 Una función virtual pura es aquella que en su declaración

contiene un inicializador de = 0.

 Cuando una clase contiene por lo menos una función virtual

pura automáticamente se convierte en clase abstracta y la
función virtual pura pasa a ser un método abstracto, es decir,
que no tiene implementación y debe ser redefinido o
implementado en las clases hijas.

 No se pueden crear instancias de una clase abstracta.

 Polimorfismo
Clases abstractas
#include “iostream.h”
#include “conio.h”
No debe tener
#include “math.h”
implementación en Figura
class Figura{
int x,y;
public:
Figura(){x=0; y=0; } //Constructor
//Función virtual pura ó método abstracto
virtual void calcular_area() = 0;
};

class Circulo: public Figura{

float radio;
public:
Circulo(){radio=2; } //Constructor
//Implementación de la función virtual pura heredada
void calcular_area();
};
void Circulo::calcular_area(){
float area= (float) 3.14 * pow(radio,2)/2;
cout << “\nEl area es: ” << area;
}
Polimorfismo
Clases abstractas

void main(){
Figura obj; //Error

Circulo obj;
obj.calcular_area(); El area es: 6.28

getch();
}
 Polimorfismo
TypeID
 La palabra clave typeid identifica un operador con el que
puede obtenerse el tipo de objetos y expresiones en tiempo de
ejecución.

 Permite comprobar si un objeto es de un tipo particular, y si

dos objetos son del mismo tipo.

typeid( expresion )
typeid( nombre-de-tipo )

typeid(Clase).name();

typeid(Obj1)==typeid(Obj2) //comparación de los tipos

//de objetos
 Polimorfismo
TypeID
#include <iostream>
class Base {
public:
virtual void vvfunc() {}
};
class Derived : public Base {};
int main() {

Base* pb[5] ;
pb[0]=new Base;
pb[1]=new Derived;
pb[2]=new Base;
pb[3]=new Derived;
pb[4]=new Derived;
for(int i=0;i<5;i++)
if(typeid( *pb[i] )==typeid(Derived))
cout <<"Objeto "<<i<<"= "<< typeid( *pb[i] ).name()
<< endl;
system("PAUSE");
delete []pb;
return 0;}
 Polimorfismo
Números aleatorios
 Para generar números aleatorios se utiliza la función rand(),
incluida en la librería <stdlib.h>.

 Retorna un numero entero pseudo-aleatorio mayor igual a 0.

 Este número es generado por un algoritmo que retorna una

sequencia de “aparentemente” números no relacionados cada
vez que es llamada. Este algoritmo usa una “semilla” para
generar la serie, el cual debe ser inicializada en distintos
valores usando la función srand().

rand()% limite_superior + límite_inferior

Ejemplo: rand()%100+1; //números del 1 al 100

 Polimorfismo
Números aleatorios
#include <iostream>
#include <time.h>
#include <stdlib.h>
using namespace std;

int main(){
int iSecreto, iAdivino;
srand (time(NULL)); //Inicializa la semilla con tiempo actual

iSecreto = rand() % 10 + 1; //genera numero secreto entre 1 y 10

do {
cout << “Adivine un numero entre (1 a 10): ";
cin >> iAdivino ;
if (iSecreto<iAdivino)
cout << “El numero secreto es mas bajo“ << endl;
else if (iSecreto>iAdivino)
cout << "El numero secreto es mas alto“ << endl;
} while (iSecreto!=iAdivino);

cout << “Felicitaciones!";

return 0;
}