Polimorfismo2015c1

Introducción Herencia Funciones virtuales Objetos dinámicos Más sobre polimorfismo
Polimorfismo
Programación Avanzada
30 de marzo de 2015

Contenido
Introducción
Definición de Polimorfismo
Polimorfismo en C++
Ejemplo de jugete
Herencia
Upcasting
Funciones virtuales
Clases abstractas
Tabla de métodos virtuales
Objetos dinámicos
Más sobre polimorfismo
Constructores y destructores
Downcasting
Polimorfismo y contenedoras

¿Qué es el Polimorfismo?
• Permite escribir programas de manera general,
manipulando clases existentes y otras aún por especificar

• Otras deﬁniciones:

• Dos o m´as objetos de una misma clase se comportan de
formas diferentes.

formas diferentes.
• Una variable puede tomar diferentes tipos, dependiendo de
la necesidad en tiempo de ejecuci´on.

formas diferentes.
• Una variable puede tomar diferentes tipos, dependiendo de
la necesidad en tiempo de ejecuci´on.
• Un puntero a un objeto de la superclase puede ser
instanciado como cualquiera de sus clases descendientes.

Mecanismo necesarios
• Para realizar polimorﬁsmo en C++ es necesario:

• Herencia.

• Herencia.
• Funciones virtuales.

• Herencia.
• Funciones virtuales.
• Objetos din´amicos.

Ejemplo de jugete
Modelado de una Orquesta

Ejemplo de jugete
Modelado de una Orquesta
Se desea modelar Orquesta en la cual el usuario del programa
tenga el control de crear varios tipos de instrumentos y cuantos
desee. Adem´as, el usuario puede elegir que puedan aﬁnarse o
bien ejecutar determinado conjunto de notas.

Herencia
• Es una forma de reutilizar c´odigo.

Herencia
• Permite crear clases (derivadas o hijas) a partir de otras
clases (bases o madres).

Herencia
clases (bases o madres). Estas nuevas clases incluyen las
caracter´ısticas de la clase ancestra m´as las propias.

Herencia
• ¿Qu´e se hereda de la clase base?

Herencia
• En principio, todo. Excepto:

Herencia
• El constructor y destructor de la clase base.

Herencia
• El operador = de la clase base.

Herencia
• El operador = de la clase base.
• Las funciones y clases amigas de la clase base.

Herencia
Ejemplo de jugete

Herencia
Ejemplo de jugete
• Se tienen instrumentos de los cuales se requiere que
ejecuten notas.

Herencia
Ejemplo de jugete
• Se tienen instrumentos de los cuales se requiere que
ejecuten notas.
• Supongamos, un Violin.

Herencia
Sintaxis
1 class nombre_clase_derivada: public nombre_clase_base { /*...*/ };

Herencia
Sintaxis
1 class nombre_clase_derivada: public nombre_clase_base { /*...*/ };
2 // Ejemplo:
3 class Violin: public Instrumento { /* ... */};

Upcasting
1 class Instrumento {
2 public:
3 void ejecutar() {cout << "Inst::ejecutar";};
4 string nombre() {return "Instrumento";};
5 };

Upcasting
2 public:
5 };
6 class Piano : public Instrumento {
7 public:
8 void ejecutar() {cout << "Piano::ejecutar";};
9 string nombre() {return "Piano";};
10 };

Upcasting
2 public:
5 };
7 public:
10 };
11 class Violin : public Instrumento {
12 public:
13 void ejecutar() {cout << "Violin::ejecutar";};
14 string nombre() {return "Violin";} ;
15 };

Upcasting
2 public:
5 };
7 public:
10 };
12 public:
15 };
16 void afinar(Instrumento& i) {
17 // ...
18 i.ejecutar();
19 }

Upcasting
2 public:
5 };
7 public:
10 };
12 public:
15 };
17 // ...
18 i.ejecutar();
19 }
20 int main(){
21 Violin v;

Upcasting
2 public:
5 };
7 public:
10 };
12 public:
15 };
17 // ...
18 i.ejecutar();
19 }
20 int main(){
21 Violin v;
22 afinar(v); // Upcasting
23 return(0);
24 }

Upcasting
• Con el upcasting le puedo asignar a un puntero de la clase
base, un puntero o direcci´on de un objeto hijo.

Upcasting
• Sin embargo, la funci´on aﬁnar de la clase Instrumento
muestra: Inst::ejecutar.

Upcasting
• ¿Por qu´e sucede esto?

Upcasting
• Encadenamiento temprano.

Upcasting
• Encadenamiento tard´ıo:

Upcasting
• Encadenamiento tard´ıo: Funciones virtuales.

Upcasting
• Encadenamiento tard´ıo: Funciones virtuales.
• Cuando se utiliza upcasting se debe tener en cuenta que
sólo es posible invocar a los métodos definidos en la clase
madre.

Upcasting
• Otro ejemplo para analizar:

Upcasting
1 int main()
2 {
3 Instrumento i; Violin v;
4 cout <<"Caso Mixton";
5 Instrumento *pi;
6 pi=&v;
7 pi->ejecutar();

Upcasting
1 int main()
2 {
5 Instrumento *pi;
6 pi=&v;
7 pi->ejecutar();
8
9 cout <<"Caso contra Mixton";
10 Violin *pv;
11 pv = &i;
12 pv->ejecutar();
13 return 0;}

Upcasting
1 int main()
2 {
5 Instrumento *pi;
6 pi=&v;
7 pi->ejecutar();
8
10 Violin *pv;
11 pv = &i;
12 pv->ejecutar();
13 return 0;}
• Salida Caso Mixto

Upcasting
1 int main()
2 {
5 Instrumento *pi;
6 pi=&v;
7 pi->ejecutar();
8
10 Violin *pv;
11 pv = &i;
12 pv->ejecutar();
13 return 0;}
• Salida Caso Mixto Instrumento::ejecutar

Upcasting
1 int main()
2 {
5 Instrumento *pi;
6 pi=&v;
7 pi->ejecutar();
8
10 Violin *pv;
11 pv = &i;
12 pv->ejecutar();
13 return 0;}
• Salida Caso contra Mixto

Upcasting
1 int main()
2 {
5 Instrumento *pi;
6 pi=&v;
7 pi->ejecutar();
8
10 Violin *pv;
11 pv = &i;
12 pv->ejecutar();
13 return 0;}
• Salida Caso contra Mixto ERROR: NO PUEDE
REALIZARSE LA CONVERSI ´ON

Funciones virtuales
• Son métodos miembros que están definidos en la clase
base, y se redefinirán en las clases descendientes

Funciones virtuales
• Si un método miembro se define como virtual en alguna de
las clases de una jerarqu´ıa, automáticamente pasa a ser
virtual en todas las clases de dicha jerarqu´ıa.

Funciones virtuales
• Si un método miembro se define como virtual en alguna de
las clases de una jerarqu´ıa, automáticamente pasa a ser
virtual en todas las clases de dicha jerarqu´ıa.
• En el ejemplo planteado, notar que es posible
independizarse del instrumento en colaborar de
responsabilidades. En esta caso, ejecutar notas.

Funciones virtuales
2 public:
3 virtual void ejecutar() {cout << "Inst::ejecutar";};
4 virtual string nombre() {return "Instrumento";};
5 };

Funciones virtuales
2 public:
5 };
7 public:
10 };

Funciones virtuales
2 public:
5 };
7 public:
10 };
12 public:
15 };

Funciones virtuales
2 public:
5 };
7 public:
10 };
12 public:
15 };
17 // ...
18 i.ejecutar();
19 // ...
20 }

Funciones virtuales
2 public:
5 };
7 public:
10 };
12 public:
15 };
17 // ...
18 i.ejecutar();
19 // ...
20 }
21 int main(){
22 Violin v;

Funciones virtuales
2 public:
5 };
7 public:
10 };
12 public:
15 };
17 // ...
18 i.ejecutar();
19 // ...
20 }
21 int main(){
22 Violin v;
23 afinar(v); // Upcasting
24 return(0);
25 }

Funciones virtuales
• Analicemos otra situaci´on:

Funciones virtuales
1 int main(){
2 cout << "Caso Violinn";
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
6 cout <<"Caso del Instrumenton";
7 Instrumento i,
8 Instrumento *pi=&i;
9 pi->ejecutar();

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
7 Instrumento i,
9 pi->ejecutar();
11 Instrumento *pi_2
12 pi_2=&v;
13 pi_2->ejecutar();
14 return(0);
15 }
• Salida Caso del Violin:

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
7 Instrumento i,
9 pi->ejecutar();
12 pi_2=&v;
14 return(0);
15 }
• Salida Caso del Violin: Violin::ejecutar

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
7 Instrumento i,
9 pi->ejecutar();
12 pi_2=&v;
14 return(0);
15 }
• Salida Caso del Instrumento:

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
7 Instrumento i,
9 pi->ejecutar();
12 pi_2=&v;
14 return(0);
15 }
• Salida Caso del Instrumento: Instrumento::ejecutar

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
7 Instrumento i,
9 pi->ejecutar();
12 pi_2=&v;
14 return(0);
15 }
• Salida Caso Mixto:

Funciones virtuales
1 int main(){
3 Violin v,
4 Violin *pv=&v;
5 pv->ejecutar();
7 Instrumento i,
9 pi->ejecutar();
12 pi_2=&v;
14 return(0);
15 }
• Salida Caso Mixto: Violin::ejecutar

Clases abstractas
• Los métodos virtuales puros no tienen definición.

Clases abstractas
• Una clase con al menos un m´etodo virtual puro es una
clase abstracta.

Clases abstractas
• Una clase con al menos un m´etodo virtual puro es una
clase abstracta.
2 public:
3 virtual void ejecutar() = 0;
4 virtual string nombre() = 0;
5 };
7 public:
10 };
12 public:
13 void ejecutar() {cout << "Violin::ejecutar";}
14 string nombre() {return "Violin";}
15 };

Clases abstractas
• Las clases abstractas son aquellas en las que al menos
uno de sus miembros es virtual puro.

Clases abstractas
• Cuando todos los miembros son virtuales puros se habla
de clases abstractas genuinas.

Clases abstractas
• Las clases abstractas no pueden instanciarse, pues
tampoco tiene sentido hacerlo.

Clases abstractas
• Las clases abstractas no pueden instanciarse, pues
tampoco tiene sentido hacerlo.
• Ahora Instrumento es una clase abstracta genuina.

• El compilador crea una tabla de métodos virtuales
(VTABLE) para cada clase, que será usada durante la
ejecución del programa.

• El compilador ubica en esta VTABLE las funciones
virtuales de cada clase.

• El compilador tambi´en agrega a cada clase un puntero
(VPTR), que apunta a cada VTABLE correspondiente.

• Cuando se invoca a un método virtual a través de un
puntero de la clase base, el compilador inserta código
para determinar qué VPTR realizó la llamada y busca la
dirección de la función en la VTABLE

• Cuando se invoca a un método virtual a través de un
puntero de la clase base, el compilador inserta código
para determinar qué VPTR realizó la llamada y busca la
dirección de la función en la VTABLE
• Ahora creando los objetos en forma dinámica, resolvemos
el problema originalmente planteado.

Objetos din´amicos
• Dada dos instrumentos, un Piano y un Viol´ın

Objetos dinámicos
• Dada dos instrumentos, un Piano y un Viol´ın
• ¿Cómo hacemos para decidir en tiempo de ejecución que
tipo de instrumento quiero que toque una nota?

Objetos din´amicos
• Una forma ser´ıa la siguiente:

Objetos din´amicos
1 switch(opcion){
2 caso 1:
3 Creo un Piano
4 Lo hago Tocar
5 caso 2:
6 Creo un Violin
7 Lo hago Tocar
8 }

Objetos din´amicos
1 switch(opcion){
2 caso 1:
3 Creo un Piano
4 Lo hago Tocar
5 caso 2:
6 Creo un Violin
7 Lo hago Tocar
8 }
• Otra forma:

Objetos din´amicos
1 switch(opcion){
2 caso 1:
3 Creo un Piano
4 Lo hago Tocar
5 caso 2:
6 Creo un Violin
7 Lo hago Tocar
8 }
• Otra forma:
1 switch(opcion){
2 caso 1:
3 Creo un Piano
4 caso 2:
5 Creo un Violin
6 }
7 Hago tocar el INSTRUMENTO

Objetos dinámicos
• Por lo tanto necesitamos asignación dinámica de memoria

Objetos din´amicos
• Para referirnos a un objeto din´amico utilizamos un puntero
a su instancia. Por ejemplo:

Objetos din´amicos
• Para referirnos a un objeto din´amico utilizamos un puntero
a su instancia. Por ejemplo:
1 Piano * p;
2 //...
3 p->ejecutar();
4 cout << p->nombre() << endl;
5 //...

Objetos din´amicos
• Para crear un objeto en tiempo de ejecuci´on es necesario
utilizar el operador new. Por ejemplo:

Objetos din´amicos
• Para crear un objeto en tiempo de ejecuci´on es necesario
utilizar el operador new. Por ejemplo:
1 Piano * p;
2 p=new Piano;
3 p->ejecutar();
5 //...

Objetos din´amicos
• Para destruir un objeto din´amico utilizamos el operador
delete. Por ejemplo:

Objetos din´amicos
• Para destruir un objeto din´amico utilizamos el operador
delete. Por ejemplo:
1 Piano * p;
2 p=new Piano;
3 p->ejecutar();
5 delete p;

Objetos dinámicos
• Creación de un objeto dinámico a partir de un puntero a la
clase base

Objetos dinámicos
• Creación de un objeto dinámico a partir de un puntero a la
clase base
1 Instrumento * p;
2 p=new Piano;
3 p->ejecutar();
5 delete p;

2 public:
3 Instrumento() {
4 cout << "Constructor de Instrumento" << endl;};
5 virtual void ejecutar(nota) =0;
6 virtual string nombre() =0;
7 virtual ˜Instrumento() {
8 cout << "Destructor de Instrumento" << endl;};
9 };

2 public:
3 Instrumento() {
9 };
• Los constructores no pueden ser virtuales.

2 public:
3 Instrumento() {
9 };
• Los destructores pueden y deben ser virtuales

2 public:
3 Instrumento() {
9 };
• Los destructores pueden y deben ser virtuales¿Por qu´e?

1 int main(){
2 Instrumento *I;
3 I= new Piano;
4 /*...*/

1 int main(){
2 Instrumento *I;
3 I= new Piano;
4 /*...*/
5 delete I;
6 return 0;}
• Siempre se conoce al objeto que se desea crear.

1 int main(){
2 Instrumento *I;
3 I= new Piano;
4 /*...*/
5 delete I;
6 return 0;}
• Siempre se conoce al objeto que se desea crear.
• Sin embargo, no se sabe cual es el objeto que se destruye
dado que estamos referenciado un ancestro.

Downcasting
2 public:
3 void ejecutar();
4 string nombre();
5 void CambiarCuerdas()
6 { cout << "Cambio de cuerdas" << endl; }
7 };

Downcasting
2 public:
3 void ejecutar();
4 string nombre();
5 void CambiarCuerdas()
6 { cout << "Cambio de cuerdas" << endl; }
7 };
8
9 int main()
10 {Instrumento *i = new Violin;
11 i->CambiarCuerdas();
12 return 0;
13 }
• No se puede acceder dado que CambiarCuerdas() no es
un miembro de Instrumento

Downcasting
1 int main()
3 /* ... */
4 Violin *v;

Downcasting
1 int main()
3 /* ... */
4 Violin *v;
5 v=(Violin*) i;// downcasting
6 v->CambiarCuerdas();
7 return 0;
8 }

• ¿C´omo podr´ıamos simular una orquesta formada por una
arreglo de instrumentos?

• Necesitaremos una lista de punteros a Instrumento
1 vector<Instrumento*> orquesta;
2 //new...

2 //new...
• ¿Cuál es la ventaja de que sean polimórficos?

2 //new...
• ¿Cuál es la ventaja de que sean polimórficos?
1 for (int i=0;i<orquesta.size();i++)
2 cout << orquesta[i]->ejecutar();
3 //delete...

Polimorfismo2015c1

Más contenido relacionado

Destacado

Similar a Polimorfismo2015c1

Último

Polimorfismo2015c1