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).
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).
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();
}
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();
}```
¿Qué es encapsulación? Es el proceso de combinar datos y métodos en una misma clase evitando que sean modificados directamente por factores externos.
Esto es muy Ăștil cuando se estĂĄ trabajando en equipos con varias personas.
En muchas ocasiones se quiere crear código de tal manera que solamente se puede trabajar con ciertos atributos o métodos utilizando ciertos métodos para poder delimitar un cierto comportamiento.
El uso de la encapsulaciĂłn permite poder hacer eso: sĂłlamente se puede acceder a ciertos mĂ©todos o atributos si se definen como pĂșblicos.
Esto nos da mucho mĂĄs control del cĂłdigo.
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.
#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!!
Este principio se aplica igualmente cuado creamos una funcion private a una public cierto?
Hola, son necesarias crear las variables miembro afuera del método constructor o se pueden nombrar iguales???
#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;
}
Yasser Pulido
Manuel Alejandro Aguilar TĂ©llez GirĂłn
Carlos Bolivar
Elena Nuñez Malledo
Moises Samuel Urias Moreno
Jeyson David Vargas Crespo
Carlos Nassif Trejo Garcia
Ivån Jiménez Paz
Federico Moreno
Carlos Nassif Trejo Garcia
Martin Gonzalez
Jose Antonio Rojas Ollarves
Aaron Joel Limachi Quispe
Jeyson David Vargas Crespo
Sebastian Andree Lopera Quevedo
Agustin Isaias Salinas Quinteros
Jose Antonio Rojas Ollarves
Hector Esau M
Jose Antonio Rojas Ollarves
Dilan Santiago Ariza Cañon
Martin Tercero
Jose Morales Varon
Angel Daniel Montes Villarreal
Sergy Lopez Moreno
Jesus Daniel Martinez Bautista
Ricardo Rito Anguiano
Ricardo Rito Anguiano
Rafael Arteaga
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(); }
Hola, gracias por el aporte pero ¿qué rayos es el this?
El profe no lo tiene en su cĂłdigo.
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!
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(); }```
¿Qué es encapsulación? Es el proceso de combinar datos y métodos en una misma clase evitando que sean modificados directamente por factores externos.
Esto es muy Ăștil cuando se estĂĄ trabajando en equipos con varias personas.
En muchas ocasiones se quiere crear código de tal manera que solamente se puede trabajar con ciertos atributos o métodos utilizando ciertos métodos para poder delimitar un cierto comportamiento.
El uso de la encapsulaciĂłn permite poder hacer eso: sĂłlamente se puede acceder a ciertos mĂ©todos o atributos si se definen como pĂșblicos.
Esto nos da mucho mĂĄs control del cĂłdigo.
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.
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
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.
#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!!
Este principio se aplica igualmente cuado creamos una funcion private a una public cierto?
Si, también funciona.
Hola, son necesarias crear las variables miembro afuera del método constructor o se pueden nombrar iguales???
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.
#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; }
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.
Creo que quisiste decir "no sean modificados por factores externos".
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= 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; }```
#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.
voiddefName(string PName) { Name=PName; }
Esa parte del codigo no iba :v
#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; }