Clases y objetos en C++

Objetos

Según la POO son bloques de código que permiten representar cosas (reales o imaginarias) como una persona o una venta. Los objetos se dividen en tres partes:

• El estado: conjunto de campos o variables (atributos o miembros)
• El comportamiento: las funciones (métodos o funciones miembro)
• La identidad: permite identificar un objeto de otro. De forma que cada objeto es identificable respecto a los demás.

Clases

Son estructuras que define las características que tendrá un objeto. Esto es lo que se llama encapsulamiento y es uno de los pilares de la POO.

Atributos

Son un conjunto de variables que definen el estado de una clase pueden ser tipos básicos:

• int
• float
• char
• bool
• Tipo colecciones (array), vectores u otros objetos.

Estas no deben ser accesibles desde el exterior, por lo que debe ser de tipo privado.

Metodos

Estos permiten acceder y modificar el estado de una clase.Tenemos dos clases especiales: el constructor y el destructor (el primero permite inicializar o instanciar una clase y el otro liberar recursos)

Además, existen los tradicionales métodos de acceso llamados GET que permiten extraer o mostrar el contenido de los atributos, generalmente sin parámetros salvo en colecciones u otros casos. Debe ser de tipo público. También, están los de modificación llamados SET que permiten modificar desde el exterior el contenido de los atributos asegurando la integridad de la clase, generalmente tienen un parámetro que coincide con el tipo de dato al que desean modificar y son públicos.

#include<iostream>
using namespace std;

class point{
	private:
		double x;
		double y;
	public:		
		//Constructor
		point(double x=0.0,double y=0.0):
			x(x),y(y)// Inicialización
			{}// Sin asignación
            
		//Métodos SET y GET	
		double getX() const {return this->x;}
		setX(double x){this->x=x;}
		double getY() const {return this->y;}
		setY(double y){this->y=y;}
		
		/*Destructor*/
		~point(){
			cout<<endl<<"Elemento destruido"<<endl<<endl;
		}		
};

Tangram con MiniWin

En el siguiente ejemplo se van a recrear las piezas de un tangram empleando triángulos rectángulos para formarlas.

Esto implica crear una o varias funciones para dibujar los triángulos rectángulos. En este caso se optó por usar cuatro funciones llamadas:

• tipoA
• tipoB
• tipoC
• tipoD

Estas podrían ser "inline", pero se optó por funciones convencionales, las funciones serían:

/*Trabajando con 4 tipos de triángulos rectángulos*/
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

Donde cada función corresponde a:

Tipo A	Tipo B
* ** *** **** *****	* ** *** **** *****
Tipo C	Tipo D
***** **** *** ** *	***** **** *** ** *

El código completo sería:

#include "miniwin.h"
using namespace miniwin;

const int DIM = 200; // Valor medio del ancho

/*Funciones */
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

int main(){
	vredimensiona(2*DIM, 2*DIM);	
	color_rgb(0, 0, 0);
	rectangulo_lleno(0, 0, 2*DIM, 2*DIM);
	
	/*Pieza 1*/
	color(AZUL);
	tipoB(0,0,DIM);
	tipoD(0,DIM,DIM);
	
	/*Pieza 2*/
	color_rgb(255, 150, 0);	
	tipoC(0,0,DIM);
	tipoD(DIM,0,DIM);	
	
	/*Pieza 3*/
	color(VERDE);	
	tipoA(DIM*1.5,0,DIM/2);
	rectangulo_lleno(DIM*1.5,DIM/2,2*DIM,DIM);
	tipoD(DIM*1.5,DIM,DIM/2);
	
	/*Pieza 4*/
	color(ROJO);	
	tipoA(DIM,DIM,DIM);
	
	/*Pieza 5*/
	color(MAGENTA);	
	tipoA(0,DIM*1.5,DIM/2);
	tipoB(DIM/2,DIM*1.5,DIM/2);
	
	/*Pieza 6*/
	color(AMARILLO);	
	tipoA(DIM/2,DIM,DIM/2);
	tipoB(DIM,DIM,DIM/2);
	tipoC(DIM/2,DIM*1.5,DIM/2);
	tipoD(DIM,DIM*1.5,DIM/2);
	
	/*Pieza 7*/
	color_rgb(100,0,155);	
	tipoA(DIM,DIM/2,DIM/2);
	tipoC(DIM,DIM,DIM/2);
	
	refresca();
	return 0;

}

El resultado visual sería: