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

Herencia

34/47
Recursos

La herencia es un principio de la programación orientada a objetos que nos ayuda a crear nuevas clases que ““heredan”” (y pueden mejorar) los métodos y propiedades de la clase ““padre””.

Debemos crear una nueva clase pero antes de abrir las llaves ({}) vamos a añadir dos puntos, la palabra public y el nombre de la clase que estamos heredando. Por ejemplo:

class Mage
{
public:
        int mana, hp, power;

        Mage (int iMana, int IHP, int iPower)
        {
                // ...
        }
};

class IceMage : public Mage
{
public:
        IceMage(int iMana, int IHP, int iPower):Mage(iMana, IHP, iPower)
        {
                // ...
        }
};

Aportes 38

Preguntas 2

Ordenar por:

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

Para no tener que volver a escribir los atributos en la clase hija, o para no ponerlos públicos en la clase madre, basta con ponerlos protegidos, así los heredan las clases hijas.
Sin faltar a la seguridad con el public ni tener que volver a escribirlos.

Buenas,

Dejo este esquema resumen de Herencia, para ayudar a entender un poco más los temas como public, private o protected.

Lo que me quedo del curso anterior es la costumbre de hacer un nuevo archivo para cada tema como lo hacia el profe Mauro, por que acá borra y trabaja sobre el mismo archivo y después no te queda.
Me gusta que cada curso es independiente entre sí y te aporta siempre algunos nuevos tips, es muy positivo. Y cada profe tiene su forma de enseñar.
Después de todo, pude trabajar lo más bien con vs code usando todos sus plugins y en linux sin la necesidad de tener codeblocks.

Mi aporte

Para que sirve la herencia en POO: Con la herencia todas las clases están clasificadas en una jerrquía estricta. Cada clase tiene una superclase (la clase superior en la jerarquía) también llamada clase base y cada clase puede tener una o más subclases también llamadas clases derivadas. Además hereda todas las variables y los métodos definidos por la superclase y agrega us elementos únicos.

No me convencio mucho esta explicacion debido a que rompio la encapsulacion al pasar las propiedades de privadas a publicas, Hay alguna mejor forma de hacer la herencia sin tener que sacar los atributos de su encapsulacion?

Los metodos privados si pueden ser heredados mediante el : public [Clase Padre]

#include <iostream>

using namespace std;

class Mago
{
public:
    int Mana, Hp, Power;

    Mago (int iMana, int iHp, int iPower)
    {
        Mana = iMana;
        Hp = iHp;
        Power = iPower;
    }
    void Expeliarmus()
    {
        cout << "expeliarmus" << Power << endl;
    }

private:


};

class Bruja : public Mago
{
public:
    Bruja(int iMana, int iHp, int iPower):Mago(iMana,iHp,iPower)
    {
        Mana = iMana;
        Hp = iHp;
        Power = iPower + 10;
    }
private:

};

int main()
{
    Mago Harry(80, 100, 30);
    Bruja Hermione(80, 100, 30);

    Harry.Expeliarmus();
    Hermione.Expeliarmus();

    return 0;
}```

Miembros de una clase son privados por defecto si no se especifica el tipo de acceso (private, public, protected).

Tuve dudas sobre la forma en que se hereda el constructor pero espero que con éste aporte ayude si alguien pasa por lo mismo:

#include <iostream>
#include <string.h>
using namespace std;

class Persona
{
	public:
		Persona(string nombre, int edad) //constructor persona
		{
			p_nombre=nombre;
			p_edad=edad;
		}
	
		void hi()
		{
			cout<<"Hola me llamo "<<p_nombre<<" y tengo "<<p_edad<<endl;
		}
		
	protected: //protected es private pero deja heredar los atributos
		string p_nombre;
		int p_edad;

};

class Profesor : public Persona 
//hereda métodos y atributos publicos de persona
{
	public:
//se declaran las mismas variables que el constructor padre
//junto con las variables extras que tendrá la nueva clase
//y despues de los : se le pasan las variables sin declarar
//del objeto padre

	Profesor(string nombre, int edad, string grado) :Persona(nombre, edad)
		{
			p_nombre=nombre;
			p_edad=edad;
			p_grado=grado;
		}
		
		void grade()
		{
			cout<<"Doy clases a nivel "<<p_grado;
		}
	
	protected:
		string p_grado;
};


int main()
{
	Persona Juan("juan", 30);
	Juan.hi();
	
	Profesor Maria("maria",90, "Secundaria");
	
	Maria.hi();
	
	Maria.grade();
	
	return 0;
}

en mi opinión: falta la explicación de la palabra Virtual que es muy importante para el proceso de abstracción.

la etiqueta friend es una buena forma de obtener los elementos privados de una clase 😃. para los q ue quieran ver otras forma de solucionar en error que apareció en clase. Saludos a todos.

😎

En 6:51 no hay necesidad de poner los atributos de la clase padre en public (y de hecho no es correcto, por no encapsular los atributos del padre, ahora cualquiera puede manipularlos). Lo correcto para manipular dichos atributos, es realizar una función setter. Por cierto, tampoco hay que volver a asignar nuevamente los valores en el constructor hijo porque ya fueron heredados por la clase padre. Y si se necesita modificar algún atributo del padre en el constructor hijo usar el protected.

Recuerdo que la primera vez que vi este concepto lo aprendi solo y me costo, aqui se vio muy simple, no se si es porque ahora si entiendo el concepto, lo importante es que los ejemplos me ayudan a ordenar todo lo que he aprendido a lo largo del tiempo y darle un sentido a ese conocimiento

#include <iostream>

using namespace std;
class chiken
{
public:
string name;
int kick;
int cockcrow;
int peck;
    chiken(string iname, int ikick, int icockcrow, int ipeck)
    {
        name = iname;
        kick = ikick;
        cockcrow = icockcrow;
        peck = ipeck;
    };
    void tweet()
    {
        cout<<name<< " dice: pio pio ";
    };
     void think()
   {
     cout <<getThink()<< endl;
   }
    int sentimientos()
   {
     return hambre, sed, miedo, aburrido;
   }
   void ataque ()
   {
       cout <<name<< " a lanzado el ataque patada " <<kick<<endl;
    }

private:

   int hambre;
   int sed;
   int miedo;
   int aburrido;

   string getThink()

   {
       if (hambre + sed > 100)
       {
           return "dame maiz y agua";
       }
       else if(miedo > 75 )
       {
           return "tengo miedo";
       }
       else if (aburrido > 100)
       {
           return "sacame de aqui";

        }
        else if (aburrido < 100)
        {
          return "estoy tranquilo";
        }

   }


};
class rooster : public chiken
{
   public:
        rooster(string iname, int ikick, int icockcrow, int ipeck) : chiken (iname, ikick, icockcrow, ipeck )
        {
            name = iname;
        kick = ikick + 10;
        cockcrow = icockcrow;
        peck = ipeck;
        }
};
int main()
{
    chiken first("gallosky", 70, 60, 10);
    chiken second("bolita", 20, 10, 100);
    rooster dorado("dorado", 50, 100, 40);
     first.ataque();
     dorado.ataque();


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

        second.tweet();
         second.think();
    }

    return 0;
}

mezcla de las clases anteriores y esta

*Mis apuntes sobre: “Herencia”

Les comparto mi código:

#include <iostream>

using namespace std;

class Mage
{
private:

public:
    int mana, hp, power;
    Mage(int iMana, int iHP, int iPower)
    {
        mana=iMana;
        hp=iHP;
        power=iPower;
    }
    void spell()
    {
        cout<<"Fireworks!!"<<power<<endl;
    }
};

class IceMage : public Mage
{
    public:
    IceMage(int iMana, int iHP, int iPower):Mage(iMana,iHP,iPower)
    {
        mana=iMana;
        hp=iHP;
        power=iPower+10;
    }
};

int main()
{
    Mage gandalf(100,10,20);
    IceMage saruman(100,10,20);
    gandalf.spell();
    saruman.spell();

    return 0;
}

Estas clases de POO son las mejores que he visto en mucho tiempo, y los ejemplos son de lo mejor!

Hecho!!!

#include <iostream>

using namespace std;

class Mage
{
public:
    int mana, hp, power;
    Mage (int iMana, int iHP, int iPower)
    {
        mana = iMana;
        hp= iHP;
        power = iPower;
    }

    void Spell ()
    {
        cout << "Fireworks!!!" << power << endl;
    }
};

class IceMage : public Mage
{
public:
    IceMage (int iMana, int iHP, int iPower): Mage (iMana, iHP, iPower)
    {
        mana = iMana;
        hp= iHP;
        power = iPower + 10;
    }
};

int main()
{
    Mage Gandalf (100, 10, 20);
    IceMage Sauroman (100, 10, 20);
    Gandalf.Spell();
    Sauroman.Spell();
}

Revisar la herencia de Constructor padre a Contructor Hijo

Mi aporte el único inconveniente que no se como solucionarlo es en el case 2

#include <iostream>

using namespace std;


class personaje
{
public:
    string nombre = " ";
    string nameMago = " ";
    int mana, vida, poder;

    personaje(string iNombre, string inameMago, int iMana, int iVida, int iPoder)
    {
        nombre = iNombre;
        nameMago =inameMago;
        mana = iMana;
        vida = iVida;
        poder = iPoder;
    }
    void spell()
    {
        cout << "Hola " << nombre << " te has convertido en " << nameMago << endl;
        cout << "Tienes mana de: " << mana << endl;
        cout << "Tienes una vida de: " << vida << endl;
        cout << "Tienes poder de: " << poder << endl;

    }
};

class magoBueno : public personaje
{
    public:
    magoBueno(string iNombre, string inameMago,int iMana, int iVida, int iPoder):personaje(iNombre,inameMago, iMana, iVida, iPoder)
    {
        nombre = iNombre;
        nameMago =inameMago;
        mana = iMana;
        vida = iVida + 50;
        poder = iPoder;
    }
};

class magoMalo : public personaje
{
    public:
    magoMalo(string iNombre,string inameMago, int iMana, int iVida, int iPoder) : personaje (iNombre,inameMago,iMana, iVida, iPoder)
    {
        nombre = iNombre;
        nameMago =inameMago;
        mana = iMana;
        vida = iVida;
        poder = iPoder + 50;
    }
};




int main()
{
    string nombre = " ";
    string nameMago = " ";
    int opcion;
    cout << "Bienvenido!!!!" << endl;
    cout << "Ingresa tu nombre: " << endl;
    cin >> nombre;
    cout << "Que tipo de mago deseas ser: " << endl;
    cout << "1. Lado Obscuro" << endl;
    cout << "2. Lado de la Luz" << endl;
    cin >> opcion;
    switch(opcion)
    {
    case 1:
        nameMago = "Voldemort";
        magoMalo Voldemort (nombre,nameMago,100,100,75);
        Voldemort.spell();
        break;
    case 2:
        /*nameMago = "Merlin"
        magoBueno Merlin (nombre,nameMago100,100,75);
        Merlin.spell();*/
        break;

    }
    return 0;
}

Aplicando la recomendación de Jalile Herrera Ramirez, por cierto, gracias a la compañera.

#include <iostream>

using namespace std;

class Mage
{
protected:
    int Mana, HP, Power;

public:
    Mage(int iMana, int iHP, int iPower)
    {
        Mana = iMana;
        HP = iHP;
        Power = iPower;
    }

    void Spell()
    {
        cout << "Fireworks: " << Power << endl;
    }
};

class IceMage : public Mage
{
public:
    IceMage(int iMana, int iHP, int iPower) : Mage(iMana, iHP, iPower)//Por defecto utilizaria el constructor de la clase Mage pero se puede hacer uno propio
        {
            Mana = iMana;
            HP = iHP;
            Power = iPower + 10;
        }
};

int main()
{
    Mage Gandalf(100, 10, 20);
    Gandalf.Spell();

    IceMage Sauruman(100, 10, 20);
    Sauruman.Spell();

    return 0;
}

Resultado:

Fireworks: 20
Fireworks: 30

hecho :3

#include <iostream>

using namespace std;

class mago
{
public:
    int mana,hp,power;

    mago(int iMana, int ihp, int ipower)
    {
        mana = iMana;
        hp = ihp;
        power = ipower;
    }

void spell()
{
    cout << "rayo laser" << power <<endl;
}

};

class mago_hielo:public mago
{
    public:
    mago_hielo(int iMana, int ihp, int ipower): mago(iMana, ihp,ipower)
    {
        mana = iMana;
        hp = ihp;
        power = ipower + 10;

    }

};

int main()
{
    mago guapo (100,10,20);
    mago_hielo feo (100,10,20);

    guapo.spell();

    feo.spell();

    return 0;
}
#include <iostream>

using namespace std;

class Wizard {
public:
    int mana, hp, power;

public:
    Wizard(int _mana, int _hp, int _power) {
        mana = _mana;
        hp = _hp;
        power = _power;
    }

    void spell() {
        cout << "fireworks!! " << power << endl;
    }
};


class IceWizard : public Wizard {
public:
    IceWizard(int _mana, int _hp, int _power) : Wizard(_mana, _hp, _power) {
        mana = _mana;
        hp = _hp;
        power = _power + 10;
    }
};

int main() {

    Wizard gandalf( 100, 10, 20 );
    gandalf.spell();

    IceWizard sauroMan( 100, 10, 20 );
    sauroMan.spell();

    return 0;
}

Muy util para evitar reescribir codigo, aparte enseña muy bien el shavo laik

#include <iostream>

using namespace std;

class Mage{
public:

    int mana;
    int hp;
    int lvl;

    Mage(int Imana,int Ihp,int Ilvl){
        mana=Imana;
        hp=Ihp;
        lvl=Ilvl;
    }


    void Espedermus(){
        cout<<"Espedermus!"<<endl;
        mana-=10;
        cout<<"Mana: "<<mana<<endl;
    }
private:


};


class IceMage : public Mage
{
public:
    IceMage(int Imana,int Ihp,int Ilvl):Mage(Imana,Ihp,Ilvl)
    {
        mana=Imana+20;
        hp=Ihp;
        lvl=Ilvl;
    }

};


int main(int argc, char const *argv[])
{

    Mage Popotes(100,80,1);
    IceMage Vinos(100,80,1);
    Popotes.Espedermus();   
    Vinos.Espedermus();
    return 0;
}
#include <iostream>

using namespace std;

class Mage
{
public:
   int mana, hp, power;
   Mage(int i_mana, int i_hp, int i_power)
   {
      mana = i_mana;
      hp = i_hp;
      power = i_power;
   }

   void spell()
   {
      cout << "Powerball: " << power << endl;
   }
};

class IceMage : public Mage
{
public:
   IceMage(int i_mana, int i_hp, int i_power) : Mage(i_mana, i_hp, i_power)
   {
      mana = i_mana;
      hp = i_hp + 50;
      power = i_power - 5;
   }
};

class FireMage : public Mage
{
public:
   FireMage(int i_mana, int i_hp, int i_power) : Mage(i_mana, i_hp, i_power)
   {
      mana = i_mana - 30;
      hp = i_hp + 10;
      power = i_power + 10;
   }
};

int main()
{
   Mage Gandalf(100, 10, 20);
   IceMage ZeroDegreezus(100, 10, 20);
   FireMage Flamage(100, 10, 20);
   
   Gandalf.spell();
   ZeroDegreezus.spell();
   Flamage.spell();

   return 0;
}

Que buena clase, pude agregar al mago de fuego en 2 minutos

#include <iostream>

using namespace std;

class Mage
{

public:
    int mana, hp, power;

    Mage(int iMana, int iHp, int iPower)
    {
        mana = iMana;
        hp = iHp;
        power = iPower;
    }

    void Spell()
    {
        cout << "FireWOrks " << power << endl;
    }

};

class IceMage : public Mage
{
public:

    IceMage(int iMana, int iHp, int iPower) : Mage(iMana, iHp, iPower)
    {
        mana = iMana;
        hp = iHp;
        power = iPower + 10;

    }
};

class FireMage : public Mage
{
public:
    FireMage(int iMana, int iHp, int iPower) : Mage(iMana, iHp, iPower)
    {
        mana = iMana;
        hp = iHp;
        power = iPower + 50;

    }
};


int main()
{
    Mage Gandalf(100, 10, 20);
    IceMage Sauruman(100, 10, 20);
    FireMage Brand(100, 10, 20);
    Sauruman.Spell();
    Gandalf.Spell();
    Brand.Spell();

    return 0;
}```

Magic The Gathering eres tú?

Esto explica porque muchos fans de WOW y LOG entienden POO súper rápido 😃

<#include <iostream>
using namespace std;
class Mage
{
private:

public:
    int mana, hp, power;
    Mage (int totalMana, int totalHp, int totalPower)
    {
        mana = totalMana;
        hp = totalHp;
        power = totalPower;
    }
    void spell ()
    {
        cout << "Dark spell" << power <<endl;
    }
};
class fireMage : public Mage
{
public:
    fireMage(int totalMana, int totalHp, int totalPower) : Mage (totalMana, totalHp, totalPower)
    {
        mana = totalMana;
        hp = totalHp;
        power = totalPower + 10;
    }
};
class darkMage : public Mage
{
public:
    darkMage (int totalMana, int totalHp, int totalPower) : Mage (totalMana, totalHp, totalPower)
    {
        mana = totalMana;
        hp = totalHp;
        power = totalPower + 50;
    }
};
int main ()
{
    Mage Lich (100, 60, 175);
    fireMage Kahel (100, 60, 175);
    darkMage Darknu (100, 50, 175);
    Lich.spell();
    Kahel.spell();
    Darknu.spell();
    return 0;
}
>
#include <iostream>

using namespace std;

class Human {
public:
    Human (int SpawnAge){
        Age = SpawnAge;
    }


    void Think(){
        cout<< GetThinkMessage() << endl;
    }

    int Age;
private:
    int SocialLevel;
    int Inteligence;
    int Luck;

    string GetThinkMessage()
    {
        if (SocialLevel + Luck > 100 )
        {
            return "Estoy teniendo pensamientos Felices:D";
        }
        else if( Luck >Inteligence ){
            return "Soy un suertudo";
        }
        else if( Age > 18 ){
            return "Soy un BB";
        }
        else {
            return "No pienso nada";
        }
    }

};

int main()
{
    Human Bob(19);

    Bob.Think();

    return 0;
}

Agregue un mago de fuego que hereda de la clase mage:

#include <iostream>

using namespace std;

class Mage
{
private:


public:

     int mana, hp, power;

    Mage(int iMana, int iHP, int iPower)
    {
        mana = iMana;
        hp = iHP;
        power = iPower;
    }

    void Spell()
    {
        cout<<"FireWorks! "<< power << endl;
    }
};

class IceMage : public Mage
{
public:
    IceMage(int iMana, int iHP, int iPower) : Mage(iMana, iHP, iPower)
    {
        mana = iMana;
        hp = iHP;
        power = iPower+10;
    }
};

class FireMage : public Mage
{
public:
    FireMage(int iMana, int iHP, int iPower) : Mage(iMana, iHP, iPower)
    {
        mana = iMana +10;
        hp = iHP+20;
        power = iPower+20;
    }
};


int main()
{
    Mage Gandalf(100, 10, 20);
    IceMage Forbax(100, 10, 20);
    FireMage Fulgore(100, 30, 50);

    Gandalf.Spell();
    Forbax.Spell();
    Fulgore.Spell();



    return 0;
}
class Mago {
public:
	int mana, hp, power;

	Mago (int iMana, int iHP, int iPower) {
		mana = iMana;
		hp = iHP;
		power = iPower;

	}

	void Spell() {
		cout << "Wingardium Leviosa " << power;
	}
};

class MagoHielo : public Mago {
public:
	MagoHielo (int iMana, int iHP, int iPower): Mago (iMana, iHP, iPower) {
		mana = iMana;
		hp = iHP;
		power = iPower + 10;
	}
};

int main() {

	Mago Gandalf(100, 10, 20);
	Gandalf.Spell();

	MagoHielo ReyHelado(100, 10, 20); 
	cout << "\n";
	ReyHelado.Spell();
return 0;
}```

buena clase

DragonBall 😄 ✌

using namespace std;

class SuperSayayin
{
public:

    string name;
    int life, power;

    SuperSayayin(string iName, int iLife, int iPower)
    {
        name = iName;
        life = iLife;
        power = iPower;
    }

    void Attack()
    {
        cout<<name<< ", Kame Hame HaaaA!! con: " <<power<< " de poder."<<endl;
    }
};

class Sayayin : public SuperSayayin
{
    public:

    Sayayin(string iName, int iLife, int iPower) : SuperSayayin(iName, iLife, iPower)
    {
        name = iName;
        life = iLife;
        power = iPower - 20;
    }
};

int main()
{
    SuperSayayin Goku("Son Goku", 100, 100);
    Sayayin Gohan("Son Gohan", 100, 100);
   
    cout<< "Dragon Ball" <<endl<<endl;
    Goku.Attack();
    Gohan.Attack();

    return 0;
}

Resultado ✌

gracias Platzi!

# include <iostream>

using namespace std;

class Mage
{
private:
    

public:
    int mana, hp, SpellPower;

    Mage(int iMana, int iHP, int iSpellPower)
    {
        mana = iMana;
        hp = iHP;
        SpellPower = iSpellPower;
    }

    void Spell()
    {
        cout << "Fireball!!" << SpellPower << endl;
    }
};


class IceMage : public Mage //Esto quiere decir que hereda
{
public:
    IceMage(int iMana, int iHP, int iSpellPower):Mage(iMana, iHP, iSpellPower)
    {
        mana = iMana;
        hp = iHP;
        SpellPower = iSpellPower*2;
    }
};


int main()
{
    Mage  Gandalf(1000, 2000, 540);
    Gandalf.Spell();

    IceMage Lagrilla(1000, 2000, 540);
    Lagrilla.Spell();

    return 0;
}