Clases en Visual C++

Buenas noches gente, el día de hoy les traigo un artículo muy muy importante para cualquier lenguaje de programación, que son las Clases, el día de hoy lo haremos mediante Visual C++ que es lo que estamos viendo en estos momentos. Vamos a dar una explicación breve de lo que son las clases:

Clases en Programación: En informática, una clase es una plantilla para la creación de objetos de datos según un modelo predefinido. Las clases se utilizan para representar entidades o conceptos, como los sustantivos en el lenguaje. Cada clase es un modelo que define un conjunto devariables -el estado, y métodos apropiados para operar con dichos datos -el comportamiento. Cada objeto creado a partir de la clase se denomina instancia de la clase. (Según Wikipedia), y esa es la definición más valida. La clase, también contiene métodos o funciones, y también sus respectivos constructores y destructores, es importante aclarar que C++ no trae implementado el recolector de basura como Java y por lo tanto es importante crear destructores, vamos a ver un pequeño ejemplo para lo cual crearemos un archivo de cabecera, el cual sería un archivo .h, en Visual Studio 2010, sería como se muestra en la siguiente imagen.

Agregar Archivos de cabecera en Visual C++ con Visual Studio 2010

Todas las clases tienen sus métodos o sus variables que son propiedades en niveles de visibilidad, tenemos el public y el private.

El public lo que hará es que el método declarado como public, será visible desde cualquier clase instanciada, el método private solo será visible desde la misma clase, por lo cual, aunque instanciemos la clase no podremos acceder a sus variables, propiedades o métodos establecido como private, para eso utilizaremos los métodos public de la misma clase. Se que está un poco confuso, pero como siempre digo, viendo y haciendo el ejemplo se entiende mejor que miles de palabras, así que procederemos a realizar el código de la clase:

#include  //Esta librería siempre se incluirá
using namespace std;
namespace Figuras //Creamos el namespace, en este caso figuras
{

class Triangulo //Creamos la clase, la cual crearemos con el comando class
{
private: //Establecemos sus variables, las cuales son sus propiedades como privadas, es decir
 //solo serán visibles desde esta misma clase
 float _base;
 float _altura;
 float _lado1;
 float _lado2;
 float _lado3;
public: //Los métodos públicos, al igual que los constructores y destructores
 Triangulo(int base, int altura) //Constructor que recibe dos parametros
 {
  _base=base;
  _altura = altura;
 }
 Triangulo() //Constructor sin parámetros
 {

 }
 ~Triangulo() //Destructor
 {
  cout <<"Limpiando...";
 }
 Triangulo (int lado1, int lado2, int lado3){ //Constructor con tres parametros
  _lado1=lado1; _lado2=lado2; _lado3=lado3;
 }
 float area() //Metodo que calcula el área de un Triangulo
 {
  return _base*_altura/2;
 }
 float perimetro() //Metodo que calcula el perimetro de n triangulo equilatero
 {
  return _lado1+_lado2+_lado3;
 }
};  //Importante la clase siempre termina con ; (puntoy coma)
}//Cerramos el namespace, si quisieramos crear otra figura, 

crearemos otra clase por ejemplo Circulo, antes de cerrar el namespace

Veremos algunos conceptos básicos como el constructor, el constructor, observado el primero de ellos en la línea 16, vemos como no tiene ningun tipo de dato, es decir no es ni int, float, string, char o void además, podemos apreciar como tiene el mismo nombre de la clase, otra cosa, desde el constructor estamos asignándole valor a las variables private considerando las líneas 18 y 19

 _base=base;

  _altura = altura;

En la línea 21 y 29 tenemos otros dos constructores, uno vacío y otro con tres parámetros, esto es debido a que podemos asignar cuantos constructores queramos, con más o menos parámetros; ésto se conoce como sobrecarga de constructores. 

En la línea 25, tenemos al destructor, que lo que hace el limpiar la memoria de las clases instanciadas, recordemos que una instancia, ocupa un espacio en memoria y si ese espacio no es liberado, quedará ocupado, por eso existen los destructores y es importante declararlos con el símbolo ~, eso es muy importante. 

Una vez que tenemos la clase realizada correctamente vamos a crear el archivo cpp de manera normal y consideraremos el siguiente código:

#include "Trianglo.h";
using namespace Figuras;
Triangulo t1;
Triangulo t2;
Triangulo t3;
void main()
{
 int base;
 int altura;
 cout <<"Dame la base: ";
 cin >>base;
 cout <<"Dame la altura: ";
 cin >> altura;
 t1 = Triangulo::Triangulo(base, altura);
 t2 = Triangulo::Triangulo(3,5,8);
 t3= Triangulo::Triangulo();
 
 cout <<t1.area()<<endl;
 cout <<t2.perimetro();
 
 system("pause");
}

Fíjense como para empezar ya no incluimos el iostream.h, esto es porque esa libreria la estamos incluyendo en el archivo Triangulo.h, después creamos tres variables mediante las cuales vamos a enlazar nuestro archivo de triangulo las cuales son:

Triangulo t1;
Triangulo t2;
Triangulo t3

localizadas en las líneas 3,4 y 5, otro detalle importante es que aquí el tipo de dato ya no es ni int, float, char, string o alguno otro, el tipo de dato es el mismo nombre de la clase, de esta manera, le estamos diciendo al compilador que esa variable pertenece a esa clase. Una vez hecho esto lo que seguiría es instanciar o inicializar las variables, recordemos que tenemos tres constructores y para ejemplificar voy a instanciar un constructor por cada variable, esto se realiza en la líneas 14, 15 y 16, como podemos apreciar, podemos tener tres triángulos con parámetros diferentes.

No se olviden de comentar, por lo menos darle +1 y darle clic a algun anuncio que les interese.
Saludos y hasta la próxima