introduccion al entorno c++ builder 3.0

PROGRAMACIÓN MULTIMEDIA

INTRODUCCIÓN AL ENTORNO DE DESARROLLO C++ BUILDER 3.0

© Carlos A. Lázaro Carrascosa. Laboratorio de Comunicación Oral R.W.N.

2

Programación Multimedia Introducción al C++ Builder 3.0

Biblioteca de clases visuales (VCL)

Componentes

Entorno de desarrollo integrado (IDE)

POO y C++ Builder

Excepciones


3



• Ventana principal:

• Menú principal• Barra de herramientas • Paleta de componentes

• Inspector de objetos

• Diseñador de formularios

• Editor de código


4


Menú principal:

• Ventana principal, siempre visible

• Menús comunes a cualquier aplicación Windows: File, Edit, Search, Help

• Título: nombre del proyecto, concepto esencial



5



Barra de herramientas:

• Objetivo: acelerar las operaciones más comunes del menú principal

• Personalizable


6



Paleta de componentes:

• Componentes: bloques básicos sobre los que se construyen aplicaciones• Personalizable • Clasificados en distintas pestañas:

Standard InternetAdittional Data AccessWin32 Data ControlsSystem QreportActiveX


7



Diseñador de Formularios:

• Herramienta visual destinada a diseñar y presentar la interfaz de usuario de una aplicación• Opciones de la rejilla (Tools|Environment Options)• Componente activo (un click)• Código asociado (doble click)


8



Inspector de objetos:

• Ventana con dos pestañas: propiedades y eventos• Apariencia: propiedades; Funcionalidad: eventos


9



Editor de código:

• Accesible desde el diseñador de formularios• Coloreo de la sintaxis, multiarchivo• Acceso a la totalidad del código fuente de la aplicación. (Mejor no cambiar el mantenido automáticamente)


10



Sistema de ayuda:

• Ayuda estándar de windows• Ayuda contextual (F1) • Publicación completa de las propiedades, eventos y métodos de cada componente


11


Compilación, ejecución, depuración:

• Compile• Make• Build• Run • Step Over• Trace Into• Run to Cursor



12



El almacén de objetos:

• Formularios, cuadros de diálogos, módulos de datos, asistentes, DLLs, etc• Prediseñados• Punto de partida• Ampliable


13


Definición:

• Elementos genéricos con una funcionalidad muy concreta, cuya única finalidad es la reutilización. • Componente VCL: clase que caracteriza a un control de Windows agregando propiedades, métodos y gestores de eventos a cada control.

Componentes


14


Propiedades:

• Elementos del componente que configuran su aspecto y controlan su comportamiento. • Accesibles en tiempo de diseño, y en tiempo de ejecución.

Componentes


15


Componentes

Métodos:

• Funciones asociadas al componente que pueden invocarse para que el componente realice distintas acciones


16


Componentes

Eventos:

• Cualquier suceso que puede ocurrirle a un componente


17


VCL

VCL: Marco de trabajo visual y orientado a objetos


18


VCL

Parte superior: clases “abstractas”, porque sirven para estructurar y agrupar comportamientos comunes de las clases de la VCL.


19


• TObject: Ancestro de todas las clases de la VCL. Encapsula el comportamiento común de todos los objetos• TPersistent: objeto que se almacenan en disco o en memoria• TComponent: Objetos de la paleta de componentes• TControl: Componentes visuales• TGraphicControl: Controles visuales, pero que no pueden recibir el foco (Canvas)• TWinControl: Controles típicos de Windows• TApplication: Aplicaciones windows.• TForm: Formularios

VCL


20


• La P.O.O. es un paradigma de programación que se fundamenta en los conceptos de objeto y clase. • Objeto: Una entidad autónoma con una funcionalidad concreta y bien definida.• Clase: Especificación de las características de un conjunto de objetos.

Un objeto es una instancia de una clase.

POO y C++ Builder


21


1. Crear un proyecto (File | New | Application) 2. Cambiar el nombre del formulario (Name=PpalFrm). 3. Colocar un PaintBox de la página de componentes System que se

llame PaintBox, con Align=alTop. Dejar espacio por debajo del PaintBox para colocar un botón.

4. Colocar un bevel de ancho 4 y alinearlo en lo alto (Align=alTop). La idea es que delimite la parte inferior del PaintBox.

5. Colocar un botón bit que permita terminar la ejecución del programa.

6. Guardar el código del formulario como Ppal.cpp y el proyecto como Ejemplo.bpr.

7. Crear una unidad (File | New | Unit). Guardarla con el nombre ObjGraf.cpp

POO y C++ Builder


22


//En ObjGraf.h:

//--------------------------------------------------

#ifndef ObjGrafH

#define ObjGrafH

// Definición de la clase

TObjGraf class TObjGraf {};

#endif

POO y C++ Builder


23


POO y C++ Builder// INSTANCIACIÓN POR DECLARACIÓN

//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){

TObjGraf ObjGraf1();

TObjGraf ObjGraf2;

}


24


POO y C++ Builder// INSTANCIACIÓN POR DECLARACIÓN

//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:

//--------------------------------------------------


TObjGraf ObjGraf1();

TObjGraf ObjGraf2;

}


25


POO y C++ Builder// INSTANCIACIÓN DINÁMICA

En Ppal.cpp:

TObjGraf * ObjGraf;

// Variable Global.

// ObjGraf es un puntero a objetos de tipo TObjGraf


ObjGraf = new TObjGraf;

}


26


POO y C++ Builder// DESTRUCCIÓN DE OBJETOS

//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;

}


27


POO y C++ Builder


28


//En ObjGraf.h:

class TObjGraf {

public: int X; // Propiedades

int Y;

TColor Color;

TPaintBox *PaintBox;

void Mostrar (void); // Métodos

};

POO y C++ Builder


29


//ACCESO A MIEMBROS DE UN OBJETO

void __fastcall TPpalFrm::FormCreate(TObject *Sender){ ... int ValorY; ...ObjGraf->X = 5; ValorY = ObjGraf->Y; ObjGraf->Mostrar(); //Equivalente a (*Obj).Mostrar();}

POO y C++ Builder


30


CONSTRUCTORES

En ObjGraf.h:class TObjGraf { ... // Constructor de objetos TObjGraf TObjGraf (TPaintBox *_PaintBox, TColor _Color=clBlack, int _X=0, int _Y=0); };En ObjGraf.cpp:TObjGraf :: TObjGraf (TPaintBox * _PaintBox, TColor _Color, int _X, int _Y){PaintBox = _PaintBox;Color = _Color; X = _X; Y = _Y;} ;

POO y C++ Builder


31


//En Ppal.cpp:void __fastcall TPpalFrm::FormCreate(TObject *Sender){ObjGraf = new TObjGraf (PaintBox, clRed, 10, 10);}

POO y C++ Builder


32


POO y C++ Builder


33


// En ObjGraf.h:

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

// Definición de la clase derivada Tcirculo

// Deriva de la clase base TObjGraf

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

class TCirculo : public TObjGraf {

public: int Radio; // Propiedad exclusiva de Tcirculo

};

POO y C++ Builder


34


// En ObjGraf.cpp:

TCirculo :: TCirculo (TPaintBox * _PaintBox, TColor _Color,int _X, int _Y, int _Radio) : TObjGraf (_PaintBox, _Color, _X, _Y){Radio = _Radio;}

POO y C++ Builder


35


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: 1.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.

POO y C++ Builder


36


Clases Abstractas

Clase abstracta: es una clase que no está completamente especificada (posee métodos sin implementar), por lo tanto no se pueden crear instancias de la misma. Una clase abstracta se usa para servir de clase base a otras clases. En terminología C++ se dice que una clase abstracta es aquella que posee al menos un método virtual puro.

· Virtual: obliga a las clases derivadas a implementar ese método.

· Puro: no pueden crearse instancias de esa clase.

POO y C++ Builder


37


//En ObjGraf.h:

class TObjGraf { public: ... // Otros metodos

virtual void Mostrar (void) = 0; // Metodo //virtual puro

}; class TCirculo : public TObjGraf { public: ... // Instanciacion del metodo virtual puro de la //clase TObjGraf void Mostrar (void); };

POO y C++ Builder


38


//En ObjGraf.cpp:

void TCirculo :: Mostrar (void){ PaintBox->Canvas->Pen->Color = Color; PaintBox->Canvas->Brush->Color = Color; PaintBox->Canvas->Ellipse(X, Y, X+Radio*2, Y+Radio*2);} ...

POO y C++ Builder


39


TCirculo *Cir1, *Cir2; TCuadrado *Cuad1, *Cuad2; void __fastcall

TPpalFrm::FormCreate(TObject *Sender) { Cir1 = new TCirculo (PaintBox, clBlack, 100, 100, 30); Cir2 = new TCirculo (PaintBox, clGreen, 210, 40, 20); Cuad1 = new TCuadrado (PaintBox, clRed, 200, 150, 45); Cuad2 = new TCuadrado (PaintBox, clYellow, 120,70,25);};

POO y C++ Builder


40


En C++ se puede especificar el acceso a los miembros de una clase utilizando los siguientes especificadores de acceso: public: Interfaz de la clase. private: Implementación de la clase. protected: Implementación de la familia. Estos especificadores no modifican ni la forma de acceso ni el comportamiento, únicamente controlan desde dónde se pueden usar los miembros de la clase: public: desde cualquier sitio. private: desde los métodos de la clase. protected: desde los métodos de la clase y desde los métodos de las clases derivadas.

POO y C++ Builder


41


// NUEVAS FORMAS DE ACCESO CON //PROPIEDADES VIRTUALES.

property int X = {read=FX, write=SetX };property int Y = {read=FY, write=SetY }; property TColor Color ={read=FColor,write=FColor}; property int Ancho = {read=GetAncho};

property int Alto = {read=GetAlto };

POO y C++ Builder


42


//Si en Ppal.cpp se usara esta propiedad para //lectura:

int CX = Cir1->X;

//En realidad es como si se hiciera

int CX = Cir1->FX;

POO y C++ Builder


43


//Si se usara esta propiedad para escritura: Cir1->X = 100;

//En realidad es como si se hiciera Cir1->SetX(100);

POO y C++ Builder


44


POLIMORFISMO

Sobrecarga de funciones.

Ocurre cuando en una clase existen dos métodos con idéntico nombre pero con distinta lista de parámetros. El compilador los considera como dos métodos distintos y aplicará cada uno de ellos en la situación apropiada.

POO y C++ Builder


45


Las excepciones son situaciones anómalas que requieren un tratamiento especial. ¡¡No tienen por qué ser errores!! Si se consigue dominar su programación, la calidad de las aplicaciones que se desarrollen aumentará considerablemente.

Excepciones


46


El funcionamiento general del mecanismo de lanzamiento y tratamiento de excepciones es el siguiente: Existe un método que invoca la ejecución de otro. Este método más interno se encuentra en una situación que puede considerarse como excepcional. Por lo tanto lanza una excepción. En este momento termina la ejecución del método más interno y se retorna inmediatamente al método llamador. El método llamador debe capturar la excepción y la trata. Parte del tratamiento de la excepción puede ser volver a lanzarla al método que invocó a este.

Excepciones


47


ESPECIFICACIÓN:

En ObjGraf.h:// Definicion de la clase EFueraRango//Clase de excepcion por entrar en "fuera de // rango":// salirse de los limites del PaintBoxclass EFueraRango {};

//Con lo que podríamos lanzar una excepción de la //siguiente manera: throw EfueraRango();

Excepciones


48


Excepciones

CAPTURA:

try { <bloque de instrucciones críticas>} catch (<tipo excepción1> <variable1>) { <manejador 1>} catch (<tipo excepción2> <variable2>) { ...}


49


VCL:EAccessViolationError de acceso a memoria.EDatabaseErrorEspecifica un error de acceso a base de datos.EDBEditErrorDatos incompatibles con una máscara especificada.EDivByZeroEZeroDivideCaptura errores de división por cero (para división entera y real, respectivamente).EInOutErrorRepresenta un error de E/S de archivo.EInvalidPointerOperaciones no válidas con punteros.EPrinterErrorIndica un error de impresión.

Excepciones


50


o VCL:

Las clases de excepción de tipo VCL solamente pueden capturarse por puntero o por referencia (preferible).

Las excepciones de tipo VCL deben lanzarse con sintaxis "por valor".

Excepciones


51


#include <vcl.h>#pragma hdrstop WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){ try { throw Exception("Mi excepción VCL"); } catch (const Exception & E) { ShowMessage("Clase de la excepción capturada: " + AnsiString(E.ClassName()) + "\nMensaje: " + E.Message); } return (0);}

Excepciones

PROGRAMACIÓN MULTIMEDIA

INTRODUCCIÓN AL ENTORNO DE DESARROLLO C++ BUILDER 3.0

introduccion al entorno c++ builder 3.0

Documents

void fastcall

error de acceso

builderen

tcolor color

en ppal

color color

builder 3

builder