Laboratorio de programación II.

Grupo C

PRACTICA 0:EL IDE DE C++ BUILDER 5.0

Introducción
En esta práctica se van a realizar ejemplos sencillos referidos al entorno de programación de C++ Builder
5.0. El objetivo es familiarizarse con el entorno y descubrir algunas de las posibilidades que nos ofrece el
mismo. Para cada Ejercicio se deberá crear un Proyecto distinto. Para hacer uso de un turno de prácticas,
el alumno tiene la obligación de identificarse en el puesto que elija, pero como se va a trabajar en grupo
bastará con la identificación de uno de los miembros. Para ello cada alumno dispone de una cuenta
personal con una cuota de almacenamiento en disco y una cuota de volumen de impresión.

Ejercicio 1: Diseño de un formulario.

a. Diseñar el formulario.
Al iniciar una sesión en el entorno el aspecto de la aplicación será el siguiente:

En este ejercicio vamos a trabajar con el diseñador de formularios, que es la primera ventana que lleva
el nombre de Form1, y con la paleta de componentes, señalada en la figura siguiente:
Menú principal

Barra de herramientas Paleta de componentes

El ejercicio consiste en colocar componentes en un formulario y redimensionarlo para que quede
(aproximadamente) como se indica en la figura E1.Todos los componentes necesarios para realizar este
ejemplo se encuentran en la página de componentes Standard. Para colocar un componente en un

1
Laboratorio de programación II. Grupo C

formulario se debe seleccionar en la paleta de componentes el botón que representa al componente y a

continuación, pinchar sobre el formulario donde se desea colocarlo. Una estrategia alternativa (y menos
utilizada) es seleccionar el componente en la ventana Components, que se abre seleccionando View |
Component List.

Figura E1. Diseñar este formulario.

b.Crear y configurar el proyecto.

Cada aplicación debería estar en un directorio propio donde se guardarán todos los ficheros asociados
a la aplicación. Configurar una aplicación consiste en proporcionar nombres significativos al proyecto y
a los ficheros asociados al proyecto:

A) Si se acaba de arrancar C++ Builder aparece, por defecto el formulario Form1 está asociado al
proyecto Project1.bpr.

B) Si existe un proyecto vigente, lo más cómodo es crear una nueva aplicación (File | New
Application) salvando, si se desea el proyecto vigente.

En cualquier caso se crean por defecto (puede comprobarse usando el gestor de proyectos (View |
Project Manager):

1. Project1.bpr, fichero de proyecto.

2. Project1.cpp, fichero que contiene la función principal WinMain(),
3. Unit1.cpp, fichero que contiene las funciones asociadas al formulario principal (constructor de la
ventana y que posteriormente contendrá, además, los gestores de los eventos que puede gestionar), y
4. Unit1.h (especificacion de los componentes del formulario principal).

Los pasos para configurar el proyecto son los siguientes:

0. Crear un directorio para nuestra aplicación. Debería estar en el directorio Projects.
1. Cambiar el nombre (Propiedad Name) y título (Propiedad Caption) del formulario principal
utilizando el inspector de objetos.
2. Guardar ficheros asociados a ventanas (File | Save As) en el directorio adecuado para dar nombres
significativos a los ficheros.
3. Guardar el proyecto: (File | Save Project As) en el directorio adecuado.
4. Dar un nombre a la aplicación y fijar un icono.Estos datos aparecerán al minimizar el programa
durante su ejecución. Seleccionar Project | Options | Application.
5. Generar el ejecutable: Seleccionar Project | Build. Y ejecutar el programa : Seleccionar Run | Run.
Para nuestro formulario usar los siguientes datos:
Directorio: Ejercicio
Nombre y titulo del formulario: Formulario1

2
Laboratorio de programación II. Grupo C

Unidad asociada al formulario (Unit1.cpp, por defecto): main.cpp,

Proyecto (Project1.bpr, por defecto): Inicial.bpr.
Nombre de la aplicación: Mi primer formulario.
Icono: Icono por defecto.
Generar el ejecutable: Seleccionar Project | Build.
Ejecutar el "programa": Seleccionar Run | Run.

Ejercicio 2: Uso del inspector de objetos para modificar propiedades.

Cada componente tiene asociado un conjunto de propiedades y métodos y un conjunto de eventos a los
que puede responder. Con el inspector de objetos podremos moldear los componentes de una aplicación
según nuestras necesidades, en cuanto a su apariencia (propiedades) y funcionalidad (eventos a los que
puede responder). En la parte superior se especifica el objeto activo (en este caso debe aparecer
Formulario1:TForm1).Las propiedades del objeto activo aparecen en la página con la pestaña Properties
y los eventos a los que puede responder en la página con la pestaña Events. Para seleccionar un objeto
desde el inspector de objetos se despliega la lista de objetos y se selecciona el objeto en la lista. También
se puede seleccionar desde el diseñador de formularios pinchando (un solo click) sobre el objeto. Si lo
que se desea es modificar sus propiedades, se abre la carpeta de propiedades pinchando sobre la pestaña
Properties. Si lo que se desea es asociarle un gestor de eventos, se abre la carpeta de gestores de eventos
seleccionando la pestaña Events.

Vamos a cambiar el formulario diseñado en el ejercicio 1 para que tenga el aspecto que se indica en la
figura E2.

Figura E2. El formulario de la figura E1 modificado.

Las modificaciones se realizarán usando el Inspector de Objetos (pestaña Properties). En la lista siguiente
se detallan las modificaciones a realizar. Observar que, básicamente, se trata de modificar los valores de
las propiedades Caption y Name:

Caption: Se refiere al título o leyenda que acompaña a los componentes (por ejemplo, al texto que
aparece sobre un botón).

Name: Se refiere al nombre con el que se va a referenciar al componente desde el programa. Al ser un
identificador (como un nombre de variable, por ejemplo) debe ser significativo. Por defecto, C++ Builder
asigna nombres como Button1 y Button2 y es conveniente asignarles otros más clarificadores como
OKButton o ExitButton, por ejemplo.

Cuando se coloca un componente en un formulario, C++ Builder crea un puntero al componente en la

declaración del formulario (fichero main.h en este ejemplo) y gracias a ello se puede acceder al
componente a través del código. C++ Builder emplea la propiedad Name del componente para denominar
al puntero.

Así, las modificaciones a realizar son las siguientes:

Form1 : Caption = Form de Prueba y Name = MainForm.
Label1 : Caption = Nombre y Name = LabelEdit.

3
Laboratorio de programación II. Grupo C

Edit1 : Dejar vacío el valor de Text y Name = Edit.

RadioButton1 : Caption = Opción 1 y Name = RadioButton1.
RadioButton2 : Caption = Opción 2 y Name = RadioButton2.
CheckBox1 : Caption = Activar opciones, Name = CheckBox y Checked = true.
Button1 : Caption = OK, Name = OKButton y Enabled = false.
Button2 : Caption = Salir y Name = ExitButton.
Label2: Dejar vacío el valor de Caption y Name = LabelOutput.
Activar el cuadro de diálogo asociado a la propiedad Font y establecer los siguientes valores: Font = MS
Serif, Font Style = Bold, Size = 10 y Color = ClNavy.

Generar el ejecutable y ejecutar el "programa". El resultado se muestra en la figura E3.

Figura E3. Resultado de la ejecución tras modificar propiedades.

Ejercicio 3: Uso del inspector de objetos para escribir gestores de eventos.

Ahora se va a construir el gestor del evento que se genera al hacer click sobre el botón de salir, de forma
que al pinchar sobre este botón la aplicación termine su ejecución.

Para ello:

a) Seleccionar el componente ExitButton y en la pestaña Events del inspector de objetos, hacer doble click
en OnClick. El editor de código muestra el siguiente código, generado automáticamente:
//------------------------------------------------------------

void __fastcall TMainForm::ExitButtonClick(TObject *Sender)

{

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

b) Escribir el siguiente código:

//------------------------------------------------------------
void __fastcall TMainForm::ExitButtonClick(TObject *Sender)
{
Application->Terminate();
}
//------------------------------------------------------------

c) Generar el ejecutable y ejecutar el programa: al hacer click sobre el botón de salir, el programa deja de
ejecutarse.

Ejercicio 4: Una aplicación de consola.

Los componentes constituyen los bloques básicos sobre la que se construyen aplicaciones Windows con
C++ Builder basadas en la VCL (Visual Component Library). Una aplicación de consola no utiliza los

4
Laboratorio de programación II. Grupo C

objetos de la VCL, y el aspecto de una aplicación de este tipo es el generado por los compiladores
"tradicionales", ejecutándose sobre una consola MS-DOS.

Una aplicación de consola se crea usando el asistente Console Wizard para lo cual:
a)Crear un directorio para la aplicación

b)Seleccionar File | New | Console Wizard y en el asistente, indicar que se va a crear una aplicación de
consola (Console).

El editor de código aparece de la siguiente manera:

5
Laboratorio de programación II. Grupo C

c)Escribir el código de la aplicación en el archivo Unit1.cpp.:

#pragma hdrstop
#include <condefs.h>
#include <iostream.h>
#include <conio.h>
//-----------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
for (int i=0; i<5; i++)
cout << "Valor de i = " << i << endl;
getch();
return 0;
}
//-----------------------------------------------------------

d)Guardar el proyecto y ejecutar el programa.

– Se selecciona File | Save y se guarda Unit1.cpp con el nombre que se desee como por ejemplo
Consola.cpp

6
Laboratorio de programación II. Grupo C

– Se selecciona File | Save Project As y se guarda Project1.bpr con el nombre que se desee como por
ejemplo Consola.bpr.

– Se selecciona Project | Build Console

7
Laboratorio de programación II. Grupo C

– Se selecciona Run | Run

Ejercicio 5: Una aplicación visual.

Vamos a escribir un programa que lanza una ventana de mensaje con un saludo:

a) Creamos un directorio para la aplicación, y a continuación creamos la nueva aplicación seleccionando

File | New Application.

b) La aplicación no tendrá un formulario y por defecto se asocia uno a la aplicación por lo que se debe
borrar. Para ello se activa el formulario y a continuación se selecciona Project | Remove from
project. Unit1.cpp tiene asociado el formulario principal Form1, de forma que al confirmar el
borrado se eliminan tanto Unit1.cpp como Unit1.h del proyecto vigente.

c) Para escribir el código del programa, seleccionar Project | View Source y escribir el siguiente código:
//-----------------------------------------------------------

#include <vcl.h>

8
Laboratorio de programación II. Grupo C

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

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{
ShowMessage ("Hola");
return 0;
}
//-----------------------------------------------------------

d) Finalmente, guardar el proyecto y ejecutar el programa. Para ello Seleccionar File | Save Project As y
guardar Project1.bpr como Saludo.bpr. Ahora se puede construir el ejecutable y probarlo:
seleccionar Project | Build Saludo y a continuación, Run | Run. El resultado de la ejecución será el
siguiente:

Ejercicio 6: Otra aplicación visual.

Vamos a crear un programa que presenta los valores guardados en un vector en una ventana de mensajes,
presentando cada valor individualmente.

a) Creamos un directorio para la aplicación, y a continuación creamos la nueva aplicación seleccionando

File | New Application.

b) La aplicación no tendrá un formulario y por defecto se asocia uno a la aplicación por lo que se debe
borrar. Para ello se activa el formulario y a continuación se selecciona Project | Remove from
project. Unit1.cpp tiene asociado el formulario principal Form1, de forma que al confirmar el
borrado se eliminan tanto Unit1.cpp como Unit1.h del proyecto vigente.

c) Para escribir el código del programa, seleccionar Project | View Source y escribir el siguiente código:
//-----------------------------------------------------------

#include <vcl.h>

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

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{
for (int i=0 ;i<5 ;i++){
ShowMessage ("Valor de i = " + AnsiString(i));
}

return 0;
}
//-----------------------------------------------------------

d) Finalmente, guardar el proyecto y ejecutar el programa. Para ello Seleccionar File | Save Project As y
guardar Project1.bpr como Ciclo.bpr. Ahora se puede construir el ejecutable y probarlo:
seleccionar Project | Build Saludo y a continuación, Run | Run. El resultado de la ejecución, en cada

9
Laboratorio de programación II. Grupo C

iteración, será el siguiente. Para pasar a la siguiente iteración hay que pulsar el botón OK, de forma que
en cada iteración aparece una sóla ventana. El resultado de la ejecución será el siguiente:

Primera iteración Segunda iteración ...... Quinta iteración

......

Ejercicio 7: Y otra más.

Vamos a crear un vector dinámico de 5 enteros y se mostrará su contenido en una única ventana.

a) Creamos un directorio para la aplicación, y a continuación creamos la nueva aplicación seleccionando

File | New Application.

b) La aplicación no tendrá un formulario y por defecto se asocia uno a la aplicación por lo que se debe
borrar. Para ello se activa el formulario y a continuación se selecciona Project | Remove from
project. Unit1.cpp tiene asociado el formulario principal Form1, de forma que al confirmar el
borrado se eliminan tanto Unit1.cpp como Unit1.h del proyecto vigente.

c) Para escribir el código del programa, seleccionar Project | View Source y escribir el siguiente código:
//-----------------------------------------------------------
#include <vcl.h>
//-----------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
int *vector;
AnsiString cadena = "";
vector = new int[5];
for (int i=0; i<5; i++) {
vector[i] = i*2;
cadena = cadena + "vector[" + AnsiString (i) +
"] = " + AnsiString (vector[i]) + "\n";
}
ShowMessage (cadena);
delete [ ]vector;
return 0;
}
//-----------------------------------------------------------

e) Finalmente, guardar el proyecto y ejecutar el programa. Para ello Seleccionar File | Save Project As y
guardar Project1.bpr como Vector.bpr.La ejecución de este programa produce el siguiente
resultado:

10
Laboratorio de programación II. Grupo C

Ejercicio 8: Otros elementos.

Ahora vamos a centrarnos en otras características del entorno:
a)El Inspector de clases y el Administrador de proyectos
En la ventana del editor de código pueden "pegarse" el gestor de proyectos y el inspector de clases (véase
en la figura más abjo) aunque estas dos herramientas pueden aparecer también como ventanas separadas.

Inspector de clases: Es un navegador que muestra las clases, objetos y métodos asociados a la aplicación.
Aparece por defecto asociada al editor (en la figura 10, en la parte inferior izquierda). Para abrir esta
ventana: View | ClassExplorer.

Administrador de proyectos: Es básicamente un navegador entre los diferentes ficheros que forman la
aplicación. No aparece por defecto, y cuando se abre (View | Project Manager) se muestra como una
ventana independiente. En la figura se muestra asociada al editor, en la parte superior izquierda.

Se propone el siguiente ejercicio:

1) Creamos un directorio para la aplicación, y a continuación creamos la nueva aplicación seleccionando
File | New Application.
2) Selecciona la ventana del editor de código que aparece titulada como Unit1.cpp. Si te fijas en la parte
izquierda hay una ventana rectangular que corresponde al inspector de clases.
3) Queremos añadir a dicho editor el administrador de proyectos. Para ello pulsa(View | Project
Manager), y se abrirá. A continuación seleccionando con el ratón sobre el administrador sitúalo sobre el
área donde se encuentra el inspector de clases.

b)El sistema de ayuda.

El sistema de ayuda será una de las herramientas que más útiles resultará en nuestro trabajo con C++
Builder. Especialmente la documentación de los componentes y clases predefinidas. Saber programar con
C++ Builder no significa dominar todos y cada uno de los aspectos del entorno, sino que más bien es
conocer los principios en los que éste se basa, y los detalles concretos ya los buscaremos en la Ayuda
cuando nos sean necesarios.

La ayuda es una ayuda estándar de Windows por lo que no entraremos en más detalles, sólo comentar que
pulsando F1 obtendremos una ayuda contextual. Así, por ejemplo, en el caso de hacerlo en el editor de

11
Laboratorio de programación II. Grupo C

código, se nos ofrecerá la ayuda correspondiente a la palabra que se encuentre bajo el cursor. De igual
forma ocurrirá si nos situamos sobre cualquier opción de un menú.

En la aplicación anterior podemos probar lo siguiente:

a) Sitúate sobre el editor de código y busca la palabra TForm, colocando al lado el cursor. Entonces pulsa
F1, y comprueba que te aparece la siguiente ventana.

b) Ahora abre el menú (View | Project Manager) y pulsa la tecla F1, y comprueba que te aparece la
siguiente ayuda:

12
Laboratorio de programación II. Grupo C

c) La depuración de los programas.

c.1) Ejecución Paso a Paso.

Se realiza desde la ventana del editor de código y se debe estar en modo de pausa. Para ello basta pulsar
la opción de pausa cuando se está ejecutando el programa. En esta situación se pueden realizar diferentes
operaciones de depuración:
*Ejecución de una simple sentencia.
En modo de pausa aparece la línea que se ejecutará en el siguiente paso, y si no aparece podemos usar
la opción (Run | Show Execution Point). Para ejecutar la sentencia podemos usar (Run|Trace Into) o
bien F7. Entonces se ejecutará la sentencia, y se vuelve al estado de depuración.

Para probar esta opción:

1)Vuelve al programa de consola , y cambia el contador del for, y en vez de i<5, escribe i<1000000.
2)Ejecuta la aplicación, y en un momento dado párala usando el botón de pausa.
3)Usa la opción (Run | Show Execution Point) para ver cual es la siguiente línea a ejecutar.
4)Ejecutala (Run|Trace Into) o bien con F7. Comprueba que la línea de ejecución ha cambiado.

*Ejecución hasta un punto.

Consiste en ejecutar el programa hasta llegar a una cierta sentencia, para ello situamos el cursor en la
sentencia y podemos hacer una de las siguientes cosas:

*Pulsar con el ratón en el margen izquierdo de la sentencia.

*Pulsar F5.
*Pulsar en el menú Debug|Toggle Breakpoinr, del menú emergente del editor de código.

Observar que estas mismas opciones sirven para eliminar un punto de parada.

Cuando se ejecuta el programa se para en las líneas marcadas y se pasa a estado de depuración. Estos
puntos de parada se denominan incondicionales pues siempre se para en ellos, sin embargo también se
pueden definir puntos de paradas condicionales, en los cuales se para en función de que se cumpla
cierta condición o que se haya pasado un cierto número de veces sobre cierta sentencia. Para introducir
un punto de parada condicional, situamos el cursor en la línea en la que estableceremos el punto de
parada y tecleamos (Run|Add BreakpointÆSource Breakpoint). Esto genera una ventana que contiene
entre otros datos, el nombre del modulo, el número de línea donde se ha situado el punto de parada, la
condición de parada que debe definirse en función de valores, variables e identificadores conocidos, y
el número máximo de veces que puede ejecutarse la sentencia antes de que se pare el programa.

Para probar esta opción:

1)Usando de nuevo el programa de consola, situarse sobre la sentencia que incluye el for, y pulsar la
opción (Run|Add BreakpointÆSource Breakpoint).
2)En la ventana que aparece modificar el valor que aparece para el número de repeticiones, e introducir
el valor de 5.
3)Ejecutar de nuevo el programa y observar el comportamiento del programa.

Se puede acceder a una ventan que contiene todos los puntos de parada en el código pulsando la opción
(View|Debug Windows).

*Finalizar la depuración.
Para finalizar la depuración pulsamos una de las siguientes opciones:
*F9
*Run|Program Reset.
*Control+F2.

c.1) Inspección de valores y evaluación de expresiones.

Las siguientes opciones sólo están disponibles en el estado de pausa:

a)Para conocer el contenido de una variable o propiedad lo único que hay que hacer es situar el ratón
sobre ella, de forma automática aparecerá una pequeña ventana con el valor actual.

13
Laboratorio de programación II. Grupo C

b)Si deseamos conocer el contenido de una variable o evaluar una expresión pulsamos:

*Control+ F7.
*Run|Evaluate|Modify.

Entonces aparece una ventana donde podemos introducir una expresión cuyo contenido queremos
conocer. Entonces pulsamos el botón Evaluate y en el área inferior aparecerá el resultado. Si lo que
hemos evaluado era una variable, se puede modificar su valor usando el área de New Value y pulsando
el botón de Modify.

c)Si deseamos conocer el contenido de una variable o evaluar una expresión con frecuencia pulsamos:

*Control+ F5.
*Run|Add Watch.

Entonces aparece una ventana en la que establecemos la variable o expresión a examinar, y a

continuación pulsamos Enter y aparece una lista con un elemento conteniendo el identificador de la
variable o la expresión y su valor actual. Mediante las opciones existentes en la parte inferior se puede
seleccionar el tipo del dato a mostrar, el número de dígitos, el factor de repetición

d)Hay una última opción interesante en View|Debug WindowsÆLocal Variables, que al seleccionarla nos
muestra las variables locales existentes, pudiendo ver el valor de dichas variables a medida que se ejecuta
paso a paso la aplicación.

Se propone como actividad probar estas opciones sobre la aplicación de consola.

14