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

Encapsulación

32/47
Recursos

La encapsulación es el proceso de combinar datos y métodos en una misma clase para evitar que sean modificados directamente por factores externos, debemos restringir la modificación de algunas propiedades sin dejar la posibilidad de acceder a todos nuestros datos (debemos permitir la lectura pero no la modificación).

Aportes 34

Preguntas 4

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

🔥 Naming Conventions in C++ 🔥

  • La regla de oro es que siempre debes sentirte a gusto con tus reglas, de caso contrario, no sirven para nada y solo retrasan tu trabajo 🔪
  • A mi me gusta así: 🌵 PascalCase para las clases, 🐫 camelCase para las instancias de las clases y otras variables, 🐍 snake_case para las funciones y UPPER_SNAKE_CASE para las constantes (cosas que --en teoría-- nunca cambian en toda la ejecución del programa) 🎉

move files around until it feels right
-Dan Abramov in React File Structure

Hecho!!!

#include <iostream>

using namespace std;

class Dog
{
public:

    Dog (string Name, string BarkType)
    {
        mName = Name;
        mBark = BarkType;
    }

    string GetName ()
    {
        return mName;
    }

    void SetName (string newName)
    {
        mName = newName;
    }
    void Bark ()
    {
        cout << mBark << endl;
    }
private:
    string mName;
    string mBark;
};

int main()
{
    Dog PerroUno ("Prika", "Guao");
    cout << PerroUno.GetName() << endl;
    PerroUno.Bark();

    Dog PerroDos ("Dino", "Woof");
    cout << PerroDos.GetName() << endl;
    PerroDos.Bark();

}```

Resumen:

#include <iostream>

using namespace std;

class Perro
{
public:
	void SetNombre(string nombre)
	{
		this->nombre = nombre;
	}

	string GetNombre()
	{
		return this->nombre;
	}
private:
	string nombre;
};

int main()
{
	Perro PrimerPerro;

	PrimerPerro.SetNombre("Kira");

	cout << PrimerPerro.GetNombre();
}
#include <iostream>

using namespace std;

class Car
{
public:
    Car(string brand, string accelerate)
    {
        m_brand = brand;
        m_accelerate = accelerate;
    }

    string get_brand()
    {
        return m_brand;
    }

    void set_brand(string new_brand)
    {
        m_brand = new_brand;
    }

    void accelerate()
    {
        cout << m_brand << " vroom!" << endl;
    }

private:
    string m_brand;
    string m_accelerate;
};

int main()
{
    Car CocheUno("Fiat", "vroom!");

    CocheUno.set_brand("Abarth");

    Car CocheDos("Seat", "vroom!");

    CocheDos.accelerate();

    CocheUno.accelerate();

    return 0;
}
#include <iostream>

using namespace std;

class Dog {
    private:
        string name;
        string mBark;

    public:
        Dog( string _name, string _barkType ) {
            name = _name;
            mBark = _barkType;
        }

        string getName() {
            return name;
        }

        void setName(string _name) {
            name = _name;
        }

};

int main() {

    Dog perro1("Woofers", "berk");
    cout << "Nombre: " << perro1.getName() << endl;

    perro1.setName("Pierre");
    cout << "Nombre: " << perro1.getName();



    return 0;
}

Los ejemplos con gatitos y perritos son lo maximo!!

Una clase muy bien explicada

**public **: otras clases pueden acceder a ella
private : solo la clase en la que fue declarada puede acceder a ella
protective : solo la clase , los objetos y las clases heredadas pueden acceder ella

Encapsulamiento= Privar de ciertos accesos a cualquier persona que desee acceder a los datos de algún elemento de la clase.

#include <iostream>

using namespace std;

class Dog{
public:

    string mBark;

    Dog(string Name,string BarkType){
        mName= Name;
        mBark= BarkType;

    }

    string GetName(){

    return mName;
    }

private:
    string mName;
};

int main()
{

    Dog PerroUno("dante","wuau");
    cout<<PerroUno.GetName()<<" dice "<< PerroUno.mBark<< endl;

    Dog PerroDos("comodoro","ladrido");

    cout<<PerroDos.GetName()<<" dice "<< PerroDos.mBark<<endl;

    return 0;
}

Mi Aporte de como entendi la clase, espero les sirva

#include<iostream>
using namespace std;

class Dog
{
    public:
        string mBark;

        Dog(string Name, string BarkType)
        {
            mName = Name;
            mBark = BarkType;
        }
        string GetDogName()
        {
            return mName;
        }
        void SetDogName(string NewDogName)
        {
            mName = NewDogName;
        }
    private:
        string mName;
};

int main()
{
    string dogename;
    Dog OneDog("Woofers", "Berk");
    Dog TwoDog("Toppy","Woof");
    cout<<"Set a Dog Name:"<<endl;
    cin>>dogename;
    TwoDog.SetDogName(dogename);
    cout<< OneDog.GetDogName()<<endl;
    cout<<TwoDog.GetDogName()<<endl;
    return 0;
}

/*El encapsulamiento es en Basico
-Proteger una Variable de la clase para que no pueda ser modificada
-Crearle un metodo a la clase protegida para permitir la consulta libre
-Si se necesita manipular el Dato, se crea una funcion(encapsulado) donde permita modificarlo
asi sabemos que solo esa funcion es la que permite o pasa la modificacion del dato
-tenemos mejor rastreabilidad de donde se esta haciendo que cosa.
*/```

Hecho !!

#include <iostream>

using namespace std;

class Dog
{
public:


    Dog(string name, string bark)
    {
        mname = name;
        mbark = bark;
    }

    string Getname()
    {
        return mname;
    }

    void Setname(string newname)
    {
        mname=newname;
    }

    void bark()
    {
        cout<<mbark<<endl;
    }

private:
        string mname;
        string mbark;
};

int main()
{
        Dog Prro1("juanito", "berk");
        Prro1.Setname("samano");

        Dog Prro2("cuachi","woof");

     cout<<Prro1.Getname()<<endl;

     cout<<Prro2.Getname()<<endl;

     Prro1.bark();
     Prro2.bark();

       return 0;
}```
/*
    Compilar así: clang++ -std=c++11 source.cpp -o source.out     
*/

#include <iostream>

using namespace std;

class Dog {
private:
    string name;
    string barkType;
public:

    // Default Constructor
    Dog () {
        name = "dog";
        barkType = "Guau";
    }

    // Overrride Constructor
    Dog (string newName, string newBarkType) {
        name = newName;
        barkType = newBarkType;
    }

    // Accesor Functions
    string GetName () const {
        return name;
    }

    // Mutator Functions
    void SetName (string newName) {
        name = newName;
    }
};

int main() {

    Dog PerroUno ("Woofers", "berk");
    cout << PerroUno.GetName() << endl;

    PerroUno.SetName("Poopy");
    cout << PerroUno.GetName() << endl;

    return 0;
}
#include <iostream>

using namespace std;
class Dog
{
public:


    Dog(string name, string barktype)
    {
        mname=name; //almacena la informacion
        mbark= barktype;
    }
    string Getname()
    {
        return mname;
    }
    void Setname(string newname) //funcion para cambiar el nombre
    {
        mname = newname;
    }
    void Bark ()
    {
       cout<< mbark<< endl;
    }
private:
    string mname; //es privado para que no pueda CONFIGURAR y tiene ingreso  limitado
    string mbark;
};
int main()
{
    Dog Perrouno("alvin","wouu");
    Perrouno.Setname("cucho"); //es independiente
    Dog Perrodos("alex","afuuafuu");
    cout << Perrouno.Getname()<< endl;
    cout << Perrodos.Getname()<< endl;
     Perrouno.Bark();
     Perrodos.Bark();


    return 0;
}
#include <iostream>

using namespace std;

class HelicopteroApache{
public:
    HelicopteroApache(string marca, string rango){//constructor
        mMarca=marca;
        mRango=rango;
    }
    string OMarca(){//Obtener nombre
        return mMarca;
    }
    void CMarca(string NuevaMarca){//Cambiar nombre
        mMarca=NuevaMarca;
    }
    void ORango(){
        cout<<mRango<<endl;
    }
private:
    string mRango;//miembro rango
    string mMarca;//miembro nombre
};

int main()
{
    HelicopteroApache hA1("Reforzado","Destructor Estrella");
    HelicopteroApache hA2("Buscador","veloz");
    cout<<hA1.OMarca()<<endl;
    hA1.CMarca("volador discreto");
    cout<<hA1.OMarca()<<endl;
    cout<<hA2.OMarca()<<endl;
    hA1.ORango();
    hA2.ORango();
    return 0;
}```

#include <iostream>

using namespace std;

class clase{
public:
clase(string datoe){
dato = datoe;
}
string cdato(){
return dato;
}
void mdato(string cambio){
dato = cambio;
}
void idato(){
cout << dato << endl;
}
private:
string dato;
};

int main()
{
string vdato;
cout << “ingrese dato :”;
cin >> vdato;

clase instancia(vdato);
cout << instancia.cdato() << endl;
instancia.mdato("cambiado ");
instancia.idato();
return 0;

}

#include <iostream>


using namespace std;

class Cat
{
public:

    


    Cat(){
        Name="Wapa";
    }


    Cat (string IName){

        Name=IName;
    }
    void miau(){
        cout<<Name<<":  Miau miau "<<endl;
    }

    string GetCatName(){
        return Name;
    }

private:    
    string Name;

    void defName(string PName)
    {
        Name=PName;
    }
};



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

    cout<<MyFirstkitty.GetCatName()<<endl;

    Cat MySecondGato("Michi22");
    cout<< MySecondGato.GetCatName()<<endl;

    MySecondGato.miau();
    return 0;
}

Si mi memoria no me falla, aqui encapsulo la variable name y una vez asignado el nombre solo puede ser accedido de modo lectura desde el main.

#include <iostream>

using namespace std;

class personas
{
private:
    string name;
    string age;
public:
    personas(string, string);
    void setname(string, string);
    string getname();
    string getage();
    void plantilla();
    void imprimir();

};
personas::personas(string  _name, string _age)
{
    name= _name;
    age= _age;
}
void personas::setname(string  _name, string _age)
{
    name = _name;
    age = _age;
}
string personas::getname()
{
    return name;
}
string personas::getage()
{
    return age;
}
void personas::imprimir()
{
    cout<<"Nombre: "<<name<<" "<<"Age: "<<age<<endl;
}
void presentacion();
int main()
{

    presentacion();
    return 0;

}
void presentacion()
{
    personas p1("pedro","14");
    p1.imprimir();
    cout<<" "<<endl;
    p1.setname("raul","15");
    cout<<"Nombre: "<<p1.getname();
    cout<<"   "<<"Age: "<<p1.getage()<<endl;
}

Propiedades privadas: Son atributos o metodos de una clase, que no pueden ser modificadas por agentes externos, lo que se refiere a una encapsulacion

Encapsulación: Es el proceso de diseñar nuestra clase para que los valores o los datos que se almacenen sean modificados por factores externos
Nota: Esto se hace gracias al principio del menor privilegio, no darle el poder de acceder a una variable, objeto, etc. si no es necesario.

Mi version!.

#include <iostream>

using namespace std;

// Creamos la clase
    class Dog
    {
        public:

            // Funcion que asigna valor a las variables
            Dog(string Name, string BarkType)
            {
                mName = Name;
                mBark = BarkType;
            }

            // Agreando metodo para que retorne el valor del nombre en pantalla y se pueda modificar
            string GetName()
            {
                return mName;
            }
            string GetBark()
            {
                return mBark;
            }

            // Funcionalidad para cambiar el nombre del perro
            void SetName(string NewName)
            {
                mName = NewName;
            }

        private:
            string mName;
            string mBark; // ladrido
    };

int main()
    {
        Dog PerroUno("Cacho","Berk");
        cout << PerroUno.GetName();
        cout << " " + PerroUno.GetBark() + "!" << endl;
        // Como esta encapsulado del dato no permite modificarlo
        //PerroUno.Mname = "Poopy";

        // Pero si utilizamos la funcionalidad para cambiar el nombre del perro si nos permite
        PerroUno.SetName("Popy");
        // Retornamos el valos de nombre modificado
        cout << PerroUno.GetName();
        cout << " " + PerroUno.GetBark() + "!" << endl;

        // Agregando un segundo perro
        Dog PerroDos("Morena","Guau");
        cout << PerroDos.GetName();
        cout << " " + PerroDos.GetBark() + "!" << endl;

        return 0;
    }
#include <iostream>

using namespace std;

class Dog{
public:

    Dog(string Name, string Bark){
        dogName = Name;
        dogBark = Bark;
    }

    string GetName(){
        return dogName;
    }

    string GetBark(){
        return dogBark;
    }

    void SetName(string NewName){
        dogName = NewName;
    }
private:
    string dogName;
    string dogBark;
};

int main()
{
    Dog Scooby("Scooby Doo", "Scooby doo bi doo");
    Dog Snoop("SnoopDogg", "Bow wow wow yippy-yo yippy-yay");
    cout << "Este perro se llama " << Scooby.GetName();
    cout << " y ladra asi: " << Scooby.GetBark() << endl;
    cout << "Este perro se llama " << Snoop.GetName();
    cout << " y ladra asi: " << Snoop.GetBark() << endl;

    return 0;
}

Una pregunta, el constructor debe ir siempre en la sección pública de la clase?

Este es mi código, espero les sirva para seguir aprendiendo…
Esta un poco mas organizado y con mas cosillas, échale mano!

#include <iostream>

using namespace std;

class Dog{

public:

    //Constructor Function
    Dog(string Name, string BarkType){
        mName = Name;
        mBark = BarkType;
    }

    //Get Name Function
    string GetName(){
        return mName;
    }

    //Get Bark Function
    string GetBark(){
        return mBark;
    }

    //Set Name Function
    void SetName(string NewName){
        mName = NewName;
    }

    //Set Bark Function
    void SetBark(string NewBark){
        mBark = NewBark;
    }

//Private Data
private:
    string mName;
    string mBark;

};

int main()
{
    cout << "Dog 1" <<endl;

    //Initial Dog (iam God xd)
    Dog Dog1("Dog 1 default name", "Dog 1 default bark");

    //Print Dog Data
    cout << Dog1.GetName() << endl;
    cout << Dog1.GetBark() << endl;

    //Set Dog Data
    Dog1.SetName("Dog 1 New Name");
    Dog1.SetBark("Dog 1 New Bark");

    //Print Dog Update
    cout << Dog1.GetName() << endl;
    cout << Dog1.GetBark() << endl;

    cout <<endl;

    cout << "Dog 2" <<endl;

    //Initial Dog (iam God xd)
    Dog Dog2("Dog 2 default name", "Dog 2 default bark");

    //Print Dog Data
    cout << Dog2.GetName() << endl;
    cout << Dog2.GetBark() << endl;

    //Set Dog Data
    Dog2.SetName("Dog 2 New Name");
    Dog2.SetName("Dog 2 New Bark");

    //Print Dog Update
    cout << Dog2.GetName() << endl;
    cout << Dog2.GetBark() << endl;

    cout << endl;

    //Very pretty isn't it
    cout << "End :D" <<endl;

    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class Perro {
public:
	
	Perro(string nombre, string tipoLadrido) {

		mNombre = nombre;
		mLadrido = tipoLadrido;

	}

	string getName() {
		return mNombre;
	}

	void setName(string newNombre) {
		mNombre = newNombre;
	}

	void ladrar() {
		cout << mLadrido << endl;
	}

private:

	string mNombre;
	string mLadrido;
};

int main() {

	Perro Perro1("Wolf", "woof");

	Perro Perro2("Tesla", "Pikaaaa");
	
	cout << Perro1.getName() << endl;
	cout << Perro2.getName() << endl;

	Perro1.ladrar();
	Perro2.ladrar();
return 0;
}```

Encapsulamiento:
.
Es el proceso de almacenar en una misma sección los elementos de una abstracción que constituyen su estructura y su comportamiento; sirve para separar el interfaz contractual de una abstracción y su implantación.
.
.
Existen tres niveles de acceso para el encapsulamiento:
.
Público (Public): Todos pueden acceder a los datos o métodos de una clase que se definen con este nivel, este es el nivel más bajo, esto es lo que tu quieres que la parte externa vea.
.
Protegido (Protected): Podemos decir que estás no son de acceso público, solamente son accesibles dentro de su clase y por subclases.
.
Privado (Private): En este nivel se puede declarar miembros accesibles sólo para la propia clase.

.
.

buena explicacion

buena clase

Mis mascotas hablando 😄
El dato de tipo de mascota esta encapsulada pero tiene la función que permite manipular el dato.

<#include <iostream>
using namespace std;

class pets
{
   public:

    string name;

    pets(string itype, string iname)
    {
      type = itype;
      name = iname;
    }

    void hablar()
    {
        cout << name << " Dice: Hola soy un " << type <<endl<<endl;
    }

    string Gettype()
    {
      return type;
    }
    void Settype(string Newtype)
    {
        type = Newtype;
    }

   private:
    string type;
};

int main()
{
 pets mascota1("Perro","Scooby");
 pets mascota2("Gato", "Cosmico");

 cout << "Tipo de mascota: " << mascota1.Gettype() << endl;
 cout << "Nombre: " << mascota1.name <<endl<<endl;
 mascota1.hablar();

 cout << "Tipo de mascota: " << mascota2.Gettype() << endl;
 cout << "Nombre: " << mascota2.name <<endl<<endl;
 mascota2.hablar();

 return 0;
}>

Resultado 😄

Es una gran idea explicar cómo funciona el código, el por qué de las lineas después de haber implementarlo. Excelente profesor 😄

*Mis apuntes sobre: “Encapsulación”

Es un proceso de combinar datos y métodos en un misma clase, evitando que sean modificados directamente por factores externos.

Ejemplos:

#include <iostream>

using namespace std;

class Dog
{
public:
    Dog(string name, string barkType)
    {
        mName=name;
        mBark=barkType;
    }
    string getName()
    {
        return mName;
    }
    void bark()
    {
        cout<<mBark<<endl;
    }
    void setName(string newName)
    {
        mName=newName;
    }
private:
    string mName, mBark;
};
int main()
{
    Dog dogOne("Woofers","berfs");
    Dog dogTwo("Comodore","woof");
    dogOne.setName("Puppy");
    cout<<dogOne.getName()<<endl;
    cout<<dogTwo.getName()<<endl;
    dogOne.bark();
    dogTwo.bark();
    return 0;
}

Gracias!

# include <iostream>


using namespace std;

class Dog
{
public:

    Dog(string Name, string BarkType)
    {
        mName = Name;
        mBark = BarkType;
    }

    string getName()
    {
        return mName;
    }

    void setName(string NewName)
    {
        mName = NewName;
    }

    void Bark()
    {
        cout << mBark << endl;
    }

private:
    string mName;
    string mBark;
};


int main()
{
    Dog PerroUno("Woofers", "berk");
    cout << PerroUno.getName() << endl;
    PerroUno.Bark();

    PerroUno.setName("Poopy");
    cout << PerroUno.getName() << endl;
    PerroUno.Bark();

    Dog PerroDos("Comodoro", "woof");
    cout << PerroDos.getName() << endl;
    PerroDos.Bark();

    return 0;
}