Introducción a C++

1

Todo lo que aprenderás sobre C++

2

¿Qué es programar y por qué aprender C++?

Conceptos Generales de C++

3

La Historia de C++ y sus diferencias con C

Preparando el entorno de trabajo

4

Instalando Codeblocks

5

Pasos para instalar en mac

6

Ejecutando nuestro primer programa

7

¿Qué son las librerías STD? - Portada del Proyecto

Manejo de memoria

8

¿Qué es la memoria y tipos de datos?

9

Alojando variables en memoria

10

¿Cómo usar operadores?

11

¿Qué son los apuntadores?

12

Reto: Escribir un programa que calcule áreas.

Entrada de datos y funciones

13

¿Cómo introducir datos a nuestro programa?

14

¿Cómo usar condicionales?

15

Usando condicionales

16

¿Cómo encapsular código en funciones ?

17

¿Qué son los parámetros y como usarlos?

18

Reto: Juego narrativo implementando condicionales y entrada de datos.

Loops y arreglos

19

¿Qué son los arreglos?

20

¿Qué son los Loops?

21

Programando Loops

22

Loops , arreglos y arreglos bidimensionales

23

Dibujando el mapa de nuestro juego con arreglos

24

Manipulando mi jugador con inputs en arreglos unidimensionales

25

Arreglos bidimensionales

26

Reto: Moviendo a mi personaje en mi arreglo bidimensional

Lectura de Archivos

27

Creando y leyendo un archivo externo

28

Leyendo archivos externos

29

Reto: En el mapa, crear punto de inicio y salida del jugador

Programación Orientada a Objetos

30

¿Qué es POO?

31

Definiendo una clase y creando sus instancias

32

Encapsulación

33

Abstracción

34

Herencia

35

Propiedades de clase en herencia

36

Polimorfismo

Finalizando nuestro proyecto

37

Creación de personaje y archivo de encabezado

38

Moviendo mi personaje con entrada de datos

39

Mapa

40

Interacción entre el personaje y el mapa

41

Paredes

42

Optimizando trazado de mapa

43

Colisiones

44

Creando nuestra portada de juego

45

Tesoro y victoria

46

Conclusiones

47

Proyecto final

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Polimorfismo

36/47
Recursos

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.

Aportes 33

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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🙈✌

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.

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

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.

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.

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

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;
}

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

#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();
}

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

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?

Hecho!!!

#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 << "Mi mago le queda: "<< hp << endl;
    }

    void PrintHP ()
    {
        cout << hp << 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 = &Gandalf;
    CurrentMage->GetDamage(1);

    CurrentMage = &Dumboldore;
    CurrentMage->GetDamage(5);

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

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.

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

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

👀

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)  {
    }
};

#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;

}

#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;
}

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.

Esta es la mejor clase que he visto en Platzi

aqui mi codigo implementando el polimorfismo:

#include <iostream>
#include <stdio.h>
#include <windows.h>

using namespace std;

class Wizard
{
public:

    Wizard(string iName,string iClase,string iHechizo, int iPower, int iHP, int iMana)
    {
        Name = iName;
        Power = iPower;
        hp = iHP;
        Clase = iClase;
        Mana = iMana;
        Hechizo = iHechizo;
    }

    void Stats()
    {
        cout << "Nombre: " << Name << endl;
        Sleep(1000);
        cout << "Clase: " << Clase << endl;
        Sleep(1000);
        cout << "Vida: " << hp << endl;
        Sleep(1000);
        cout << "Poder: " << Power << endl;
        Sleep(1000);
        cout << "Mana: " << Mana << endl;

    }

    void Spell(char input)
    {
        do
        {
            
            if (input == 'a')
            {
                Mana = Mana - 10;
                cout << Hechizo <<  endl;
            }
            else
            {
                cout << "por favor ingresa un hechizo" << endl;
                cin >> input;
            }
        } while (input != 'a');

        
    }

    int Damage()
    {
        return Power;
    }

    void GetDamage(int Value)
    {
        hp -= Value;
    }

    int Vida()
    {
        return hp;
    }

    string Nombre()
    {
        return Name;
    }

    void Magia()
    {
       cout << "(a)\t" << Hechizo << endl; 
    }

protected:

    int Power, hp, Mana;
    string Name, Clase, Hechizo;
};

class IceWizard : public Wizard
{
public:
    IceWizard(string iName, string iClase,string iHechizo, int iPower, int iHP, int iMana) : Wizard(iName, iClase,iHechizo, iPower, iHP, iMana)
    {
        Clase = iClase;
        Name = iName;
        Power = iPower + 5;
        hp = iHP;
        Mana = iMana;
        Hechizo = iHechizo;
    }

    void Spell(char input)
    {
        do
        {
            
            if (input == 'a')
            {
                Mana = Mana - 10;
                cout << Hechizo << endl;
            }
            else
            {
                cout << "por favor ingresa un hechizo" << endl;
                cin >> input;
            }
        } while (input != 'a');
        
        
        
    }

    void Magia()
    {
        cout << "(a)\t" << Hechizo << endl;
    } 

};

class FireWizard : public Wizard
{
public:
    FireWizard(string iName, string iClase,string iHechizo, int iPower, int iHP, int iMana) : Wizard(iName, iClase,iHechizo, iPower, iHP, iMana)
    {
        Clase = iClase;
        Name = iName;
        Power = iPower;
        hp = iHP + 5;
        Mana = iMana;
        Hechizo = iHechizo;
    }

    void Spell(char input)
    {
        do
        {
            
            if (input == 'a')
            {
                Mana = Mana - 10;
                cout << Hechizo << endl;
            }
            else
            {
                cout << "por favor ingresa un hechizo" << endl;
                cin >> input;
            }
        } while (input != 'a');
        
        
        
    }

    void Magia()
    {
        cout << "(a)\t" << Hechizo << endl;
    }
    

};

int main()
{
    Wizard* CurrentWizard1;                      //el objeto de la clase padre va a ser de puntero que va apuntar a los hijos
    Wizard* CurrentWizard2;
    string buffer;
    char input;
    bool EndGame = false;

    cout << "ingresa el nombre de tu mago: ";
    cin >> buffer;
    IceWizard MagoDeFuego(buffer, "Fuego", "Fire Ball!!", 20, 100, 100);     //esta clase es hijo de la clase padre Wizard. aqui va a puntar el objeto puntero de la clase padre
    
    cout << "ingresa el nombre del otro mago: ";
    cin >> buffer;
    FireWizard MagoDeHielo(buffer, "Helido", "Ice Ball!!", 20, 100, 100);    //este es otra clase hijo de la clase padre Wizard. aqui tambien va apuntar el objeto puntero de la clase padre

    for(int i = 0; i < 2; i++)
    {
        if(i == 0)
        {
            CurrentWizard1 = &MagoDeFuego;
            
        }
        else
        {
            CurrentWizard1 = &MagoDeHielo;
        }
        CurrentWizard1->Stats();             //en el apuntador para acceder a las funciones vamos a utilizar una flecha -> en lugar de un punto .
        Sleep(1000);
        cout << endl;
        
    }
    
    cout << "\nComiensa la Batalla" << endl;
    Sleep(1000);
    cout << MagoDeFuego.Nombre() << endl;
    Sleep(1000);
    cout << "  Versus" << endl;
    Sleep(1000);
    cout << MagoDeHielo.Nombre() << endl;
    CurrentWizard1 = &MagoDeFuego;

    do
    {
        int i;   
        
        for (i = 0; i < 2; i++)
        {
            

            if (i == 0)
            {
                CurrentWizard1 = &MagoDeFuego;
                CurrentWizard2 = &MagoDeHielo;
            }
            else
            {
                CurrentWizard1 = &MagoDeHielo;
                CurrentWizard2 = &MagoDeFuego;
            }
            cout << "turno de : " << CurrentWizard1->Nombre() << endl;
            Sleep(1000);

            cout << "hechizos: " << endl;
            CurrentWizard1->Magia();
            cin >> input;
            CurrentWizard1->Spell(input);
            CurrentWizard2->GetDamage(CurrentWizard1->Damage());
            Sleep(1000);
            cout << CurrentWizard2->Nombre() << " Recive: " << CurrentWizard1->Damage() << " De damage" << endl;
            Sleep(1000);
            

            
        }
        if(CurrentWizard2->Vida() <= 0)
            {
                cout << CurrentWizard2->Nombre() << " a sido eliminado por: " << CurrentWizard1->Nombre() << endl;
                Sleep(1000);
                cout << CurrentWizard1->Nombre() << " a ganado la partida" << endl;
                EndGame = true;
            }

        i = 0;
        
        
    } while (!EndGame);
    

    
    
    return 0;
}

hecho:)

#include <iostream>

using namespace std;

class mago
{
public:

    mago(int basepower,int basehp)
    {
       power= basepower;
       hp = basehp;
    }
    float damage()
    {
            return power;
    }


    void getdamage(int valor) //acepta un valor
    {
        hp-=valor; //reduce los puntos de vida
        cout << "mi mago le queda :" << hp <<endl;

    }


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

    void spell()
    {
        cout<<"hello world" <<endl;
    }

protected:

    int power,hp;
};

class magohielo: public mago
{

    public:
    magohielo(int basepower,int basehp):mago(basepower, basehp)
    {
        power=basepower + 1;
        hp= basehp;
    }

};


class magofuego: public mago
{
    public:
    magofuego(int basepower,int basehp):mago(basepower, basehp)
    {
        power=basepower;
        hp= basehp + 10;
    }



};

int main()
{
    mago* actualmago;  //creamos un apuntador vacio tipo mago.
    magofuego gandalf(10,10);
    magohielo domuldor(10,10);

    actualmago = &gandalf;  // lo estoy llamando desde una variable tipo mago, entonces gandalf adquirio la forma de mago, pero sigue siendo un mago de hielo
    actualmago ->getdamage(1);

    actualmago= &domuldor;
    actualmago->getdamage(5);

        gandalf.printHP();
        domuldor.printHP();


    return 0;
}```

Entiendo que se puede hacer, más no entiendo la utilidad real, para que voy a querer hacer esto, si ya tengo tipos de mago definidos, osea para que complicarse la vida, realmente no entiendo mucho el tema del polimorfismo y su aporte

En realidad entendi a la perfeccion lo del polimorfismo, pero ciertamente no entiendo hasta ahora su utilidad. Al hacer que el puntero apunte al objeto padre haria lo mismo que decir:
gandalf.getDamage();
Ya que gandalf es un objeto de tipo magoFuego que hereda de Mago tambien hereda entonces las funciones publicas de Mago. Podriamos privatizar la funcion getdamage colocandola en private: y accederla a traves de otra funcion pero eso seria Abstraccion lo cual me parece mucho mas util.

#include <iostream>

using namespace std;

class Mago
{
public:
    Mago(int basePoder, int baseHp)
    {
        poder = basePoder;
        hp = baseHp;
    }

    float Damage()
    {
        return poder;
    }

    void GetDamage(int value)
    {
        hp -= value;
        cout << "Al mago le quedan: " << hp << endl;
    }

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


protected:
    int poder, hp;
};

class MagoHielo : public Mago
{
public:
    MagoHielo(int basePoder, int baseHp) : Mago(basePoder,baseHp)
    {
        poder = basePoder + 10;
        hp = baseHp - 10;
    }
};

class MagoFuego : public Mago
{
public:
    MagoFuego(int basePoder, int baseHp) : Mago(basePoder,baseHp)
    {
        poder = basePoder - 10;
        hp = baseHp + 10;
    }
};

int main()
{
    Mago* currentMago;

    MagoFuego Gandalf(30,100);
    MagoHielo Dumbledore(30,100);

    currentMago = &Gandalf;
    currentMago->GetDamage(30);

    currentMago = &Dumbledore;
    currentMago->GetDamage(30);

    Gandalf.printHp();
    Dumbledore.printHp();


    return 0;
}
#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;// Cambiamos de Mago con el apuntador
    CurrentMage->GetDamage(3,"Dumbledore");// Llamamos al metodo para que reciba el daño



    return 0;
}

Creo que entendi el concepto, pero para que puede ser util?

Muy buena clase la pude entender, pero siento que me falta practica para entender más aplicaciones del polimorfismo.

No comprendo el uso de ejemplos tan “infantiles”, creo que en ese sentido el contenido debe mejorar el tipo de ejemplos, es una opinión solamente, saludos 😃

Gracias por la clase muy entretenida.

*Mis apuntes sobre: “Polimorfismo”

Es la característica de un objeto de tomar varias formas.
Cuando un tipo de dato hereda de otro este puede tomar la forma del cual heredó.

Ejemplo:

#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<<"The mage now have: "<<hp<<" hp"<<endl;
    }
    void printHP()
    {
        cout<<hp<<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 dumbledore(10,10);

    currentMage=&gandalf;
    currentMage->getDamage(1);

    currentMage=&dumbledore;
    currentMage->getDamage(5);

    gandalf.printHP();
    dumbledore.printHP();

    return 0;
}

gracias!