Tutorial C++ Builder

 
Tutorial BORLAND C++Builder de programacion ncluye programas tareas aplicacion arreglos y Base de Datos.



UNIDAD I C++BUILDER PROGRAMACION VISUAL ELEMENTOS BASICOS

1.- INTRODUCCION

2.- MODELO DE SOLUCION

3.- VARIABLES

4.- TIPOS DE DATOS

5.- OPERADORES ARITMETICOS

6.- OPERADOR CAST

7.- JERARQUIA DE OPERACIONES

8.- ENTRADAS/SALIDAS EN PROGRAMACION VISUAL

9.- FORM1, ACTIVA O PRINCIPAL

10.- PROGRAMAS, FORMAS Y COMPONENTES

11.- COMPONENTE LABEL Standard

12.- COMPONENTE BUTTON Standard

13.- COMPONENTE EDIT Standard

14.- COMPONENTE MaskEdit Adicional

15.- COMPONENTE ComboBox Standard

16.- COMPONENTES DE AGRUPAMIENTO

17.- COMPONENTE PANEL Standard y atrás flecha negra

18.- COMPONENTE GroupBox Standard

19.- VENTANAS EN C++Builder



UNIDAD II C++BUILDER INSTRUCCIONES DE CONTROL DE PROGRAMA

1.- INTRODUCCION

2.- INSTRUCCIONES CONDICIONALES

3.- CONDICIONES SIMPLES

4.- INSTRUCCION IF

5.- CONDICIONES COMPUESTAS

6.- INSTRUCCION SWITCH

7.- COMPONENTES VISUALES DE SELECCION Y DECISIÓN

8.- COMPONENTE CheckBox Standard

9.- COMPONENTE RadioButton Standard

10.- COMPONENTE RadioGroup Standard

11.- COMPONENTE MainMenu Standard

12.- COMPONENTE PopupMenu Standard

13.- CICLO FOR

14.- CICLO WHILE

15.- CICLO DO-WHILE

16.- CONCLUSIONES ACERCA DE CICLOS

17.- INSTRUCCION DE SALTO INCONDICIONAL



III UNIDAD C++ BUILDER ARREGLOS

1.- INTRODUCCION

2.- ARREGLOS TRADICIONALES EN C++BUILDER

3.- ARREGLOS TIPO LISTAS

4.- ARREGLOS TIPO TABLA

5.- TIPOS DE ARREGLOS EN C++BUILDER CLASES E INTERNOS

6.- TStringList

7.- COMPONENTE ListBox Standard

8.- COMPONENTE StringGrid adicional



IV UNIDAD C++BUILDER INT A LAS BASES DE DATOS

1.- INTRODUCCION

2.- MODELOS DE ALMACENAMIENTO DE DATOS

3.- TABLAS

4.- TABLAS CONTINUACION

5.- DATABASE DESKTOP

6.- APLICACIONES O PROGRAMAS CON TABLAS

7.- APLICACIONES POR RENGLON

8.- APLICACION POR TABLA

9.- PROCESOS BASICOS

10.- BUSQUEDAS

11.- FILTROS

12.- GRAFICOS O IMAGENES

13.- IMPRESION O REPORTES

14.- IMPRESION DE TODA LA TABLA

15.- MODELO RELACIONAL DE DATOS

16.- TIPOS DE RELACIONES

17.- MODELO RELACIONAL Y DATABASE DESKTOP

18.- APLICACIONES CON TABLAS DE RELACION



V UNIDAD C++BUILDER COMPONENTES

1.- INTRODUCCION

2.- COMPONENTES, CLASES Y OBJETOS

3.- INSTALACION Y MANTENIMIENTO DE COMPONENTES VISUALES

4.- INSTALACION PRACTICA DE COMPONENTES

5.- CREACION E INSTALACION DE COMPONENTES VISUALES

6.- EDICION DE COMPONENTES VISUALES

7.- ELIMINACION COMPONENTES VISUALES

8.- BITMAPS A COMPONENTES VISUALES

9.- CREACION COMPONENTES NO VISUALES



VI UNIDAD C++BUILDER MULTIPROCESAMIENTO

1.- INTRODUCCCION

2.- OBJETOS CONCURRENTES

3.- APLICACIONES CONCURRENTES

Los nuevos sistemas de información son costosos en tiempos y recursos, la solución moderna de sistemas de información exigen nuevas herramientas y metodologías para resolver rápida, económica y eficiente los problemas de información planteados por las organizaciones.


Aun mas el pleno potencial del hardware no es aprovechado plenamente y existe un considerable retraso con el software y sus aplicaciones, generando lo que se conoce como “crisis del software”.

En programación tradicional, modular o estructurada un programa describe una serie de pasos a ser realizados para la solución de un problema, es decir es un algoritmo.


En programación orientada a objetos ( OOP ) un programa es considerado como un sistema de objetos interactuando entre sí, ambientes de desarrollo visuales facilitan aun más la construcción de programas y solución de problemas, porque permiten abstraer al ingeniero de software de todo el GUI (interfase gráfica) del problema, que constituye más del 60% del código normal de un programa.


Es decir, en programación modular o estructurada un problema sencillo de información es descompuesto en una serie de módulos(llamados procedimientos o funciones) donde cada uno de ellos realiza una tarea específica, por ejemplo uno de ellos captura los datos, otro resuelve operaciones, etc.


En OOP todo problema aun aquellos sencillos de información, se consideran y resuelven como módulos de código gigante (clase) que contiene todo el código necesario(variables, procedimientos, funciones, interfaces, etc.) para solucionar el problema.


En programación visual( que también es heredera de OOP ),la interfase con el usuario( pantallas) son generadas por el propio compilador y el ingeniero de software solo se concentra en resolver el problema planteado.


C++Builder, es un compilador que permite usar cualquiera de los tres enfoques en la solución de problemas de información que puedan y deban ser resueltos empleando el computador y el lenguaje.


Para propósitos de aprendizaje usaremos el tercer enfoque, es decir programación en ambientes visuales y usando el lenguaje de programación C++Builder.

 
En general un problema de información es posible entenderlo, analizarlo y descomponerlo en todos sus componentes o partes que de una u otra manera intervienen tanto en su planteamiento como en su solución.

Una herramienta rápida que nos permite descomponer en partes un problema para su solución, es el llamado modelo de solución, este consiste de una pequeña caja que contiene los tres elementos más básicos en que se puede descomponer cualquier problema sencillo de información, estas tres partes son:

1. LA PRIMERA PARTE son todos los datos que el computador ocupa para resolver el problema, estos datos son almacenados internamente en la memoria del computador en las llamadas variables de entrada.

2. LA SEGUNDA PARTE son todas las operaciones generalmente algebraicas necesarias para solucionar el problema, generalmente esta parte del modelo es una formula (o igualdad matemática, ej. X= y + 5).

3. LA TERCERA PARTE es el resultado o solución del problema que generalmente se obtiene de la parte de operaciones del modelo y dichos datos están almacenados en las llamadas variables de salida.

En resumen para todo problema sencillo de información es necesario plantearse las siguientes preguntas:

Que información o variables de salida se van a desplegar en pantalla para responder al problema planteado originalmente?

Variables es el nombre de una localidad o dirección interna en la memoria del computador donde se almacenan los datos, ejemplo de variables para los casos del inciso anterior, CIUDAD, DIRECCION, EDAD, SUELDO, ETC.

Información son datos ya procesados que resuelven un problema planteado.

EJEMPLO DE MODELO DE SOLUCION

Construir un modelo de solución que resuelva el problema de calcular el área de un triángulo con la formula área igual a base por altura sobre dos.


UNIDAD 5.- C++BUILDER COMPONENTES


 Variable(s) Entrada        Proceso u operación         Variable(s) salida

 BASE ALTURA        AREA = BASE * ALTURA / 2              AREA

TAREAS PROGRAMACION C++BUILDER

PROBLEMA 2.- CONVERTIR LA EDAD EN AÑOS DE UNA PERSONA A MESES.

PROBLEMA 3.- CONVERTIR PESOS A DOLARES.

PROBLEMA 4.- CALCULAR EL AREA DE UN CIRCULO CON LA FORMULA



PROBLEMA 5.- EVALUAR LA FUNCION PARA CUALQUIER VALOR DE X.

Pero recordar también que existirán problemas sencillos donde:

*No se ocupan entradas o no se ocupan operaciones, pero todos ocupan salida.

* Una formula grande o muy compleja puede ser más segura y fácil de resolver, si es descompuesta y resuelta en partes, juntando al final los parciales para obtener el resultado final.

* Un problema puede tener más de una solución correcta.

* El problema no esta suficientemente explicado o enunciado, entonces, estudiarlo, analizarlo y construirlo de manera genérica.

PROBLEMAS SUGERIDOS:

Construir los modelos de solución de los siguientes problemas:

PROBLEMA 6.- Convertir millas a kilómetros(caso normal)

PROBLEMA 7.- Convertir 125 metros a centímetros(no ocupa entradas)

PROBLEMA 8.- Se calcula que en promedio hay 4.7 nidos en cada árbol en la UABC, también se calcula que en cada nido existen un promedio de 5.8 pájaros, se pide calcular la cantidad total de nidos y de pájaros en los 227 arboles que existen en la UABC. (no ocupa entradas)

PROBLEMA 9.- La gorda Sra. López y sus 8 hijos solo compran una vez al mes su mandado en conocido supermercado, en dicha tienda el kilogramo de frijol cuesta $8.75, el paquete de tortillas cuesta $3.55 y el frasco de café vale $14.25, si solo compran de estos tres productos para su mandado, calcular su gasto total. ( problema no claro)

PROBLEMA 10.- Capturar y desplegar los cinco datos mas importantes de un automóvil(no ocupa operaciones)

PROBLEMA 11.- La distancia Tijuana - Ensenada es de 110 kilómetros. Si un automóvil la recorre a una velocidad constante de 30 millas por hora, cuanto tiempo tarda en llegar. ( 1 milla = 1.609 Km.) (dos maneras correctas de

resolverlo).

PROBLEMA 12.-Evaluar la función para cualquier valor de x.(caso normal).

PROBLEMA 13.-Evaluar la función para cuando x vale 4 . (no ocupa entradas).

 
Identificadores son conjuntos de letras y/o números que se utilizan para simbolizar todos los elementos que en un programa, son definibles por el usuario (programador o ingeniero de software) del mismo, como son las variables donde se almacenan datos, funciones( pequeños módulos con código), etiquetas, clases, objetos, etc.

En C++Builder un identificador es una palabra compuesta de letras y/o números de hasta 32 caracteres significativos, empezando siempre con una letra.

Una variable se define como un identificador que se utiliza para almacenar todos los datos generados durante la ejecución de un programa.

Existen ciertas reglas en cuanto a variables:

*

* Claras y con referencia directa al problema. *

* No espacios en blanco, ni símbolos extraños en ellas. *

* Se pueden usar abreviaturas, pero solo de carácter general.

No deben ser palabras reservadas del lenguaje.

Ejemplos de buenas variables:

Nombre, Edad, SdoDiario, IngMensual, Perímetro, Calif1, etc.

 
A toda variable que se use en un programa, se le debe asociar (generalmente al principio del programa) un tipo de dato específico.

Un tipo de dato define todo el posible rango de valores que una variable puede tomar al momento de ejecución del programa y a lo largo de toda la vida útil del propio programa.

Los tipos de datos más comunes en C++Builder son:

Tipo Tamaño Rango


--------------------------------------------------------------------------------

unsigned char 8 bits 0 a 255

char 8 bits -128 a 127

short int 16 bits -32,768 a 32,767

unsigned int 32 bits 0 a 4,294,967,295

int 32 bits -2,147,483,648 a 2,147,483,647

unsigned long 32 bits 0 a 4,294,967,295

enum 16 bits -2,147,483,648 a 2,147,483,647

long 32 bits -2,147,483,648 a 2,147,483,647

float 32 bits 3.4 x 10-38 a 3.4 x 10+38(6 dec)

double 64 bits 1.7 x 10-308 a 1.7*10+308(15 dec)

long double 80 bits 3.4 x 10-4932 a 1.1 x 10+4932

AnsiString cadena de caracteres


--------------------------------------------------------------------------------

AnsiString no es propiamente un tipo de dato, sino una clase que se especializa en al almacenamiento y manipulación de datos de tipo string, es decir, como clase ya contiene toda una serie de métodos (procedimientos y funciones) que pueden usar directamente las variables(objetos) que se declaren de tipo AnsiString, como en el siguiente ejemplo;

área de declaración carga normal de variables strings (que antes no se podía hacer directamente en C o C++)

// procesos con las variables ya considerándolas como objetos de la clase AnsiString estos procesos antes ocupaban una librería especial llamada < string.h >

* Interesante este nuevo tipo (Clase) AnsiString y también interesante estos dos métodos ( LowerCase() y ToInt() ), el resto de métodos, se deben buscar en la ayuda del C++Builder (solo abrir folder o libro llamado “referencia del programador”, pedir índex y luego escribir AnsiString ).

 
Un operador es un símbolo especial que indica al compilador que debe efectuar una operación matemática o lógica.

C++Builder reconoce los siguientes operadores aritméticos:


--------------------------------------------------------------------------------

Operador Operación

+ Suma

- Resta

* Multiplicación

/ División

% Residuo o Módulo


--------------------------------------------------------------------------------

Como notas importantes a recordar siempre;

* En problemas de división entre enteros, C++ trunca la parte residual, es decir:

Código:

// área de declaración de variables

float a;

// área de operaciones

a = 10 / 4;

// área de despliegue de resultados

desplegar a; --> En pantalla sale ( 2.000000 )

El problema no es el tipo float, sino que por definición de la división entre enteros C++ siempre trunca la parte residual, mas adelante se indica como se resolverá este problema.

El operador (%) devuelve el residuo entero de una división entre enteros, ejemplo:

// área de despliegue

Otro ejemplo;

Para resolver los problemas de potencias y raíces, se usan ciertas instrucciones especiales que proporciona el lenguaje, llamadas funciones matemáticas, en C++ existe toda una librería de instrucciones o funciones matemáticas.

Recordar que todas las funciones reciben uno o más datos o valores y regresan siempre un resultado, una de estas funciones matemáticas es:

Esta función ocupa dos valores o datos( base y exp) ambos de tipo double, y regresa un resultado también de tipo double, ejemplo;

- resolver el problema de calcular

Para resolver el problema de raíces, se aprovecha una de las mas elementales y conocida de las leyes de exponentes que dice:



Es decir una raíz cualquiera se puede transformar a una potencia con un exponente fraccionario.

Ejemplo:

problema y = 3 √x esto es equivalente a
entonces:

y=3 * pow(double(x),double(1/2.0) );

* En este ejemplo se esta dando por supuesto que no interesa el tipo de dato que requiere la función pow() para trabajar correctamente.

 
Se puede forzar un dato, variable o una expresión a convertirse o cambiarse a un nuevo tipo de dato.

El operador cast realiza este proceso, es decir convierte datos, variables o expresiones a un nuevo tipo de dato, su formato es:

Ejemplo:


--------------------------------------------------------------------------------

int (3.1416);


--------------------------------------------------------------------------------

* en este ejemplo se está convirtiendo un float a int, recordar que en este caso ya no se tendrán los decimales.

Como nota importante este operador resuelve los dos problemas pendientes:

1. El de la división entre enteros.

2. El tipo de dato especifico que requieren las funciones.

En toda división recordar agregar a uno de los dos valores el (.0), solo que los dos elementos sean variables entonces usar el operador cast con una de ellas.

Se puede usar pow(), directamente con los datos, argumentos o parámetros requeridos , si estos son numéricos, pero transformándolos con el operador cast.

Esto también va a permitir evaluar expresiones matemáticas de manera mas directa y sencilla, solo recordando usar un pow() por cada potencia y cada raíz de la ecuación, ejemplo:

TAREAS PROGRAMACION C++BUILDER :

El problema de no tomar en cuenta la jerarquía de los operadores al plantear y resolver

una operación casi siempre conduce a resultados muchas veces equivocados como estos:

Ejemplos:


--------------------------------------------------------------------------------

1.

2. 2+ 3* 4 = 20(incorrecto) = 14 (correcto)


--------------------------------------------------------------------------------

b) si calif1=60 y calif2=80


--------------------------------------------------------------------------------

Recordar siempre, que antes de plantear una formula en un programa se deberá evaluar contra el siguiente:


--------------------------------------------------------------------------------

--------------------------------------------------------------------------------

Nota: Si se quiere alterar el orden normal de operaciones, entonces usar paréntesis.

Nota: Tampoco es bueno usar paréntesis de mas en una operación, esto solo indica que no se evalúo bien la formula, como en el siguiente ejemplo;


--------------------------------------------------------------------------------


--------------------------------------------------------------------------------

aquí los paréntesis están de mas, porque por orden de operaciones, multiplicación y división tienen la misma jerarquía y entonces se resuelven de izquierda a derecha, en otras palabras ni que falten paréntesis ni que sobren paréntesis.

Entradas o capturas de datos y salidas o despliegues de información o resultados son de los procesos más comunes en cualquier tipo de problema de información, estos procesos o instrucciones varían de acuerdo a los lenguajes y ambientes de programación a usar.

El lenguaje y ambiente de programación a utilizar, es de tipo visual, y muchos de los problemas asociados a entradas y salidas se encuentran ya resueltos por el propio compilador.

El ambiente de construcción de programas a usar, es el siguiente:

* SOLO CARGARLO EN PANTALLA EJECUTANDO EL C++Builder, QUE SE ENCUENTRA

EN LA BARRA DE START DE WINDOWS.



Sus elementos básicos son:

1.- La barra de menús (file, edit , etc.);

2.- La barra de herramientas(icono de grabar, run, forma, etc.)

3.- La barra de componentes

4.- El Inspector de Objetos

5.- La forma activa o principal

Es sobre esta forma donde se construye el programa y esta forma se convierte en ventana al momento de ejecutarse el programa.

Es decir será la primera ventana que el usuario ve al momento de ejecutarse el programa, su nombre es Form1.

Esta forma o ventana es un objeto de C++, y como todos los objetos de C++ y del universo, la forma o ventana tiene asociados propiedades y eventos.

Propiedades son todas las características particulares que diferencian un objeto de otro objeto, las propiedades o características mas comunes son forma, tamaño, color, etc., para objetos en C++, estas propiedades se modifican o individualizan usando el Inspector de Objetos, que es la parte del programa que las contiene.

También se pueden modificar las propiedades dentro de un programa, usando instrucciones apropiadas, mismas que llevan el siguiente formato:

nomobjeto→propiedad = nvovalor;

ej.; Form2→Color=clRed;

Eventos, son todos aquellos sucesos de carácter externo que afectan o llaman la atención del objeto, para estos caso la forma o ventana:

1. Debe tener capacidad de detectar el evento

2. Aun mas importante debe tener capacidad de reaccionar y emitir una respuesta, mensaje o conducta apropiada a el evento detectado.

Evento es por ejemplo que otro objeto llamado humano, pulse el objeto tecla ESC, o haga click derecho con el objeto ratón en alguna parte de la ventana , etc. , es en estos casos, cuando la ventana detecta un evento de estos, la propia forma deberá responder de manera apropiada.

Esta respuesta no es automática, sino son la serie de instrucciones del lenguaje (o programa) que los ingenieros de software diseñan(o programan), en otras palabras son los eventos quienes contendrán los programas.

Es tambien el Inspector de Objetos, quien contiene todos los posibles eventos asociados a la forma.



Para los primeros programas en C++Builder , solo se usaran propiedades sencillas como color, font, etc. de Form1, y no se usan, de momento los eventos que puede detectar Form1.

Un programa o problema de información en C++Builder , no es mas que una o mas formas o ventanas, donde cada una de ellas contiene elementos u objetos especiales llamados componentes, dichos componentes C++Builder los proporciona a través de la barra de componentes.



Es decir toda la interfase que se quiera manejar con el usuario del programa, no consiste mas que de una colección de componentes agrupados en una forma o ventana.

La colección de componentes que pone a nuestra disposición C++Builder están agrupados en diversos folder o pestañas o paginas en la barra de componentes, estas categorías contienen los siguientes componentes:

Standard.- MainMenu, PopupMenu, Label, Edit, Memo, Button, CheckBox, RadioButton, ListBox, ComboBox, ScrollBar, GroupBox, RadioGroup, Panel.



Win95.- TabControl, PageControl, TreeView, ListView, ImageList, HeaderControl, RichEdit, StatusBar,TrackBar,ProgressBar,UpDown,HotKey.



Additional.- BitBtn, SpeedButton, MaskEdit, StringGrid, DrawGrid, Image, Shape, Bevel, ScrollBox.



Data Access.- DataSource, Table, Query, StoredProc, DataBase, Session, BatchMove, UpdateSQL



Data Controls.- DBGrid, DBNavigator, DBText, DBEdit, DBMemo, DBImage, DBListBox, DBComboBox, DBCheckBox,DBRadioGroup, DBLookupListBox, DBLookupComboBox.



Win31.- DBLookupList, DBLookupCombo, TabSet, Outline, Header, TabbedNotebook, NoteBook.



Dialogs.- OpenDialog, SaveDialog, FontDialog, ColorDialog, PrintDialog, PrinterSetupDialog, FindDialog, ReplaceDialog.



System.- Timer, PaintBox, FileListBox, DirectoryListBox, DriveComboBox, FilterComboBox, MediaPlayer, OleContainer, Ddeclientconv, DdclientItem, Ddeserverconv, DdeserverItem.



QReport.- QuickReport, QRBand, QRGroup, QRDetailLink, QRLabel, QRMemo, QRDBText, QRDBCalc, QRSysData, QRShape, QRPreview.



ActiveX.- ChartFX.



Para incorporar un componente a una forma solo basta seleccionarlo con un click derecho en su icono y luego colocar el cursor dentro de la forma en el lugar donde se quiere que aparezca y volver a hacer un click derecho.

También los componentes son objetos de C++Builder y como tales también tienen asociados propiedades y eventos, tales como los tiene la forma principal, solo que existen pequeñas variaciones en cuanto a sus propiedades y eventos propios con respecto a Form1.

Recordar además, que es el Inspector de Objetos en primera instancia quien permite asociar o modificar propiedades especificas tanto a una forma como a un componente.

Ya en segunda instancia las propiedades de formas y componentes se pueden modificar también directamente dentro de un programa, usando instrucciones como las ya descritas en párrafos muy anteriores.

Analizaremos ahora los dos primeros componentes, que también se usaran para construir o diseñar nuestro primer programa en C++Builder y Visual.

Este componente se utiliza para desplegar textos o mensajes estáticos dentro de las formas, textos tales como encabezados, solicitud al usuario del programa para que proporcione algún dato o información(edad, dame sueldo, etc.), en cierta forma hace las funciones de printf, cout, writeln, print, display, etc., pero solo cuando se consideran en su parte de mensajes.

También es un objeto en C++Builder y por tanto tiene asociados sus propias propiedades y eventos, al mismo tiempo como se está usando dentro del objeto form1, muchas propiedades que se definan para el objeto Form1, el objeto Label1 las va a heredar.

Si bien es cierto que el objeto se llama Label, pero cuando se ponen dentro de una forma C++Builder los va numerando automáticamente, si se ponen tres Labels en Form1, ellos se llaman o simbolizan o se procesan o programan con Label1, Label2, Label3.

Es la propiedad Caption, la que lleva el contenido del mensaje que se quiere desplegar en la pantalla, solo click derecho a un lado de la propiedad Caption en el Inspector de Objetos, teniendo seleccionada la caja Label1 en la forma y escribir el texto indicado.

Es el componente principal de la forma, contiene el código principal del programa y su activación por el usuario provoca que se realicen los principales procesos del problema planteado (aquí es donde se capturan datos, se realizan operaciones, etc.).

De este componente se maneja su propiedad Caption para etiquetarlo con la palabra “OK” o “ACEPTAR” o “EXE” , y su evento OnClick para activarlo, es en dicho evento donde se construye el código del programa.

Recordar que aunque no es un componente necesario en los programas, ya que el código se puede asociar o pegar a cualquier evento de cualquier forma, o componente del programa, Microsoft ya acostumbro a todos los usuarios al botón OK, de acuerdo, OK.

Este botón también puede activar su evento OnClick, cuando el usuario presione la tecla <ENTER>, solo poner la propiedad Default en true, en este caso el botón de ordenes, se le conoce como botón de default.

Igualmente puede activar su evento OnClick cuando el usuario, presione la tecla <ESC>, solo poner la propiedad Cancel en true, a este caso se le conoce como “CANCEL BUTTON”.

PRACTICA

Construir un primer programa que consiste en un forma que contenga los cinco datos mas importantes de un automóvil, y uno de esos datos solo deberá aparecer cuando el usuario haga click en el botón de ejecución o de orden o de OK.

Para este programa se ocupa, una forma, dos componentes labels para encabezados apropiados al problema, 10 componentes labels para textos y datos, un componente Button.

Para el ultimo componente Label su propiedad Caption se dejara en blanco o vacía para que sea el usuario del programa quien lo cargue al apretar el botón de ordenes o botón de OK.

Recordar que C++Builder va numerando automáticamente todos los componentes en el programa en forma consecutiva, es decir al finalizar el diseño del programa se tendrán, los componentes form1, label1,label2,label3,..button1.

El procedimiento completo para crear y ejecutar el programa es:

3.- Antes de poner el primer componente usar la opción, File Save Project As, aparece la siguiente ventana:



Donde se deberá seleccionar primero, el icono de nuevo folder( arriba a la derecha y tiene un folder con rayitos), esto es, para crear un nuevo folder o directorio donde quedara guardado o almacenado el programa, en cuanto se crea el nuevo folder, sobrescribir la palabra “new folder” que aparece, con el nombre que tendrá el directorio donde quedara almacenado el programa, escribir por ejemplo “programa uno” ( Windows95 ya permite que los nombres de directorios y sus archivos ya sean mas largos y no necesariamente del tipo antiguo de 8.3), al terminar de sobrescribir, la palabra “programa uno” apretar tecla <ENTER> y esperar un momento a que se cree el directorio.

Ya creado y renombrado el directorio, observar que en la parte inferior de la ventana el programa ya tiene el nombre de “Unit1.cpp”, a un lado esta una caja o botón de “OPEN”, mismo que se deberá apretar y después usar en la misma parte un botón llamado “SAVE” para almacenar “Unit1.cpp” y otra vez usar otro botón “SAVE” para almacenar “Project1.mak”.

4.- Ahora ya que se tiene Form1 en pantalla, recordar que se pueden modificar sus propiedades como color, font, etc. usando el Inspector de Objetos que esta a un lado de la forma ( se sugiere practicar un poco esto), los cambios que se hacen en el Inspector de Objetos se van reflejando automáticamente en la forma en pantalla y también en la ventana que el usuario vera al ejecutarse el programa.

5.- Ahora se selecciona con un click el componente llamado Label en la barra de componentes y luego poner el cursor dentro de la forma en el lugar donde se quiera que aparezca el componente, y volver a hacer click con el ratón para que ya aparezca dicho componente en la forma.

Observar que el componente en la forma, que esté seleccionado ( esto se puede hacer, usando un click dentro de el componente) se puede arrastrar para cambiarlo de lugar o posición o hacerlo mas pequeño o mas grande.

Como nota también a recordar siempre, un componente o la propia forma, está seleccionado, si el Inspector de Objetos lo esta referenciando, es decir es el Inspector de Objetos quien contiene el nombre del componente en la parte de arriba del propio Inspector de Objetos.

Para cargar o para que despliegue un texto el componente Label1, solo escribir dicho texto en la cajita que esta a un lado de la propiedad Captión en el Inspector de Objetos, por ejemplo para el problema, escribir la palabra “AUTOS ECONOMICOS”, y recordar que también esté componente también tiene propiedad font que se puede usar para alterar el tipo de letra que despliega el componente.

6.-Repetir el procedimiento anterior hasta tener los doce componentes Label bien acomodados y organizados en la forma y con sus textos correspondientes, solo recordar dejar el componente Label12 con su propiedad Caption en blanco(usando tecla backspace).

7.- Seleccionar y acomodar ahora un componente Button en la forma y colocarlo en la esquina inferior derecha, en su propiedad Caption = escribir la palabra “OK”.

Recordar que este componente, es quien contiene el código del programa y mas específicamente es su evento OnClick quien lo contiene y quien además lo activa o lo ejecuta.

Para añadirle el código(en este ejemplo que cargue el Caption de Label12 al tiempo de ejecución del programa y por decisión del propio usuario) existen dos maneras:

En el Inspector de Objetos, hacer click en la pestaña o folder llamado event y ahora en lugar de propiedades el Inspector de Objetos, muestra todos los eventos que el componente puede detectar(observar y anotarlos), ahora click en la cajita que esta a un lado del evento llamado OnClick y con este paso aparece el siguiente minieditor de programas de C++Builder:

Observar que ya trae listo el evento Button1Onclick(), para programarse y es dentro de sus llaves donde se construye el programa.

Solo escribir dentro de las llaves la instrucción Label12→Caption=”$ 5,000.00”;

8.- Ahora ya esta lista la forma o programa para ejecutarse, también existen dos maneras:

1.

2. Usar la opción Run que esta arriba en la barra de menús. 3.

Usar icono “run” en barra de herramientas

Nota.- También se puede usar también la primera letra dentro del botón de comando o de ordenes (OK), para activar las instrucciones o acciones del botón, es decir se puede usar click en botón o solo pulsar la letra O, para que se ejecute este ultimo procedimiento , solo poner un símbolo & en el caption del botón antes de la letra O.

El programa ya en ejecución debe ser similar(pero mejor diseñado) al siguiente ejemplo:



Ya que se practicó, la mecánica de creación de programas, resolveremos el problema de interactividad con el usuario.

Es decir en estos casos es el usuario quien generalmente proporciona los datos para su procesamiento en el problema, el trabajo del ingeniero de software, es procesarlos y darles sentido, coherencia y sobre todo eficiencia.

Para esto se ocupan , componentes llamados de “input”, “entrada” o “captura”, que permitan al usuario cargar o proporcionar un dato en ellos, dichos componentes son: