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

Aprende Inglés, Programación, AI, Ciberseguridad y mucho más.

Antes: $249

Currency
$209
Suscríbete

Termina en:

3 Días
10 Hrs
8 Min
1 Seg

Abstracción

33/47
Recursos

La abstracción es usada por los lenguajes de programación para enseñarle a los usuarios únicamente los datos esenciales, lo que necesitan para realizar sus actividades en el sistema, y esconder el funcionamiento o los datos innecesarios del programa.

Por ejemplo: las computadoras nos permiten presionar un botón para encender y apagar la máquina sin necesidad de que entendamos cómo funcionan los circuitos y toda la lógica de ellas.

Vamos a usar la parte privada de nuestras clases para esconder las variables y métodos que queremos esconder de los jugadores. Puede pasar que necesitemos imprimir estos datos para que los jugadores tomen decisiones en alguna parte del juego, es por eso que podemos llamar a las propiedades escondidas desde las propiedades públicas.

Así, los jugadores NO podrán modificar nuestras propiedades secretas y solo podrán saber (leer) el valor de ellas cuando nosotros lo permitamos con un método público.

Aportes 34

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Vengo del futuro: Algún día pensaran que este fue el mejor ejemplo que le dieron de Abstracción en la programación orientada a objetos.

Para aquellos que quieran separar las clases del fichero donde se encuentra el método main, pueden crear normal su fichero aparte ejemplo “otroarchivo.cpp” y el el fichero donde se encuentra el metodo main lo pueden incluir donde van las librerias de la siguiente forma: #include “otroarchivo.cpp”. A mi me funciono de esta forma.

Bastante raro que no haya instanciado las variables luck y social level y aun asi haya entrado en ese if.

Puedo afirmar que abstracción es el proceso de dividir la informaicón y funciones del código en dos grupos: Privadas y Públicas. Las informaciones y funciones públicas son aquellas que pueden estar al alcance del usuario permitiendo ejecutar sus actividades, Ya las informaciones y funciones privadas están fuera del alcance del usuario impidiendo que sean modificadas.

Creo que el entendimiento de la abstracción en si puede llegar a ser muy abstracto.

Yo trabajo mucho con IoT en el colegio, y esto es fundamental.
Gracias por hacerlo tan facil de entender 😄

#include <iostream>

using namespace std;

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

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

private:

    int SocialLevel;
    int Inteligence;
    int Luck;

    string GetThinkingMessage()
    {
        if(SocialLevel + Luck > 100)
        {
            return "Estoy teniendo pensamientos felies";
        }
        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;
}

HECHO

#include <iostream>
using namespace std;
class Humanos
{
public:
    Humanos(int M_edad)
    {
     edad= M_edad;
    }

    void think()
    {
     cout << GetThink() << endl;
    }


    int edad;
private:
    int socialLevel;
    int inteligencia;
    int suerte;

    string GetThink()
    {
        if (socialLevel+suerte>100)
        {
        return "estoy feliz";
        }
        else if(suerte>inteligencia)
        {

        return " soy un suertudo";

        }
        else if(edad>18)
        {
            return "soy un bebe";
        }
        else{ return "no pienso";}

    }
};
int main()
{
    Humanos Bob (19);
    Bob.think(); //aunque hacemos pensar a Bob, no sabemos que es lo que esta pasando adentro.
    return 0;
}

¿Qué es abstracción?
En lenguajes de programación es usado para enseñarle al usuario solo los datos esenciales y esconder el funcionamiento y datos innecesarios de él.

Es muy importante entender qué es exáctamente lo que ocupamos que sea público en nuestra clases.

Muy bien

muy buen clase se entido todo

Pregunta… abstraccion no tiene que ver con crear clases que no pueden ser instanciadas?, que solo se usan para generar clases hijas que implementen sus variables y su metodos ? en clases de JAVA me lo explicaron de esta manera…

*Mis apuntes sobre: “Abstracción”:

En lenguajes de programación es usado para enseñarle al usuario solo los datos esenciales y esconder el funcionamientos y datos innecesarios de él.

Ejemplo de código:

#include <iostream>

using namespace std;

class Human
{
public:
    Human(int spawnAge)
    {
        age=spawnAge;
    }
    void think()
    {
        cout<<getThinkMessage()<<endl;
    }
    int age;
private:
    int socialLevel,intelligence,luck;
    string getThinkMessage()
    {
        if(socialLevel+luck>100)
        {
            return "I'm having happy thoughts! :D";
        }
        else if(luck>intelligence)
        {
            return "I'm very lucky!";
        }
        else if(age>18)
        {
            return "I'm a baby";
        }
        else
        {
            return "I don't think anything!";
        }
    }
};

int main()
{
    Human bob(19);
    bob.think();
    return 0;
}

supongamos que la experiencia al matar a un villano es privado y no lo puedo alcanzar como usuario. Pero, si este fuera publico… ¿Como es que yo como usuario podría llegar a estos para cambiarlos sin ir al código?, es decir… desde la propia interfaz del juego !! si en la interfaz no pongo ninguna opción de cambiar xp)?

Hecho!!!

#include <iostream>

using namespace std;

class Human
{
public:

    Human (int SpawnAge)
    {
        Age = SpawnAge;
    }

    void Think ()
    {
        cout << GetThingMessage()<<endl;
    }
    int Age;
private:
    int SocialLevel;
    int Inteligence;
    int Luck;

    string GetThingMessage ()
    {
        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 bebe";
        }
        else
        {
            return "No pienso nada";
        }
    }
};

int main()
{
    Human Bob(19);

    Bob.Think();

}```

La Abstracción siempre es un tema que me ha parecido difícil de entender pero, en este vídeo, se explica bastante bien.

Abstarcción: Es esconder el funcionamiento de ciertas cosas para que el programador no tenga que preocuparse de ello, es algo como construir una casa alguien puede comprar los materiales y hacerla por sí mismo, pero jamás tuvo ni idea de cómo se realiza la elaboración de los materiales que uso vidrios, ladrillo, el cemento…

Human y Bob me recordaron a los nombres por defecto del ARK, por cierto excelente explicación

#include <iostream>

using namespace std;

class Humano
{
public:
    Humano(int spawnAge)
    {
        Age = spawnAge;
    }

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

    int Age;

private:

    int NivelSocial;
    int Suerte;
    int Inteligencia;

    string GetThinkMessage()
    {
        if (NivelSocial + Suerte > 100)
        {
            return "estoy teniendo pensamientos felices =D";
        }
        else if (Suerte > Inteligencia)
        {
            return "Soy un suertudo";
        }
        else if (Age < 18)
        {
            return "soy un bebe";
        }
        else{
            return "no pienso nada";
        }
    }
};

int main()
{
    Humano Jose(31);
    Jose.Think();

    return 0;
}
#include <iostream>

using namespace std;


class Human
{
public: //estaran los datos y funciones publicas
     Human (int SpawnAge)//constructor que nos pida la EDAD
     {
       Age = SpawnAge; //informacion que esta expuesta
     }
     int Age;

     void Pensar ()
     {
         cout<< Devolverpensarelmensaje ()<< endl;
     }
private:// lo que no quiero que vean pero hara calculos necesarios para la clase
  int SocialLevel;
  int Inteligence;
  int Lunk;

  string Devolverpensarelmensaje ()
  {
     if (SocialLevel + Lunk > 100)
     {
         return "Im great happies thinking :D ";
     }
     else if (Lunk > Inteligence)
     {
        return "Soy un suertudo!" ;
     }
     else if (Age > 18)
     {
         return "I'm a baby";
     }
     else
     {
         return "no pienso NADA";
     }
  }
};
int main()
{
    Human Cuchito(31);
    Cuchito.Pensar(); //no pueden ser llamadas desde afuera
    return 0;
}
#include <iostream>

using namespace std;

class Humano{
public:
    int Edad;
    Humano(int NuevaEdad){
        Edad=NuevaEdad;
    }
    void Pensar(){
        cout<<OPensamiento()<<endl;
    }
private:
    int NivelSocial;
    int Inteligencia;
    int Suerte;
    string OPensamiento(){
        if (NivelSocial>100){
            return "Pensamientos positivos";
        }
        else if(Suerte>Inteligencia){
            return "Soy suertudo";
        }
        else if(Edad<18){
            return "soy un nene";
        }else{
            return "no pienso en nada";
        }
    }
};

int main()
{
    Humano Bob(9);
    Bob.Pensar();
}```
#include<iostream>

using namespace std;

class Human{
	public:
	    int age;
	    Human(int newAge){
	        age=newAge;
	    }
	    void think(int levelSocial){
	        cout << getThinkMessage(levelSocial) << endl;
	    }
	private:
	    int levelSocial;
	    int inteligence;
	    int luck;
	    string getThinkMessage(int levelSocial){
	        if (levelSocial > 100){
	            return "Pensamientos positivos";
	        }
	        else if(luck>inteligence){
	            return "Soy suertudo";
	        }
	        else if(age < 18){
	            return "soy un nene";
	        }else{
	            return "no pienso en nada";
	        }
	    }
};

int main()
{
	int levelSocial = 101;
    Human Bob(50);
    Bob.think(levelSocial);
}

Lo usaba siempre y no sabia que eso era la abstracción jaja Muy buena clase

#include <iostream>

using namespace    std;


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

    void think(){
        cout<<GetThinkMessage()<<endl;
    }
//-------------------------FIN PUBLIC----------------------------
    private:
 
 
    int SocialLevel=0;
    int Inteligence=0;
    int Luck=0;   
    string GetThinkMessage(){
        if(SocialLevel + Luck > 100){
            cout<<SocialLevel<<endl;
            return "Im so happy";
            

        }else if(Luck>Inteligence)
        {
            return "Im lucky";
        }else if(Age>18)
        {
            return "Ya soy legal osiosi";
        }else
        {
            return "...";
        }
    }
};

int main(int argc, char const *argv[])
{
    human bob(15);
    bob.think();

    return 0;
}

En resumen, entonces decimos que la encapsulación es el ocultamiento de información (lo que se puede ver y a lo que se puede acceder y modificar) mientras la abstracción es esconder el funcionamiento interno de una acción, nos permite ver QUE hace, pero no COMO lo hace.

#include<iostream>

using namespace std;

class Human
{
public:
    int age;
    Human(int);
    void think();
private:
    int SocialLevel, lucky, Inteligence;
    string getThinMessage();

};
Human::Human(int _age){
    age=_age;
}
string Human::getThinMessage(){
    if(SocialLevel+Inteligence>100){
        return "Estoy emocionado";
    }else if (Inteligence<lucky){
        return "Soy un suertudo";
    }else if(age>18){
        return "Soy un mayor de edad yeah!";
    }else{
        return "....";
    }
}
void Human::think(){
    cout<<getThinMessage()<<endl;
}

int main()
{
    Human bob(15);
    bob.think();

    return 0;
}

Abstraccion: Se basa en ocultar procesos que pueden manipular agentes externos, como por ejemplo un video juego, donde creamos unos mobs que al derrotarlos ganamos exp, estos parametros de cuanta xp ganaremos por derrotarlos necesitamos ocultarlos, para que el jugador unicamente tenga acceso a las funcionalidades de como moverse atacar, etc.

Yo aprendi en mi universidad con el lenguaje de Programacion en Java que abstraccion era un metodo que se comportaba de diferente manera por ejemplo
El metodo ladrar() se puede usar tanto para un gato y perro ,pero su sonido sera muy diferente entre ambos

#include <iostream>

using namespace std;
class chiken
{
public:

    chiken(string iname)
    {
        name = iname;
    };
    void tweet()
    {
        cout<<name<< " dice: pio pio ";
    };
     void think()
   {
     cout <<getThink()<< endl;
   }
    int sentimientos()
   {
     return hambre, sed, miedo, aburrido;
   }
private:
   string name;
   int hambre;
   int sed;
   int miedo;
   int aburrido;

   string getThink()

   {
       if (hambre + sed > 100)
       {
           return "dame de 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";
        }

   }


};
int main()
{
    chiken first("gallosky");
    chiken second("bolita");
    cout<< first.sentimientos ()<< endl;
        cout<< second.sentimientos ()<< endl;

    for (int i = 0; i < 2; i++)
    {
        first.tweet();
        first.think();

        second.tweet();
         second.think();
    }
    return 0;
}
#include <iostream>

using namespace std;

class Human{
public:
    int Age;

    Human(int SpawnAge){
        Age = SpawnAge;
    }

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

private:

    int SocialLevel;
    int Intelligence;
    int Luck;

    string GetThinkMessage(){
        if (SocialLevel + Luck > 100){
            return "Estoy teniendo pensamientos felices";
        }else if(Luck > Intelligence){
            return "Soy muy suertudo";
        }else if(Age > 18){
            return "Ya soy mayor de edad";
        }else{
            return "No se me ocurre nada";
        }
    }
};

int main()
{
    Human Fer(19);
    Fer.Think();

    return 0;
}

Deberian de anadir el codigo que se utilizo en esta clase

Ejemplo de Abstraccion

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
class Humano {
public:
	Humano(int edadClase) {
		edad = edadClase;
	}
	int edad;

	void pensar() {

		cout << getMensajePensamiento() << endl;
	}

private:
	int socialLevel;
	int intellegenceLevel;
	int luckLevel;

	string getMensajePensamiento() {
		if (socialLevel + luckLevel > 100) {
			return "Estoy teniendo pensamientos buenos :D\n";
		}
		else if (luckLevel > intellegenceLevel) {
			return "Soy un suertudo\n";
		}
		else if (edad > 18) {
			return "No hay delito\n";
		}
		else {
			return "Soy un zurdo que no piensa nada\n";
		}
	}
};

int main() {

	Humano Marcos(19);
	Marcos.pensar();
return 0;
}

Dejo este PDF que tiene un resumen bastante completo y fácil de entender que encontré

Pets 😄

#include <iostream>
using namespace std;

class Pets
{
   public:

   string name;
   int edad;

   Pets(string itype, string iname, int iedad)
   {
       type = itype;
       name = iname;
       edad = iedad;
   }

      void hablar()
   {
       cout << GetResultado() << endl;
   }

   string Gettype()
   {
     return type;
   }
   int Getedad()
   {
       return edad;
   }

   private:

   string type;

    string GetResultado()
    {
       if(edad >= 10)
       {
        return "Soy una mascota adulta :D";
       }
       else if(edad < 10 && 0 < edad)
       {
        return "Soy un cachorrito :D";
       }
       else if(edad > 20 || edad < 0)
       {
        return "No es posible que tenga esa edad :0";
       }
       else
       {
        return "Esa no es una edad correcta :/";
       }
    }
};

int main()
{
    Pets pet1("Perro", "Boby",8);

    cout << "Tipo de mascote: " << pet1.Gettype() << endl;
    cout << "Nombre: "<< pet1.name << endl;
    cout << "Poder: "<< pet1.Getedad() << endl<< endl;
    pet1.hablar();

    return 0;
}

**Resultado **

Esto me ayudo mucho a entender mejor la abstracción:

Sabes como usar el teléfono, como interactuar con el; pero no sabes exactamente como funciona, de que forma tus toque se convierten en órdenes.

Gracias por la clase.

gracias