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

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Adquiere por un a帽o todos los cursos, escuelas y certificados por un precio especial.

Antes: $249

Currency
$219/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Comprar ahora

Termina en:

1D
11H
52M
13S

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?

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鈥o 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 鈥渋nfantiles鈥, 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: 鈥淧olimorfismo鈥

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!