Encapsulación de Datos en Programación Orientada a Objetos

Clase 32 de 47 • Curso Práctico de C++

Contenido del curso

Introducción a C++

Conceptos Generales de C++

3
Historia y uso del compilador GCC en programación
01:43 min

Preparando el entorno de trabajo

Manejo de memoria

Entrada de datos y funciones

Loops y arreglos

Lectura de Archivos

Programación Orientada a Objetos

Finalizando nuestro proyecto

Tomar examen

Resumen

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).

Comentarios

Yasser Pulido

student•

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

Manuel Alejandro Aguilar Téllez Girón

student•

Hola, gracias por el aporte pero ¿qué rayos es el this?

El profe no lo tiene en su código.

Carlos Bolivar

student•

El this hace referencia a la variable de la clase, de esta manera le indicas al programa que this->nombre pertenece a la clase Perro y la variable nombre sin el this, es la que recibes por parametro!

Elena Nuñez Malledo

student•

Hecho!!!

#include &lt;iostream&gt;

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 &lt;&lt; mBark &lt;&lt; endl;
    }
private:
    string mName;
    string mBark;
};

int main()
{
    Dog PerroUno (&quot;Prika&quot;, &quot;Guao&quot;);
    cout &lt;&lt; PerroUno.GetName() &lt;&lt; endl;
    PerroUno.Bark();

    Dog PerroDos (&quot;Dino&quot;, &quot;Woof&quot;);
    cout &lt;&lt; PerroDos.GetName() &lt;&lt; endl;
    PerroDos.Bark();

}```

Jeyson David Vargas Crespo

student•

Mi pregunta va orientada a esta parte del código:

dog(string name, string barkType) { mName = name; mBark = barkType; }

Porque igualar mName = name; y mBark = barkType;

Muchas gracias por su ayuda.

Carlos Nassif Trejo Garcia

student•

El de la izquierda es la variable de tu clase, mientras que el de la derecha es la variable de entrada por el parámetro.

Puedes cambiarlos por los nombres que tu quieras, solo que sea consistentes

Iván Jiménez Paz

student•

name y barkType es el nombre de acceso a tu constructor, mientras que mName y mBark es donde se va a almacenar esa información.

Federico Moreno

student•

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

Carlos Nassif Trejo Garcia

student•

#include &lt;iostream&gt;

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(&quot;Woofers&quot;, &quot;berk&quot;);
    cout &lt;&lt; &quot;Nombre: &quot; &lt;&lt; perro1.getName() &lt;&lt; endl;

    perro1.setName(&quot;Pierre&quot;);
    cout &lt;&lt; &quot;Nombre: &quot; &lt;&lt; perro1.getName();



    return 0;
}

Martin Gonzalez

student•

Los ejemplos con gatitos y perritos son lo maximo!!

Jose Antonio Rojas Ollarves

student•

Este principio se aplica igualmente cuado creamos una funcion private a una public cierto?

Aaron Joel Limachi Quispe

student•

Si, también funciona.

Jeyson David Vargas Crespo

student•

Hola, son necesarias crear las variables miembro afuera del método constructor o se pueden nombrar iguales???

Sebastian Andree Lopera Quevedo

student•

Las variables, es decir los objetos de la clase que tendrá cada instancia (cada perro) son eso, objetos. El contructor es la función que se lanza inmediatamente se crea una nueva instancia junto con sus propiedades. Imaginatelo como a ti: tienes boca, que es una propiedad, tienes el metodo comer y tu primera acción al existir, tu constructor, es respirar; claro que para comer necesitas la boca pero no se la crea en la acción.

Agustin Isaias Salinas Quinteros

student•

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

Jose Antonio Rojas Ollarves

student•

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

Hector Esau M

student•

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.

Jose Antonio Rojas Ollarves

student•

Creo que quisiste decir "no sean modificados por factores externos".

Dilan Santiago Ariza Cañon

student•

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

Martin Tercero

student•

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

Jose Morales Varon

student•

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

Angel Daniel Montes Villarreal

student•

#include &lt;iostream&gt;

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(&quot;dante&quot;,&quot;wuau&quot;);
    cout&lt;&lt;PerroUno.GetName()&lt;&lt;&quot; dice &quot;&lt;&lt; PerroUno.mBark&lt;&lt; endl;

    Dog PerroDos(&quot;comodoro&quot;,&quot;ladrido&quot;);

    cout&lt;&lt;PerroDos.GetName()&lt;&lt;&quot; dice &quot;&lt;&lt; PerroDos.mBark&lt;&lt;endl;

    return 0;
}

Sergy Lopez Moreno

student•

Mi Aporte de como entendi la clase, espero les sirva

#include&lt;iostream&gt;
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(&quot;Woofers&quot;, &quot;Berk&quot;);
    Dog TwoDog(&quot;Toppy&quot;,&quot;Woof&quot;);
    cout&lt;&lt;&quot;Set a Dog Name:&quot;&lt;&lt;endl;
    cin&gt;&gt;dogename;
    TwoDog.SetDogName(dogename);
    cout&lt;&lt; OneDog.GetDogName()&lt;&lt;endl;
    cout&lt;&lt;TwoDog.GetDogName()&lt;&lt;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.
*/```

Jesus Daniel Martinez Bautista

student•

Hecho !!

#include &lt;iostream&gt;

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&lt;&lt;mbark&lt;&lt;endl;
    }

private:
        string mname;
        string mbark;
};

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

        Dog Prro2(&quot;cuachi&quot;,&quot;woof&quot;);

     cout&lt;&lt;Prro1.Getname()&lt;&lt;endl;

     cout&lt;&lt;Prro2.Getname()&lt;&lt;endl;

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

       return 0;
}```

Ricardo Rito Anguiano

student•

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

Ricardo Rito Anguiano

student•


    voiddefName(string PName)
    {
        Name=PName;
    }

Esa parte del codigo no iba :v

Rafael Arteaga

student•

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

Wilmer Gaona Romero

student•

/*
    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 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 &lt;iostream&gt;

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 &lt;&lt; mBark &lt;&lt; endl;
    }
private:
    string mName;
    string mBark;
};

int main()
{
    Dog PerroUno (&quot;Prika&quot;, &quot;Guao&quot;);
    cout &lt;&lt; PerroUno.GetName() &lt;&lt; endl;
    PerroUno.Bark();

    Dog PerroDos (&quot;Dino&quot;, &quot;Woof&quot;);
    cout &lt;&lt; PerroDos.GetName() &lt;&lt; endl;
    PerroDos.Bark();

}```

#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 &lt;iostream&gt;

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(&quot;Woofers&quot;, &quot;berk&quot;);
    cout &lt;&lt; &quot;Nombre: &quot; &lt;&lt; perro1.getName() &lt;&lt; endl;

    perro1.setName(&quot;Pierre&quot;);
    cout &lt;&lt; &quot;Nombre: &quot; &lt;&lt; perro1.getName();



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

#include &lt;iostream&gt;

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(&quot;dante&quot;,&quot;wuau&quot;);
    cout&lt;&lt;PerroUno.GetName()&lt;&lt;&quot; dice &quot;&lt;&lt; PerroUno.mBark&lt;&lt; endl;

    Dog PerroDos(&quot;comodoro&quot;,&quot;ladrido&quot;);

    cout&lt;&lt;PerroDos.GetName()&lt;&lt;&quot; dice &quot;&lt;&lt; PerroDos.mBark&lt;&lt;endl;

    return 0;
}

#include&lt;iostream&gt;
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(&quot;Woofers&quot;, &quot;Berk&quot;);
    Dog TwoDog(&quot;Toppy&quot;,&quot;Woof&quot;);
    cout&lt;&lt;&quot;Set a Dog Name:&quot;&lt;&lt;endl;
    cin&gt;&gt;dogename;
    TwoDog.SetDogName(dogename);
    cout&lt;&lt; OneDog.GetDogName()&lt;&lt;endl;
    cout&lt;&lt;TwoDog.GetDogName()&lt;&lt;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.
*/```

#include &lt;iostream&gt;

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&lt;&lt;mbark&lt;&lt;endl;
    }

private:
        string mname;
        string mbark;
};

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

        Dog Prro2(&quot;cuachi&quot;,&quot;woof&quot;);

     cout&lt;&lt;Prro1.Getname()&lt;&lt;endl;

     cout&lt;&lt;Prro2.Getname()&lt;&lt;endl;

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

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

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

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

Encapsulación de Datos en Programación Orientada a Objetos

Introducción a C++

Programación de Videojuegos con C++ desde Cero

Programación en C++: Fundamentos y Aplicaciones Prácticas

Conceptos Generales de C++

Historia y uso del compilador GCC en programación

Preparando el entorno de trabajo

Instalación de Code::Blocks en Windows paso a paso

Instalación de CodeBlocks en Mac paso a paso

Creación de un Proyecto de Consola en C++ Paso a Paso

Uso de Librerías y Entrada/Salida en C++

Manejo de memoria

Memoria y Tipos de Datos en Computadoras y Programación

Variables y tipos de datos en programación básica

Operadores Aritméticos y Lógicos en Programación

Uso de Apuntadores para Manipulación de Memoria en Programación

Cálculo del Área de Círculo y Esfera con Variables

Entrada de datos y funciones

Entrada y manejo de datos en programas C++

Operadores Relacionales y Condicionales en Programación

Condicionales y estructuras de control en programación

Funciones y Encapsulamiento en Programación

Funciones en Programación: Creación y Uso Eficiente

Creación de aventuras interactivas con C++ y decisiones de usuario

Loops y arreglos

Arreglos: Conceptos Básicos y Manipulación en Programación

Estructuras de Control: Bucles en Programación

Contadores y Bucles en Programación: While, Do-While y For

Arreglos Unidimensionales y Bidimensionales en Programación

Dibujar Mapas y Personajes en Juegos con Arreglos en C++

Movimiento de Personajes en Juegos con Python

Programación de Mapas Bidimensionales en Videojuegos

Movimiento de Personajes en Cuatro Direcciones con CIN

Lectura de Archivos

Lectura y escritura de archivos en C++ con fstream

Lectura y Escritura de Archivos en Programación

Posicionamiento del Jugador en el Mapa de Juego

Programación Orientada a Objetos

Programación Orientada a Objetos: Conceptos y Beneficios

Programación Orientada a Objetos: Clases e Instancias en Java

Encapsulación de Datos en Programación Orientada a Objetos

Abstracción en Programación Orientada a Objetos

Herencia en Programación Orientada a Objetos: Clases y Constructores

Tipos de acceso en la herencia de clases en programación

Polimorfismo en C++: Teoría y Práctica

Finalizando nuestro proyecto

Programación de un Juego de Laberinto en C++

Controles básicos de movimiento en videojuegos con programación en C++

Creación de Clases para Mapas en Juegos de Programación

Conexión de Jugador y Coordenadas en Mapas de Videojuegos

Carga y Lectura de Archivos para Mapas en Juegos

Colisiones y Movimiento en Juegos 2D con C++

Colisiones y restricciones de movimiento en mapas de juegos

Colisiones y Portadas en Videojuegos: Implementación en C++

Creación de Juegos de Aventuras en C++: Laberintos y Cofres del Tesoro

Programación Orientada a Objetos en Videojuegos Básicos

Creación de Enemigos y Laberintos en C++ Avanzado