U.T.O. – F.N.I. ING. DE SISTEMAS – ING.

INFORMÁTICA

SIS – 2210 METODOLOGÍA DE LA PROGRAMACIÓN II

GUÍA DE LABORATORIO # 5

TEMA: ENCAPSULAMIENTO. CONSTRUCTORES Y DESTRUCTORES

LOGROS A ALCANZAR.

 Comprende los conceptos respecto al encapsulamiento y ocultamiento de datos.

 Entiende los conceptos de Interfaz e Implementación.
 Conoce y utiliza constructores de clase

FUNDAMENTO TEORICO.

Encapsulamiento.-

El encapsulamiento es uno de los conceptos fundamentales de la programación orientada a objetos que

consiste en ocultar el estado interno de un objeto y solo permitir el acceso a sus atributos y métodos a
través de métodos públicos o interfaces definidas.

En otras palabras, el encapsulamiento se refiere a la restricción de acceso a los datos de un objeto para
proteger su integridad y garantizar un comportamiento consistente. Esto se logra definiendo los
atributos de un objeto como privados y proporcionando métodos públicos para acceder y modificar
dichos atributos de manera controlada.

El encapsulamiento permite mejorar la modularidad y la reutilización del código, ya que los cambios en
la implementación interna de un objeto no afectan a otras partes del programa que lo utilizan.

En un objeto podemos distinguir dos aspectos bien diferenciados:

 Estado -----------> Propiedades

 Comportamiento ---> Métodos

Interfaz e Implementación.-
 Headers(.h): aquí irá la interfaz, donde tendremos los parámetros y métodos declarados dentro la
parte deseada, public, private, protected, etc. Entre ellos estarán el constructor, el destructor, los getters,
los setters y los demás métodos.
 Sources(.cpp): aquí se definirán los métodos que no se hayan rellenado en el header.
Otra cosa a tener en cuenta es que los include hay que ponerlos en el source y evitar su uso en el
header.

Página 1
Para crear la interfaz debe crearse la clase; para ello una vez creado el proyecto crear dentro de él la
clase con: File/New class y dar el nombre correspondiente de la clase. Inmediatamente se crean dos
pestañas con el nombre de la clase y extensiones .h y .cpp. En el primero definir la clase (atributos y
datos) y en el segundo definir todos los métodos de la clase.

Constructores y destructores
C++ permite definir un método especial llamado el constructor de la clase, cuyo cometido es
precisamente inicializar por defecto los objetos de la clase. El constructor es un método que lleva el
mismo nombre de la clase y no tiene tipo.
La implementación del constructor se hace fuera de la construcción class. Ej.

Complejo::Complejo() { …}

Es posible asociar a una clase un constructor extendido en que se indiquen mediante argumentos los
valores a los que se debe inicializar un objeto de la clase.
Podemos añadir un constructor extendido (con argumentos) a la clase Complejo como sigue:
La implementación del constructor extendido es inmediata, basta emplear los argumentos para
inicializar los atributos:

Complejo::Complejo(double r, double i) {…}

también es posible definir un destructor que se encargue de destruir los objetos automáticamente,
liberando los recursos que pudieran tener asignados:
El nombre del destructor es siempre el de la clase a la que pertenece antecedido por el símbolo ~ (en
nuestro ejemplo, ~Complejo()).
Al igual que los constructores, los destructores se definen fuera de la construcción class {...} y no tienen
tipo de retorno alguno:
Clases en Codeblocks.

Para definir una clase en codeblocks, Generamos una clase nueva mediante: File->New-.Class,
abriendo la siguiente ventana

Se coloca el nombre de la clase, el cual generará los archivos .h y .cpp. Tener cuidado de tener las
casillas marcadas tal como se muestra en la fig.

Página 2
Setters y getters.- En C++ se le llaman get y set, a los métodos de un objeto que retornan o modifican una
característica privada del objeto; no obstante, no es necesario llamarlo get y set, ya que (al menos en c++) el programador
decide el nombre a darle a esos métodos.

get ->; retornar valor

ser ->; modificar valor
Ejemplo
class usuario {
private:
char name ;
char mail ;
int cod;
public:
get_name() {return name};
//devolver_name() {return name}
set_cod(int a) {cod=a;}
//cambiar_cod(int a) {cod=a;}
}

Página 3
En CodeBlokcs se puede realizar estas operaciones automáticamente mediante el cuadro de diálogo “Member variables” de
la ilustración anterior. Así obtenemos:
class usuario
{
private:
string nombre;
string mail;
int cod;

public:
usuario();
~usuario();

string GetNombre() { return nombre; }

void SetNombre(string val) { nombre = val; }
string GetMail() { return mail; }
void SetMail(string val) { mail = val; }
int GetCod() { return cod; }
void SetCod(int val) { cod = val; }
};

La diferencia entre un set y un constructor está en que en el constructor se inicializan todos los
atributos de la clase; en cambio cuando se utiliza set solo se pueden utilizar algunos atributos, los
necesarios; aunque no siempre se sabe cuáles serán los necesarios. Se acostumbra definir estos sets y
gets en la definición de la clase por tratarse de métodos cortos: y los demás métodos declarados en la
clase, definirlos en el cuerpo o source
Actividad en clase:

1. Generar una clase “carro” con métodos que indiquen aceleración y/o frenado del vehículo

Solución:

#include <iostream>
Using namespace std;
class Carro
{
private:
int velocidad;

public:
Carro() {
velocidad = 0;
}

void acelerar() {
velocidad += 10;
}

void frenar() {
velocidad -= 10;
}

void imprimirVelocidad() {
Página 4
 cout << "Velocidad: " << velocidad << " km/h" << endl;
}
};

int main() {
Carro carro;
carro.acelerar();
carro.imprimirVelocidad();
carro.frenar();
carro.imprimirVelocidad();
return 0;
}

2. Clase “Persona” con setters y Getters

#include <iostream>
Using namespace std;

class Persona
{
private:
string nombre;
int edad;

public:
Persona() {
nombre = "";
edad = 0;
}

void setNombre(string n) {
nombre = n;
}

void setEdad(int e) {
edad = e;
}

string getNombre() {
return nombre;
}

int getEdad() {
return edad;
}
};

int main() {
Persona persona;
persona.setNombre("Juan");
persona.setEdad(30);

cout << "Nombre: " << persona.getNombre() << endl;

cout << "Edad: " << persona.getEdad() << endl;

return 0;
}

Página 5
3. Implementar la clase complejo que permita manipular los atributos de los números complejos (real
e imaginaria). El programa deberá permitir asignar valores a los atributos, desplegar sus valores y
realizar la suma de dos números complejos

Solución:

#include <iostream>

using namespace std;

class complejo
{
private:
double real, imag;
public:
complejo(); //Constructor por defecto
complejo(double r, double i); //Constructor extendido
~complejo() { }; //Destructor
void setreal(double r) { real=r; }
void setimag(double i) { Imag=i;}
double getreal() {return real }
double getimag() { return imag }

void suma(const complejo &a, const complejo &b);

};

complejo::complejo()
{
real=1;
imag=0;
}
complejo::complejo(double r, double i)
{
real=r;
imag=i;
}

void complejo::suma(const complejo &a, const complejo &b)

{
real=a.real + b.real;
imag=a.imag + b.imag;
}

int main()
{
//complejo a b, s;
complejo a;
complejo b(1,5);
complejo s;
//a.setreal(1);
//a.setimag(3);
//b.setreal(2);
//b.setimag(7);
s.suma(a,b);
cout<<"parte real: "<<s.getreal()<<" "<<"parte imaginari: "<<s.getimag()<<"i"<<endl;
return 0;
}

Página 6
Ejercicio Propuesto

4. Implementa la siguiente clase para representar complejos en forma de una dupla (real,imaginaria):
class Complejo
{
private:
double real, imag;

public:
Complejo();
Complejo(double r, double i);
void setreal(double r);
void setimag(double i);
double getreal();
double getimag();
double modulo();
void suma(const Complejo &a, const Complejo &b);
void resta(const Complejo &a, const Complejo &b);
};
y escribe una función calculadora(a,b) que reciba desde teclado dos complejos a y
b (por referencia) y calcule e imprima su suma, su resta, el producto y la división de los
complejos a y b .

Página 7