Polimorfismo en C++: Teoría y Práctica

Resumen

En esta clase vamos a aprender qué es el Polimorfismo, cómo funciona y qué ventajas obtenemos al usarlo. Nuestra profesora es Eri Dorado, programadora de videojuegos para diferentes plataformas en HyperBeard Games.

El polimorfismo es una característica de la programación orientada a objetos donde los objetos pueden tomar la forma de las clases que heredaron, las clases hijas pueden comportarse como sus clases padres cuando heredan de ellas.

C++ es un lenguaje de programación muy parecido a C pero con todas las características de la programación orientada a objetos. Es usado por muchas aplicaciones que tienen como prioridad la optimización de recursos sin dejar de ser escalables, modulares y distribuidas por varias plataformas. C++ es muy veloz porque nos permite hacer un buen manejo de la memoria sin necesidad de máquinas virtuales ni recolectores de basura. Además, es un lenguaje complejo, tiene una gran cantidad de librerías y es constantemente actualizado.

David Santiago González Ramos

student•

Quizas en el ejemplo no se vea tan clara la utilidad, o la diferencia a estar haciendo algo como Gandalf.GetDamage(1) y desps Dumbledore.GetDamage(5) Pero piensen que usandolos a ambos como mago, podemos crear un ciclo e iterar en nuestros magos y (ejemplo) hacer que todos ataquen, sin tener que llamarlos uno por uno y gracias al polimorfismo, cada mago según su tipo va a tener un ataque diferente a pesar de que el método Attack() se declare igual para todos...no sé si fui claro🙈✌

Ian Vassallo

student•

Es lo que estaba pensando.

Al declarar las variables, los hijos funcionan perfectamente para establecer "en este ejemplo" los tipos de vida, atk, y más. Para cuando ya se establezcan sus estadísticas se volverán a hacer magos normales con sus funciones/metodos preestablecidos con el polimorfismo.

Christian Picón Calderón

student•

Yo intenté implementar espero sirva de ejemplo para ver la utilidad ( si alguien lo entiende y se anima a comentarlo, sería buen aporte para la comunidad).

#include <iostream>
#include <cstdlib>
#include <string>

using namespace std;

// Las funciones se declaran antes del main

// Void es si la funcion solo imprime datos
void imprimirCosas(){

    printf("Game over....");

}
//Clase padre
class Mage{
public:
    //Constructor
    Mage(int BasePower, int BaseHp, string name)
    {
        Power = BasePower;
        hp = BaseHp;
        Name = name;
    }
    float Damage()
    {
        return Power;
    }
    void GetDamage(int Value)
    {
        hp= hp-Value;
    }
    int life()
    {
        return hp;
    }
    string get_name()
    {
        return Name;
    }
protected:
    int Power, hp;
    string Name;
};

//Clase hija 1
class IceMage : public Mage
{
    public:
    IceMage(int BasePower, int BaseHp, string name) : Mage(BasePower, BaseHp, name)
    {
        Power = BasePower + 1;
        hp = BaseHp +1;
        Name = name;
    }
    int ice_attack(){

        return  (rand() % Power) + 1;
    }
};

//Clase hija 2
class FireMage : public Mage
{
    public:
    FireMage(int BasePower, int BaseHp, string name) : Mage(BasePower, BaseHp, name)
    {
        Power = BasePower;
        hp = BaseHp + 10;
        Name = name;
    }
    int fire_attack(){
        return  (rand() % Power) + 1;
    }
};
int main()
{
    Mage* Current_mage;
    Mage Harry(10, 100, "Harry");
    IceMage Dumbledore(11, 100, "Dumbledore");
    FireMage Gandalf(11,100, "Gandalf");
    //fuck_pointers();
    //imprimirCosas();
    bool chance = true;
    int attack_value;
    for (int i=0;i<10;i++){
        if (chance){
            Current_mage = &Dumbledore;
            attack_value = Dumbledore.ice_attack();
            cout<<" attack :"<<attack_value;
            Current_mage->GetDamage(attack_value);
            cout<<Current_mage->get_name()<<"- current life :"<<Current_mage->life()<<endl;
            chance = false;
        }
        else{
            Current_mage = &Gandalf;
            attack_value = Gandalf.fire_attack();
            cout<<" attack :"<<attack_value;
            Current_mage->GetDamage(attack_value);
            cout<<Current_mage->get_name()<<"- current life :"<<Current_mage->life()<<endl;
            chance = true;
        };
    }
    return 0;
}

lo qu ei

Jose Antonio Rojas Ollarves

student•

Polimorfismo en programacion: Se utiliza cuando una clase herada a otra sus atributos y sus metodos, por ejemplo pasamos a tener la siguientes clases

Explicacion: Tenemos una clase madre, que comparte el atributo del area y el metodo de calcular area, ambas comparten los mismos parametros pero, la funcion de calcular area no se puede hacer igual a la de los demas, con esto tendremos que modificar el bloque de codigo que se encuentra en la funcion calcularArea(). Dicha tecnica se le llama:

Sobre escritura de metodo: Mejor conocido como polimorfismo. La sobreescritura de métodos nos permite redifinir un método que heredamos para que este funcione de acuerdo a nuestras necesidades y no a lo definido en la superclase. Cuando en un objeto llamamos a un método el compilador comprueba si el método existe en nuestro objeto, si existe lo usa y si no existe en nuestro objeto entonces lo busca en la superclase. Esto ocurre así hasta que el compilador encuentra el método definido. El compilador busca el método de abajo a arriba.

Wilmer Gaona Romero

student•

Si, para poder implementarlo es necesario definir a calcularArea() como "virtual" para que al definir un objeto del tipo círculo, sobreescriba a la función correspondiente para calcular el área.

Eduardo Sebastián Sandoval Jiménez

student•

Excelente aporte gracias!!!

Manuel Durán

student•

min 6:45 LMFAO... obvio que todos saben la diferencia entre un mago de hielo y uno de fuego... obvio...

Leandro Ariel Labiano Ramo

student•

El polimorfismo podría comparase con los numeros EL 1 es un numero natural, por lo que puede hacer todas las operaciones comunes de números naturales. Pero el 1 también es un numero entero, por lo que puede hacer todas las operaciones de números enteros. Entonces 1 es tipo Natural y tipo Entero, pudiendo actuar de ambas maneras segun sea conveniente.

GERARDO EMMANUEL ALONSO CELIS

student•

Excelente analogía!

Obed Paz

student•

Veo varios comentarios comentando que no le ven la utilidad al polimorfismo, trataré de explicarlo de forma sencilla:

Verán, la utilidad radica en la capacidad de poder hacer lo mismo que el padre, pero de forma distinta. Es decir, en el ejemplo de la clase, tenemos dos magos, uno de hielo y uno de fuego que heredan de un mago normal. Los magos de hielo y de fuego heredan la acción de ataque de su padre, pero la forma en que lo hacen es diferente. Eso es polimorfismo, poder comportarse igual que su padre (atacar) pero de otro modo (hielo o fuego) y aun así seguir siendo magos.

En resumen: Herencia = Copy Paste Polimorfismo = Editar el copy paste.

Julio Barra

student•

no entendí muy bien la utilidad de para que sirve el polimorfismo:(

David Lache Alvarez

student•

Para que se comporte como el papa, con las propiedades el hijo

Carlos Lefin Henriquez

student•

es como una transformacion... el padre se transforma en sus hijos. pero en este caso es un puntero padre

Alejandro Andrade Soriano

student•

LOL GANO DUMBLEDORE!!

#include <iostream>


using namespace std;


class Wizzard{
  // Base Wizzard
  public:
   
    Wizzard(int base_power, int base_hp, string base_name){
      power = base_power;
      hp = base_hp;
      name = base_name;

    }

    float Damage(){
      return power;

    }

    void GetDamage(int damage_value){
      hp -= damage_value;
      cout << name << " HP: " << hp << endl;
    }

    void Speak(string dialog){
      cout << name << ": " << dialog << endl;
    }

    int GetHp(){
      return hp;
    }

    

  protected:
    float power, hp;
    string name;
};


class FireWizzard:public Wizzard{
  // This wizzard has more power atack but less hp
  public:
    FireWizzard(int base_power, int base_hp, string base_name) : Wizzard(base_power, base_hp, base_name){
      power = base_power + 10;
      hp = base_hp - 30;
      name = base_name;
  }
  
};

class IceWizzard:public Wizzard{
  // This wizzard has more life but less power atack

  public:
    IceWizzard(int base_power, int base_hp, string base_name) : Wizzard(base_power, base_hp, base_name){
      power = base_power - 20;
      hp = base_hp + 20;
      name = base_name;
  }
  
};


int main(){
  // apuntador al wizzard actual.
  Wizzard* current_wizzard;
  // INIT HARRY
  Wizzard Harry(20, 100, "Harry");
  Harry.Speak("Hola bienvenidos al juego.");
  // INIT GANDALF
  IceWizzard Gandalf(20, 100, "Gandalf");
  // INIT DUMBLEDORE 
  FireWizzard Dumbledore(20, 100, "Dumbledore");
  int round = 1;

  // PROCESS FIGHT
  while(Dumbledore.GetHp() > 0 && Gandalf.GetHp() > 0){
    if(round % 2){
      Harry.Speak("Dumbledore Recibe Dano!!");
      current_wizzard = &Dumbledore;
      current_wizzard->GetDamage(Gandalf.Damage());
    }else{
      Harry.Speak("Gandalf Recibe Dano!!");
      current_wizzard = &Gandalf;
      current_wizzard->GetDamage(Dumbledore.Damage());
    }
    cout << "***************************************" << endl;
    ++round;
  }

  // PRINTING WINNWE
  if(Dumbledore.GetHp() < 0){
    Harry.Speak("GANADOR!!! GANDALF");
  }else{
    Harry.Speak("GANADOR!!! DUMBLEDORE");
  }

  return 0;
}

Paulina Yañez Rubio

student•

Este curso es genial, de los que mas he disfrutado! Me fascina como explica y los ejercicios son muy divertidos.

Yasser Pulido

student•

#include <iostream>

using namespace std;

class Mago
{
public:

	Mago(int BasePower, int BaseHP)
	{
		Power = BasePower;
		hp = BaseHP;
	}
	float	Damage()
	{
		return Power;
	}

	void GetDamage(int Value)
	{
		hp -= Value;
		cout << "Le queda: " << hp << endl;
	}

	void PrintHP()
	{
		cout << hp << endl;
	}

	void Spell()
	{
		cout << "Hola mundo";
	}

protected:
	int Power, hp;
};

class MagoHielo : public Mago
{
public:
	MagoHielo(int BasePower, int BaseHP) : Mago(BasePower, BaseHP)
	{
		Power = BasePower;
		hp = BaseHP;
	}
};

class MagoFuego : public Mago
{
public:
	MagoFuego(int BasePower, int BaseHP) : Mago(BasePower, BaseHP)
	{
		Power = BasePower;
		hp = BaseHP + 10;
	}
};

int main()
{
	Mago* MagoActual;

	MagoFuego Gandalf(10,10);
	MagoHielo Saruman(10,10);

	MagoActual = &Gandalf;
	MagoActual->GetDamage(1);

	MagoActual = &Saruman;
	MagoActual->GetDamage(5);

	Gandalf.PrintHP();
	Saruman.PrintHP();
}

Elena Nuñez Malledo

student•

Hecho!!!

#include &lt;iostream&gt;

using namespace std;

class Mage
{
public:
    Mage (int BasePower, int BaseHP)
    {
        Power = BasePower;
        hp = BaseHP;
    }

    float Damage ()
    {
        return Power;
    }

    void GetDamage (int Value)
    {
        hp -= Value;
        cout &lt;&lt; &quot;Mi mago le queda: &quot;&lt;&lt; hp &lt;&lt; endl;
    }

    void PrintHP ()
    {
        cout &lt;&lt; hp &lt;&lt; endl;
    }


protected:

    int Power, hp;

};

class IceMage: public Mage
{
public:
    IceMage (int BasePower, int BaseHP) : Mage (BasePower, BaseHP)
    {
        Power = BasePower + 1;
        hp = BaseHP;

    }

};
class FireMage: public Mage
{
public:
    FireMage (int BasePower, int BaseHP) : Mage (BasePower, BaseHP)
    {
        Power = BasePower;
        hp = BaseHP + 10;

    }

};

int main()
{
    Mage* CurrentMage;

    FireMage Gandalf (10, 10);
    IceMage Dumboldore (10, 10);

    CurrentMage = &amp;Gandalf;
    CurrentMage-&gt;GetDamage(1);

    CurrentMage = &amp;Dumboldore;
    CurrentMage-&gt;GetDamage(5);

    Gandalf.PrintHP();
    Dumboldore.PrintHP();
}

javier nicolas nieto

student•

Este video es excelente también, me ayudó bastante a entender este tema. Además usa la función virtual que es propia del polimorfismo

Brian Ricardo Sanchez Lopez

student•

Yo también aprendí POO con esos videos, muy bien explicados. Un crack el chavo, lástima que ya se nos adelanto. Me gusto más como explico el polimorfismo.

Alan Laboinet Amaya

student•

Buenas, le he dado vueltas a esto y no me termina de dar porque usar apuntadores exactamente. Esto porque hasta donde tengo entendido, la herencia implica herencia de métodos también, me entonces podría aplicar GetDamage() desde mi objeto dumbuldore o Gandalf. Que incluso me parece más claro y limpio de cara al código, si alguien tiene un razonamiento me lo podría decir por favor?

Brian Ricardo Sanchez Lopez

student•

El polimorfismo es cuando una operación tiene el mismo nombre en diferentes clases, pero realiza acciones diferentes. Por ejemplo la operación abrir(), puede ser utilizada en diferentes clases y hacer acciones diferentes como abrir una puerta, una ventana, una cuenta bancaria etc. En el ejemplo de esta clase la operación que tiene polimorfismo es GetDamage() porque cada mago (clase) hace un daño (acción) diferente.

Carlos Nassif Trejo Garcia

student•

Polimorfismo: Habilidad de tomar le clase de alguien a quien heredo

Francisco Joel Morando Pinedo

student•

Nah, no se entiende lo que estás diciendo Eri...

Fernando Leal

student•

Cual es tu duda compañero?

Oscar Jaramillo

student•

👀

LUIS ALEJANDRO BERNAL ROMERO

student•

Esta es una forma de hacerlo la herencia y adicionando uno directemente al llamar la constructora:

class Mage {
    public:

    Mage(int aPower, int aHp) {
        power = aPower;
        hp = aHp;
    }

    private:

    int power;
    int hp;
};


class IceMage : public Mage {
    public:

    IceMage(int aPower, int aHp) : Mage(aPower + 1, aHp)  {
    }
};

Estuardo Villagrán

student•

#include <iostream>

using namespace std;

class Mage { public: Mage(int BasePower, int BaseHP) { power=BasePower; hp=BaseHP; }

float Damage()
{
    return power;
}
void GetDamage(int Value)
{
    hp-=Value;
    cout<< "A mi mago le quedan: "<<hp<< " puntos de vida"<<endl;
}
void PrintHP()
{
    cout<<hp<<endl;
}
void SpellGreet()
{
    cout<< "Saludos, mi poder es "<<power<<endl;
}

protected: int power; int hp; };

class IceMage:public Mage { public: IceMage(int BasePower, int BaseHP): Mage(BasePower,BaseHP) { power=BasePower+1; hp=BaseHP; } }; class FireMage:public Mage { public: FireMage(int BasePower, int BaseHP): Mage(BasePower,BaseHP) { power=BasePower+1; hp=BaseHP+3; } }; int main() { Mage* CurrentMage;

Mage Harry(1,20);
FireMage Bran(1,30);
IceMage Anivia(1,5);

CurrentMage= &Bran;
CurrentMage->GetDamage(10);

CurrentMage= &Anivia;
CurrentMage->GetDamage(6);

Bran.PrintHP();
Anivia.PrintHP();
Harry.SpellGreet();

return 0;

}

José Carlos Coronel Nuñez

student•

#include <iostream>

using namespace std;

// Creamos una clase Mago
class Mage
{
    public:
        //Metodo para el poder y la vida del Mago
        Mage(int BasePower, int BaseHP, string BaseNombre)
        {
            Power = BasePower;
            hp = BaseHP;
            Nombre = BaseNombre;
        }
        float Damage()
        {
            return Power;
        }
        //metodo para recibir daño lo que hace es que acepta un valor
        void GetDamage(int Value, string NombreMago)
        {
            hp -= Value;
            cout << "La vida de " + NombreMago + " es :" << hp << endl;
        }
        void SpellGreet()
        {
            cout << "Hello Im " + Nombre + " the mage!." << endl;
        }

    //Protegemos la variable para que no sea modificada
    protected:
        int Power, hp; // declarando las variables
        string Nombre;
};

// Polimorfismo para que herede de la clase Mago y poder crear otras clases
class IceMage : public Mage // Funcionalidad para que herede de la Clase Mage
{
    public: // Declaramos como publicas por que se ponen como privadas por default
     IceMage( int BasePower, int BaseHP, string BaseNombre) : Mage(BasePower,BaseHP,BaseNombre) // Funcionalidad para que herede de Mage
     {
         Power = BasePower + 1;
         hp = BaseHP;
         Nombre = BaseNombre;
     }
};

// Polimorfismo para que herede de la clase Mago y poder crear otras clases
class FireMage : public Mage // Funcionalidad para que herede de la Clase Mage
{
    public: // Declaramos como publicas por que se ponen como privadas por default
     FireMage( int BasePower, int BaseHP, string BaseNombre) : Mage(BasePower,BaseHP,BaseNombre) // Funcionalidad para que herede de Mage
     {
         Power = BasePower;
         hp = BaseHP + 1;
         Nombre = BaseNombre;
     }
};

int main(){

    // Llamando al construtor Mage con los dos parametros (BasePower,BaseHp)
    Mage Harry(1,20,"Harry");
    // llamando el metodo para saludar
    Harry.SpellGreet();

    // Llamando al construtor Mage con los dos parametros (BasePower,BaseHp)
    Mage Valdomero(3,15,"Valdomero");
    // llamando el metodo para saludar
    Valdomero.SpellGreet();

    cout << "\n" << endl;// Saldo de linea
    cout << "Apartir de aqui aplicamos el polimosfismo" << endl;
    cout << "\n" << endl;
    cout << "Polimosfismo: Es la capacidad de que las Clases Hijas \n";
    cout << "              se puedan comportar como las Clases Padres." << endl;
    cout << "\n" << endl;

    // Creamos un apuntado
    Mage* CurrentMage;

    FireMage Gandalf(10,10,"Gandalf");
    IceMage Dumbledore(10,10,"Dumbledore");

    CurrentMage = &Gandalf;// Cambiamos de Mago con el apuntador
    CurrentMage->GetDamage(5,"Gandalf");// Llamamos al metodo para que reciba el daño

    CurrentMage = &Dumbledore;
    CurrentMage->GetDamage(3,"Dumbledore");

    return 0;
}

Gerardo Jesús Mota Olguín

student•

Perfecto, quedo bastante claro, muchas gracias!!!! el polimorfismo a resumidas cuentas es que los objetos que heredan de un Padre puedan convertirse en el tipo de dato del padre al que heredan.

Polimorfismo en C++: Teoría y Práctica

Introducción a C++

Programación de Videojuegos con C++ desde Cero

Programación en C++: Fundamentos y Aplicaciones Prácticas

Conceptos Generales de C++

Historia y uso del compilador GCC en programación

Preparando el entorno de trabajo

Instalación de Code::Blocks en Windows paso a paso

Instalación de CodeBlocks en Mac paso a paso

Creación de un Proyecto de Consola en C++ Paso a Paso

Uso de Librerías y Entrada/Salida en C++

Manejo de memoria

Memoria y Tipos de Datos en Computadoras y Programación

Variables y tipos de datos en programación básica

Operadores Aritméticos y Lógicos en Programación

Uso de Apuntadores para Manipulación de Memoria en Programación

Cálculo del Área de Círculo y Esfera con Variables

Entrada de datos y funciones

Entrada y manejo de datos en programas C++

Operadores Relacionales y Condicionales en Programación

Condicionales y estructuras de control en programación

Funciones y Encapsulamiento en Programación

Funciones en Programación: Creación y Uso Eficiente

Creación de aventuras interactivas con C++ y decisiones de usuario

Loops y arreglos

Arreglos: Conceptos Básicos y Manipulación en Programación

Estructuras de Control: Bucles en Programación

Contadores y Bucles en Programación: While, Do-While y For

Arreglos Unidimensionales y Bidimensionales en Programación

Dibujar Mapas y Personajes en Juegos con Arreglos en C++

Movimiento de Personajes en Juegos con Python

Programación de Mapas Bidimensionales en Videojuegos

Movimiento de Personajes en Cuatro Direcciones con CIN

Lectura de Archivos

Lectura y escritura de archivos en C++ con fstream

Lectura y Escritura de Archivos en Programación

Posicionamiento del Jugador en el Mapa de Juego

Programación Orientada a Objetos

Programación Orientada a Objetos: Conceptos y Beneficios

Programación Orientada a Objetos: Clases e Instancias en Java

Encapsulación de Datos en Programación Orientada a Objetos

Abstracción en Programación Orientada a Objetos

Herencia en Programación Orientada a Objetos: Clases y Constructores

Tipos de acceso en la herencia de clases en programación

Polimorfismo en C++: Teoría y Práctica

Finalizando nuestro proyecto

Programación de un Juego de Laberinto en C++

Controles básicos de movimiento en videojuegos con programación en C++

Creación de Clases para Mapas en Juegos de Programación

Conexión de Jugador y Coordenadas en Mapas de Videojuegos

Carga y Lectura de Archivos para Mapas en Juegos

Colisiones y Movimiento en Juegos 2D con C++

Colisiones y restricciones de movimiento en mapas de juegos

Colisiones y Portadas en Videojuegos: Implementación en C++

Creación de Juegos de Aventuras en C++: Laberintos y Cofres del Tesoro

Programación Orientada a Objetos en Videojuegos Básicos

Creación de Enemigos y Laberintos en C++ Avanzado