Clases y encapsulado

ENCAPSULADO
Definicin: nos referimos al encapsulado como el proceso de formar objetos. Un
objeto encapsulado tambin es a menudo llamado un tipo de dato abstracto que es
uno de los temas principales de la Programacin Orientada a Objetos, sin el
encapsulado, lo cual involucra el uso de una ms clases no existira la Programacin
Orientada a Objetos.
En la programacin por procedimientos tradicional, digamos utilizando C, es normal
declarar una serie de variables con nombres representativos de un tipo especfico para
el dato en cuestin, as, si declaramos algunas variables de tipo int sabemos que
podemos asignarles valores numricos dentro de un rango especfico, tambin
podemos realizar ciertas operaciones con stas variables, como sumar, restar otros
clculos y adems podemos asignar los resultados a otra variable del mismo tipo. El
tipo de las variables indica:
El tamao en memoria de la variable.
El tipo de informacin que puede almacenar.
Las acciones que se pueden ejecutar en ellas.
En C++, se puede crear el tipo que sea necesario con toda la funcionalidad y potencia
que aporta el lenguaje.
FUNCIONES MIEMBRO
En C++ la estructura presenta una mejora con respecto a su prima del lenguaje C,
permite especificar funciones miembro lo que resulta muy prctico en trminos de
ordenar diversas partes del cdigo de acuerdo a su funcionalidad.
El siguiente programa demuestra el uso de estructuras y funciones miembro:
//******************************************************************
// TEMA : 2.CONSTRUCCION DE CLASES Y OBJETOS
// SUBTEMA : 2.1.ESTRUCTURAS.....
// PRACTICA 2.1A
// PROGRAMA QUE EJEMPLIFICA EL USO DE ESTRUCTURAS Y ENCAPSULADO EN
// EL CALCULO DE LA LEY DE OHM
ENCAPSU1.CPP
//******************************************************************
#include <iostream>
using namespace std;
//USO DE ESTRUCTURA
struct ohm
{
float voltaje;
float resistencia;
float corriente;
float amperios(float voltios, float ohmios);
};

// funcion miembro
float ohm::amperios(float voltios, float ohmios)

{
}

return voltios / ohmios;

int main()
{
struct ohm calculo1;
ohm calculo2;
float resultado;

// En C++ no es indispensable
// especificar la palabra "struct"

calculo1.voltaje = 127;
calculo1.resistencia = 470;
calculo2.corriente = 0.75;
calculo2.resistencia = 220;

// Inicializamos datos

//Asignacion de datos
indirectos
calculo1.corriente = calculo1.amperios(calculo1.voltaje,
calculo1.resistencia);
resultado = calculo2.amperios(135.25, 47); //Asignacion de datos
directos
calculo2.voltaje = calculo2.corriente * calculo2.resistencia;
// despliegue de resultados
cout << "\n La corriente en el calculo 1 es de: "
<< calculo1.corriente << " amperios" << endl;
cout << "\n El voltaje en el calculo 2 es de: "
<< calculo2.voltaje << " voltios" << endl;
cout << "\n La corriente en el calculo 2 es de: "
<< resultado << " amperios" << endl;
cin.get();
}

return 0;

Clases
C++ proporciona una alternativa muy interesante llamada clase, con sta
instruccin propia de C++ y de la POO podemos agrupar efectivamente una serie de
variables y funciones miembro, y al igual que con la estructura, la clase nos sirve para
construir nuevos tipos de datos. Una clase es una coleccin de variables, a menudo de
diferentes tipos, combinadas con funciones relacionadas.
Una clase nos permite encapsular o agrupar una serie de variables y funciones en una
coleccin a la cul llamamos objeto.
Similarmente a la estructura, llamamos a las variables como variables miembro en
tanto que a las funciones les llamamos funciones miembro, tambin conocidas como
mtodos. Para declarar una clase utilizamos la palabra clave class.
El siguiente programa demuestra el encapsulado y la manera para declarar y utilizar
una clase:

Declaracin de una clase

La palabra a utilizar es class que sirve para declarar una clase. Su uso es
parecido a la ya conocida struct:
class <identificador de clase> [<:lista de clases base>]
{
<lista de miembros>
} [<lista de objetos>];
La lista de clases base se usa para derivar clases, de momento no le prestes
demasiada atencin, ya que por ahora slo declararemos clases base.
La lista de miembros ser en general una lista de funciones y datos.
Los datos se declaran del mismo modo en que lo hacamos hasta ahora, salvo que
no pueden ser inicializados, recuerda que estamos hablando de declaraciones de
clases y no de definiciones de objetos. En el siguiente captulo veremos el modo
de inicializar las variables de un objeto.
Las funciones pueden ser simplemente declaraciones de prototipos, que se deben
definir aparte de la clase o tambin definiciones.
Cuando se definen fuera de la clase se debe usar el operador de mbito "::".
Lo veremos mucho mejor con un ejemplo.
//Programa que almacena en la clase parXY dos variables enteras y
//despliega su contenido a travs de funciones
#include <iostream>
using namespace std;
class parXY
{
private:
// Datos miembro de la clase " parXY "
int a, b;
public:
// Funciones miembro de la clase " parXY "
void Lee(int &a2, int &b2);
void Guarda(int a2, int b2)
{
a = a2;
b = b2;
}
};
// paso por referencia, cambian su contenido las variables parmetro
void parXY::Lee(int &a2, int &b2)
{
a2 = a;
b2 = b; }
int main()
{
parXY par1;
int x, y;
par1.Guarda(12, 32);
par1.Lee(x, y);
cout << "Valor de par1.a: " << x << endl;
cout << "Valor de par1.b: " << y << endl;
return 0;}
Nuestra clase " parXY " tiene dos miembros de tipo de datos: a y b.
Y dos funciones, una para leer esos valores y otra para modificarlos.

En el caso de la funcin "Lee" la hemos declarado en el interior de la clase y

definido fuera, observa que en el exterior de la declaracin de la clase tenemos
que usar la expresin:
void parXY::Lee(int &a2, int &b2)
Para que quede claro que nos referimos a la funcin "Lee" de la clase " parXY".
Ten en cuenta que pueden existir otras clases que tengan funciones con el mismo
nombre.
En el caso de la funcin "Guarda" la hemos definido en el interior de la propia
clase. Esto lo haremos slo cuando la definicin sea muy simple, ya que dificulta
la lectura y comprensin del programa.
Adems, las funciones definidas de ste modo sern tratadas como "inline", y esto
slo es recomendable para funciones cortas, ya que, (como recordars), en estas
funciones se inserta el cdigo cada vez que son llamadas.

Especificaciones de acceso:
Dentro de la lista de miembros, cada miembro puede tener diferentes niveles de
acceso. En nuestro ejemplo hemos usado dos de esos niveles, el privado y el
pblico, aunque hay ms.
class <identificador de clase>
{
public:
<lista de miembros>
private:
<lista de miembros>
protected:
<lista de miembros>
};

Acceso privado, private:

Los miembros privados de una clase slo son accesibles por los propios miembros
de la clase y en general por objetos de la misma clase, pero no desde funciones
externas o desde funciones de clases derivadas.

Acceso pblico, public:

Cualquier miembro pblico de una clase es accesible desde cualquier parte donde
sea accesible el propio objeto.

Acceso protegido, protected:

Con respecto a las funciones externas, es equivalente al acceso privado, pero con
respecto a las clases derivadas se comporta como pblico.
Cada una de stas palabras, seguidas de ":", da comienzo a una seccin, que
terminar cuando se inicie la seccin siguiente o cuando termine la declaracin de
la clase. Es posible tener varias secciones de cada tipo dentro de una clase.
Si no se especifica nada, por defecto, los miembros de una clase son privados.

//******************************************************************

// TEMA : 2.CONSTRUCCION DE CLASES Y OBJETOS

// SUBTEMA : 2.2.FUNCIONES MIEMBRO.....
// PRACTICA 2.1B
// PROGRAMA QUE EJEMPLIFICA EL USO DE CLASES Y ENCAPSULADO EN EL
// CALCULO DE LA LEY DE OHM
ENCAPSU2.CPP
//******************************************************************
#include <iostream.h>
// USO DE CLASE EN LUGAR DE ESTRUCTURA
class ohm
{
float voltaje;
float resistencia;
float corriente;

};

public:
void asigna(float, float);
void muestra(void);

// FUNCION MIEMBRO
void ohm::asigna(float volts, float amperios)
{
voltaje = volts;
corriente = amperios;
resistencia = volts / amperios;
}
// FUNCION MIEMBRO
void ohm::muestra(void)
{
cout << "El voltaje es: " << voltaje << endl;
cout << "La corriente es: " << corriente << endl;
cout << "La resistencia es: " << resistencia << endl;
}
int main()
{
ohm calculo1, calculo2;
float volt, ampere;
cout << "\n Valor de voltaje: " ;
cin >> volt;
cout << "\n Valor de la corriente: " ;
cin >> ampere;
cout << endl;
calculo1.asigna(volt, ampere);
calculo2.asigna(volt*4, ampere/2);
cout << "Resultados del objeto \"calculo1\"" << endl;
calculo1.muestra();
cout << endl;
cin.get();
cout << "Resultados del objeto \"calculo2\"" << endl;
calculo2.muestra();
cin.get();
return 0;}