La programación orientada a objetos (POO, u OOP según sus siglas en inglés) es un paradigma de programación que usa objetos en sus interacciones, para diseñar aplicaciones y programas informáticos.
Está basada en varias técnicas, incluyendo herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento.
Su uso se popularizó a principios de la década de 1990. En la actualidad, existe una gran variedad de lenguajes de programación que soportan la orientación a objetos.
El Paradigma de la POO en C++
Existen cuatro principios básicos que cualquier sistema orientado a objetos debe incorporar, que se esquematizan en la figura 5.1.
Figura 5.1. Pilares de la POO.
Creación y Destrucción de Objetos
Ya se ha dicho que una clase es únicamente una especificación. Para poder utilizar la funcionalidad contenida en la misma, se deben instanciar las clases.
- Creación por Declaración.
- La duración de los objetos suele ir más allá de una simple función o bloque. Debido al enfoque de la programación dirigida por eventos, suele ser habitual que un objeto se cree en un gestor de eventos y se destruya en otro.
- No se puede usar esta modalidad de creación con la VCL.
- Creación Dinámica
- Destrucción de objetos
Un objeto se puede instanciar de una forma simple, declarando una variable del tipo de la clase.
En Ppal.h:
#include "ObjGraf.h"
En Ppal.cpp:
Pulsando dos veces en OnCreate de la pestaña Events del editor de objetos de PpalFrm:
void __fastcall TPpalFrm::FormCreate(TObject *Sender) { }
 |
Aunque esta forma es posible, y bastante utilizada en la programación de C++ clásica, en C++ Builder se utiliza en muy contadas ocasiones. Esto es así por dos razones, fundamentalmente:
Por lo tanto, nosotros no la utilizaremos.
|
Es la forma habitual de crear objetos en C++ Builder, y se realiza mediante el operador new .
Cuando usamos new para instanciar un objeto, se usa una variable que referencie o apunte al nuevo objeto creado (de otra manera éste quedaría totalmente inaccesible). En definitiva, se requiere la declaración previa de un puntero a objetos del tipo del que se va a crear.
En Ppal.cpp:
//--------------------------------------------------void __fastcall TPpalFrm::FormCreate(TObject *Sender) {}
La forma de establecer el estado inicial o destruir las componentes de un objeto se estudiarán en el apartado dedicado a Constructores y Destructores(sección 5.4).
¡Cuidado! Cuando se utiliza esta forma de instanciación de clases es responsabilidad únicamente del programador la correcta destrucción de los mismos.
Cuando un objeto deja de ser útil hay que eliminarlo. De esta manera la aplicación recupera los recursos (memoria) que ese objeto había acaparado cuando se creó.
La destrucción de objetos creados en tiempo de ejecución con new se realiza mediante el operador delete.
En Ppal.cpp:
Pulsando dos veces en OnDestroy de la pestaña Events del editor de objetos de PpalFrm:
//--------------------------------------------------
void __fastcall TPpalFrm::FormDestroy(TObject *Sender)
{
delete ObjGraf;
}
//--------------------------------------------------
Encapsulamiento
En la programación clásica (lenguaje C, p.e.) existen datos y procedimientos que actúan sobre esos datos. No hay una relación aparente entre datos y procedimientos (funciones) y esta relación se establece de manera más o menos pecisa de acuerdo a la profesionalidad del programador.
En un objeto podemos distinguir dos aspectos bien diferenciados:
- Estado -----------> Propiedades
- Comportamiento ---> Métodos
En P.O.O. los datos y los procedimientos que los gestionan están relacionados explícitamente y se "encapsulan" en un objeto. La especificación de las propiedades de un objeto y los métodos de acceso se realiza en la declaración de la clase de la que se instancia el objeto.
En la figura 5.2 esquematizamos las propiedades y métodos que se van a asociar a los objetos de la clase TObjGraf:
Figura 5.2. Propiedades y métodos de los objetos de la clase TObjGraf.
La declaración de propiedades y métodos de los objetos de la clase TObjGraf se realiza de la siguiente manera:
En ObjGraf.h:
//--------------------------------------------------class TObjGraf {public:int X; // Propiedadesint Y;TColor Color;TPaintBox *PaintBox;void Mostrar (void); // Métodos};//--------------------------------------------------
Acceso a Miembros de un Objeto
Para acceder a los miembros de un objeto se usan los operadores típicos de acceso a miembros: el operador . para referencia directa al objeto y el operador -> para acceso a través de un puntero. Como nosotros siempre creamos los objetos con new, y los referenciamos mediante un puntero, el operador de acceso que utilizaremos es el operador ->
En Ppal.cpp:
//--------------------------------------------------void __fastcall TPpalFrm::FormCreate(TObject *Sender)int ValorY;{ ......ObjGraf->X = 5;ValorY = ObjGraf->Y;ObjGraf->Mostrar(); //Equivalente a (*Obj).Mostrar();}//--------------------------------------------------
Nota: Los puntos suspensivos no son una palabra reservada de C++, simplemente significan que se omite una parte del código, ya sea porque es irrelevante o porque ya se ha expuesto anteriormente.
5.4. Constructores y Destructores (Inicialización de Clases I)
Son métodos que permiten establecer el estado inicial y final de un objeto. Los constructores se pueden definir con un conjunto de argumentos arbitrario, pero no pueden devolver nada. Y los destructores no pueden recibir ni devolver ningún valor.
El constructor debe llamarse igual que la clase, y el destructor el nombre de la clase precedido del carácter ~
Un constructor se ejecuta cuando se crea un nuevo objeto: 1) por declaración, ó 2) cuando se crea dinámicamente con el operador new. Un destructor se ejecuta cuando el objeto deja de existir: 1) porque su ámbito acaba, ó 2) cuando se libera explícitamente con el operador delete.
En ObjGraf.h:
class TObjGraf {...// Constructor de objetos TObjGrafTObjGraf (TPaintBox *_PaintBox, TColor _Color=clBlack,int _X=0, int _Y=0);// El destructor sería: ~TObjGraf (void);};
En ObjGraf.cpp:
TObjGraf :: TObjGraf (TPaintBox * _PaintBox, TColor _Color,int _X, int _Y){PaintBox = _PaintBox;Color = _Color;Y = _Y;X = _X;}
En Ppal.cpp:
void __fastcall TPpalFrm::FormCreate(TObject *Sender){ObjGraf = new TObjGraf (PaintBox, clRed, 10, 10);}
Importante: No es necesario escribir un destructor salvo si el objeto requiere memoria dinámica adicional. De ser así, la tarea del destructor será, básicamente, liberar la memoria dinámica que ocupa el objeto que se va a destruir.
5.5. Herencia
Cuando una clase hereda de otra, la clase derivada incorpora todos los miembros de la clase base además de los suyos propios.
La herencia es una herramienta muy importante en muchos aspectos del desarrollo de aplicaciones:
- Organización del diseño.
- Reusabilidad de clases (propias o no).
- Mejora del mantenimiento.
Tomando como base la clase TObjGraf se van a construir dos nuevas clases, TCirculo y TCuadrado, que derivan de TObjGraf. Esto significa que los objetos de estas clases tienen asociados las propiedades y métodos de la clase base, TObjGraf, además de los suyos propios. En la figura 5.3 esquematizamos el mecanismo de herencia para las nuevas clases y las nuevas propiedades que se asocian a los objetos de las clases derivadas.
Figura 5.3. Las clases TCirculo y TCuadrado heredan las propiedades y métodos de la clase TObjGraf.4
En ObjGraf.h:
//*************************************************/// Definicion de la clase derivada TCirculo//*************************************************/// Deriva de la clase base TObjGrafclass TCirculo : public TObjGraf {public:int Radio; // Propiedad exclusiva de TCirculo};//*************************************************/// Definicion de la clase derivada TCuadrado.//*************************************************/// Deriva de la clase base TObjGrafclass TCuadrado : public TObjGraf {public:int Lado; // Propiedad exclusiva de TCuadrado};
Antes del nombre de la clase base hay que poner public, esto es así porque C++ permite también la herencia private. Pero ésta no se suele usar, por lo que nosotros supondremos que sólo existe la public.
5.5.1. Herencia de Constructores y Destructores (Inicialización de Clases II)
Los constructores y destructores de una clase no son heredadas automáticamente por sus descendientes. Deberemos crear en las clases hijas sus propios constructores y destructores. Es posible, no obstante, emplear los constructores de la clase base pero hay que indicarlo explícitamente. De ser así, es necesario saber:
- que los constructores y destructores de las clases base son invocados automáticamente antes que los constructores de las clases derivadas, y
- que los destructores de las clases derivadas se invocan antes que los de las clases base.
Para determinar con qué parámetros se llaman a los constructores de las clases base, se utiliza la lista de inicialización.
En ObjGraf.h:
//*************************************************/// Definicion de la clase derivada TCirculo//*************************************************/// Deriva de la clase base TObjGrafclass TCirculo : public TObjGraf {public:int Radio; // Propiedad exclusiva de TCirculo// Metodo constructorTCirculo (TPaintBox *_PaintBox, TColor _Color=clBlack,int _X=0, int _Y=0, int _Radio=1);};//*************************************************/// Definicion de la clase derivada TCuadrado.//*************************************************/// Deriva de la clase base TObjGrafclass TCuadrado : public TObjGraf {public:int Lado; // Propiedad exclusiva de TCuadrado// Metodo constructorTCuadrado (TPaintBox * _PaintBox, TColor _Color=clBlack,int _X=0, int _Y=0, int _Lado=1);};
En ObjGraf.cpp:
TCirculo :: TCirculo (TPaintBox * _PaintBox, TColor _Color,int _X, int _Y, int _Radio) :TObjGraf (_PaintBox, _Color, _X, _Y){ Radio = _Radio; }TCuadrado :: TCuadrado (TPaintBox * _PaintBox, TColor _Color,int _X, int _Y, int _Lado) :TObjGraf (_PaintBox, _Color, _X, _Y){ Lado = _Lado;}
FUENTE DE CONSULTA:
- http://elvex.ugr.es/decsai/builder/intro/5.html
- https://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos
- http://dis.unal.edu.co/~fgonza/courses/2003/poo/c++.htm
No hay comentarios:
Publicar un comentario