Programación en C++ con C++Builder

Programación en C++ con C++Builder 1

Programación en C++ con

C++Builder

Versión de borrador N°6 Mayo - 2005

Angel A. Zeitoune ([email protected])

y Ricardo A. Rettore ([email protected])

• Esta es una versión borrador, cualquier duda o sugerencia por favor escribir a cualquiera de los autores.

• Este libro sufre continuas modificaciones y ampliaciones, de acuerdo a la disponibilidad de los autores. La última versión la podrán encontrar en la página Web: http://www.angelzeitoune.com.ar/cpp/libro_cpp.html

mailto:([email protected])

mailto:([email protected])

http://www.angelzeitoune.com.ar/cpp/libro_cpp.html


Licencia Este libro se distribuye bajo esta licencia de Creative Commons Reconocimiento-

NoComercial-SinObraDerivada 2.0 (http://creativecommons.org/licenses/by-nc-nd/2.0/).

Presentamos un resumen más legible de esta licencia.

Usted es libre de:

• copiar, distribuir y comunicar públicamente la obra

Bajo las condiciones siguientes:

Reconocimiento. Debe reconocer y citar al autor original.

No comercial. No puede utilizar esta obra para fines comerciales.

Sin obras derivadas. No se puede alterar, transformar o generar una obra derivada a partir de esta obra.

• Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de la licencia de esta obra.

• Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de los derechos de autor

Los derechos derivados de usos legítimos u otras limitaciones no se ven afectados por lo anterior.

http://creativecommons.org/licenses/by-nc-nd/2.0/


Índice

Índice............................................................................................................................................. 3

Introducción.................................................................................................................................. 5

Capítulo 1: Entorno de desarrollo. ............................................................................................... 6 Creando un proyecto. ................................................................................................................. 7 Conociendo los componentes...................................................................................................... 8 Primera aplicación.................................................................................................................... 12

Capítulo 2: Programación Orientada a Objetos (POO)............................................................. 17 Clases (class)............................................................................................................................ 17 Diagrama de clase. ................................................................................................................... 21 Constructor. ............................................................................................................................. 21 Destructor. ............................................................................................................................... 22 Resumen de conceptos importantes:.......................................................................................... 23 Cuándo y porque modelamos una clase..................................................................................... 23 Encapsulamiento ...................................................................................................................... 24 Herencia................................................................................................................................... 24 Clases contenedoras. ................................................................................................................ 28 Diferencia entre Registros y Clases........................................................................................... 31

Capítulo 3: Lógica de control ..................................................................................................... 33 Expresión lógica....................................................................................................................... 33 Estructura condicional “if” ....................................................................................................... 34 Estructura condicional “switch”................................................................................................ 36

Capítulo 4: Estructuras Repetitivas ........................................................................................... 38 Ciclo for................................................................................................................................... 38 Ciclo while............................................................................................................................... 40 Ciclo do-while.......................................................................................................................... 41 Instrucciones break y continue.................................................................................................. 42

Capítulo 5: Vectores y Matrices ................................................................................................. 44 Declaración.............................................................................................................................. 44 Ejemplo. .................................................................................................................................. 45

Capítulo 6: Cadenas de caracteres ............................................................................................. 56 char.......................................................................................................................................... 56 c-string..................................................................................................................................... 56 c++ string................................................................................................................................. 57 AnsiString................................................................................................................................ 57 Ejemplos.................................................................................................................................. 59

Capítulo 7: Archivos de Texto. ................................................................................................... 62 Creación del objeto................................................................................................................... 62 Apertura del archivo. ................................................................................................................ 63 Cierre del archivo. .................................................................................................................... 64 Manipulación del archivo. ........................................................................................................ 64


Ejemplos.................................................................................................................................. 70

ANEXO I: Tabla de caracteres ASCII ....................................................................................... 72

ANEXO II: funciones.................................................................................................................. 73 Conversiones de tipo ................................................................................................................ 73 Funciones matemáticas............................................................................................................. 73


Introducción. Esta obra nace con la necesidad de contar con un libro que permitiese aprender a

programar en C++ al mismo tiempo que enseñase a utilizar como herramienta a Borland® C++Builder, y dada su carencia en el mercado, decidimos desarrollarlo.

C++Builder es una herramienta de desarrollo rápido de aplicaciones (RAD, rapid application development) para Windows, en lenguaje de C++, que posee varias características importantes, lo cual facilita el desarrollo de aplicaciones gráficas.

Queremos aclarar que en este curso, sólo presentaremos una breve introducción al uso de la herramienta de programación C++Builder y conocimientos mínimos para lograr el aprendizaje del lenguaje.

A lo largo de este libro nos introduciremos al entorno de desarrollo, presentando sus características, su utilización y algunos componentes básicos.

Posteriormente concentraremos en la programación orientada a objetos, diseño e implementación, resaltando los conceptos en todo momento, para permitir al lector formarse con una base sólida.

Desarrollaremos las estructuras de programación básica, lógica de control, estructuras repetitivas, y manipulación de vectores y matrices estáticas.

Expondremos diferentes formas de manipular las cadenas de caracteres, para lograr generar una idea global sobre el tema, concentrándonos sobre la clase AnsiString propia de Borland®.

Culminaremos con manipulación de archivos de texto, cuyo uso es sumamente frecuente para almacenar información, intentando proveer un amplio abanico de ejemplos con sutiles diferencias para evaluar su funcionamiento.

Esperamos que les guste y sobre todo les sea útil.

Angel Zeitoune y Ricardo Rettore


Capítulo 1: Entorno de desarrollo. Una vez iniciado el programa, nos presentará su IDE (integrated development

environment, entorno de desarrollo integrado), que provee todas las herramientas necesarias para diseñar, desarrollar, testear y compilar aplicaciones. Se observa lo siguiente:

Entre los elementos que forman el IDE, se puede nombrar: Formulario (Form): representa la ventana de aplicación, que a su vez puede

contener a otros objetos componentes (objetos).

Editor de Código (Code Editor): aparece, inicialmente, atrás del formulario. Es un editor de texto avanzado que contiene el código fuente del programa.

Ventana Principal (main window): Contiene la barra de título, el menú principal, barra de acceso rápido (SpeedBar), y la paleta de componentes (Component palette).

Inspector de Objetos (Object Inspector): esta dividido en dos páginas, propiedades y eventos, las cuales están asociadas al componente seleccionado.


Creando un proyecto. Al iniciarse, C++Builder, esta listo para comenzar un nuevo proyecto. Si estabamos

en el entrono y queremos crear uno nuevo existen dos formas de hacerlo:

• En el menú principal File/New Application.

• En el menú principal File/New, donde se nos presenta una ventana de “new item”, donde seleccionamos Application.

Un nuevo proyecto esta formado (por defecto) por los archivos de proyecto, y un formulario con su respectiva unit.

También podremos incluir a nuestro proyecto, nuevos formularios, units, módulos de datos, archivos de texto, etc. con la opción File/New.

Lo primero que realizaremos, es grabar nuestro proyecto con nombres significativos al programa que estemos realizando en una carpeta especialmente destinada a nuestro proyecto.

Si analizamos un poco, los archivos que se encuentran en esta carpeta podremos observar una serie de archivos extras al que nosotros grabamos. Podemos distinguir estos archivos según sus extensiones:

Extensión Contenido .h Archivo de cabecera. Contiene la declaración de la clase.

.cpp Archivo fuente de C++. Implementación del archivo .h, Usualmente tenemos uno por cada unit y uno por el proyecto principal.

Sugerencia: Al nombre del archivo de proyecto le antepondremos una P (por ej. PNombre.bpr) y al nombre de la unit asociada al formulario le antepondremos una F (por ej. FNombre.cpp), y a una unit sin formulario con una U (por ej. UNombre.cpp).


.dfm Archivos del formulario. Es un archivo de texto que contiene características de los elementos visuales.

.bpr Archivo de proyecto

.exe Programa ejecutable.

.res Archivo de recursos. Se guardan en este archivo el icono de nuestra aplicación entre otras cosas.

.obj Archivo objeto. Es un archivo binario que produce el compilador de nuestro proyecto antes de armar el ejecutable.

.tds Tabla simbólica de depuración.

.~h .~cpp .~dfm Archivos temporales de los anteriores

Conociendo los componentes. C++Builder, nos presenta una serie de componentes previamente definidos, en una

“paleta de componentes”, agrupados en un conjunto de páginas de acuerdo con las finalidades de los mismos.

Para insertarlos en un formulario, existen tres maneras:

• Haciendo click sobre el mismo y luego sobre el formulario.

• Hiendo doble click sobre el componente.

• Haciendo click sobre el componente y luego manteniendo presionando el botón izquierdo del mouse sobre el formulario, dando el tamaño deseado al mismo.

El inspector de objetos nos presenta las propiedades y eventos asociados a los elementos que componen la interfaz gráfica.

Analizaremos las propiedades, métodos y eventos más importantes de los

principales componentes:

Form: El formulario representa la ventana de una aplicación. Un formulario, a su vez,

puede contener otros componentes, como Button, Label, CheckBox, etc.

Propiedades:

Avanzado: Los componentes, están conformados en una biblioteca visual de componentes (Visual Component Library), llamada VCL, que se basa en modelo de propiedades, métodos y eventos (PME). La VCL es una jerarquía de clases escrita en Object Pascal asociada al IDE de C++Buider.


Name: Representa el nombre lógico con el que se referencia al componente. Caption: permite modificar el texto del título del formulario.

Font: modifica el tipo de letra (fuente, estilo de fuente, tamaño, etc.) de los componentes que están contenidos en el formulario.

Position: especifica la posición del formulario. Puede ser por diseño, en el centro de la pantalla, centro del escritorio, etc.

Height y Width: representan el alto y ancho del formulario en pixeles. Left y Top: posición izquierda y superior del extremo superior izquierdo del

formulario en pixeles.

Eventos: OnCreate: este evento ocurre cuando el formulario se crea.

OnShow: ocurre cuando el formulario es mostrado (cuando el propiedad Visible es True).

OnActivate: ocurre cuando se activa el formulario (cuando el formulario recibe el foco).

OnPaint: ocurre cuando el formulario es redibujado (redraw).

OnClose: ocurre cuando el formulario se cierra.

Button, BitBtn y SpeedButton: Button es un botón estándar de Windows, mientras los que los otros amplían sus

funcionalidades como permitir incluir un bitmap.

Propiedades:

Name: Representa el nombre lógico con el que se referencia al componente. Caption: permite modificar el texto del botón.

Font: modifica el tipo de letra (fuente, estilo de fuente, tamaño, etc.) del caption. Height y Width: representan el alto y ancho del botón en pixeles.

Left y Top: posición izquierda y superior del extremo superior izquierdo del botón relativa al del formulario en pixeles.

Enabled: Habilita o deshabilita la respuesta del botón a eventos.

Nota: al crearse un formulario, la creación de este sigue esta secuencia de eventos mencionados, OnCreate, OnShow, OnActivate y On Paint.


Hint: es un pequeño texto que aparecerá sobre el botón cuando el usuario coloque el mouse sobre el botón. Para que aparezca el Hint debe colocarse la propiedad ShowHint en valor “True”. Estas propiedades se encuentran en la mayoría de los componentes visuales.

Visible: determina cuando el botón aparece en el formulario.

Glyph (sólo en BitBtn y SpeedButton): permite especificar el bitmap que aparece en el botón.

Kind (sólo en BitBtn): determina el tipo de algunos bitmap predefinidos. Flat (sólo en SpeedButton): hace desaparecer el efecto 3D de los botones.

Down (sólo en SpeedButton): especifica cuando el botón está presionado. Para quedar presionado la propiedad GroupIndex debe ser distinta de cero.

TabOrder: especifica el orden en el que los componentes tendrán el foco.

Eventos:

OnClick: ocurre cuando se hace click sobre el botón. OnMouseMove: ocurre cuando se mueve el mouse sobre el botón.

Métodos: SetFocus: coloca el foco en el botón.

Label: Componente que permite mostrar texto en un formulario. Es usado para mostrar

resultados e información al usuario, debido a que él no puede editarlo. No puede contener el foco en una aplicación.

Propiedades: Name: Representa el nombre lógico con el que se referencia al componente.

Caption: permite modificar el texto del label (etiqueta). Font: modifica el tipo de letra (fuente, estilo de fuente, tamaño, etc.) del caption.

Alignment: permite especificar la alineación del texto. Puede ser hacia la derecha, izquierda o centrada.

Edit: Caja de edición, que permite editar un texto de una sola línea. Se utiliza para que el

usuario introduzca información.

Propiedades:

Sugerencia: probar cambiar el color de la fuente en todos los botones.


Name: Representa el nombre lógico con el que se referencia al componente. Text: es el texto asociado al edit.

Font: modifica el tipo de letra (fuente, estilo de fuente, tamaño, etc.) del caption. CharCase: permite especificar los caracteres en mayúscula o minúscula.

MaxLength: cantidad máxima de caracteres que se pueden introducir. ReadOnly: especifica que el texto es de solo lectura.

Eventos: OnChange: ocurre cuando le texto es modificado.

CheckBox y RadioButton: Son componentes de selección. Se diferencian en que el primero permite seleccionar

varias opciones simultáneamente, mientras el segundo sólo permite la selección de un único elemento dentro de un mismo grupo.

De ahora en adelante sólo veremos las propiedades, métodos y eventos que caracterizan a los componentes.

Propiedades: Checked: especifica cuando el componente está seleccionado.

ListBox: Es un componente que permite visualizar y manipular una lista de elementos

(items).

Propiedades: Items: contiene los elementos del ListBox; es del tipo TStrings (lista de strings).

Esta clase, a su vez, contiene métodos que permiten manipular elementos como agregar (Add), insertar (insert), eliminar (delete) y mover (move).

Columns: especifica el número de columnas.

MultiSelect: permite seleccionar varios elementos al mismo tiempo. Sorted: ordena automáticamente los elementos alfabéticamente.

Métodos: Clear: Borra todos los elementos del ListBox.

Investigar: cómo puedo especificar diferentes grupos de RadioButton, de manera que me permitan seleccionar una opción de cada grupo?


Memo: Es un componente estándar de Windows, que permite manipular texto multilínea,

tanto para el ingreso por parte del usuario como informar textos de gran longitud.

Propiedades: Lines: contiene los líneas de texto que están contenida en el Memo; es del tipo

TStrings (lista de strings), al igual que los Ítems del ListBox.

ScrollBars: determina cuales barras de desplazamientos se van a mostrar.

Métodos: Clear: Borra el contenido del Memo.

Otros: Una vez experimentado con estos componentes, se sugiere continuar investigando,

otros como:

MainMenu.

ComboBox.

Panel.

StringGrid.

Image.

StatusBar.

Timer.

Primera aplicación A continuación, comenzaremos el acercamiento al programa con un clásico ejemplo

sencillo y didáctico (el viejo y conocido “Hola Mundo”) para explicar y mostrar qué parte de código debemos escribir nosotros y qué parte de código implementa por defecto C++Builder, y que por lo tanto no debemos escribir ni alterar.

El objetivo del siguiente programa, es muy simple, solo mostrará en pantalla la frase “Hola Mundo” en el instante en que oprimamos el botón “oprimir”.

En principio, veremos que al ejecutar una nueva aplicación, automáticamente se crea un formulario y una unit, la cual está asociada al formulario, por ello, cualquier cambio


que hagamos al formulario, se reflejará en la unit asociada donde veremos que se ha agregado código ante cualquiera de estas modificaciones.

Los pasos iniciales: + Abrir una nueva Aplicación.

+ Guardar el Proyecto: File/Save Project As, ubicar la carpeta donde irá guardado el proyecto, y guardar la Unit1 (asociada al formulario) con el nombre fHolaMundo (f para hacer referencia al formulario), y el Project1 con el nombre pHolaMundo.

En el caso que nuestro programa requiera de una unit adicional, la misma se guardará con el nombre “uNombreDelPrograma”, donde u hace referencia a que la unit fue creada por el usuario.

Los pasos para hacer el formulario son: 1. Formulario.

a. Cambiar el Name a Hola. b. Cambiar el Caption del formulario por Hola Mundo.

2. Botón que muestra el Cartel

a. Colocar un Botón (BitBtn). i. Cambiarle el Tamaño.

ii. Cambiar el Name a “Boton”. iii. Cambiar la Propiedad Kind seleccionando bkAll.

iv. Cambiar la Propiedad Caption, sin borrar el carácter “&”, escribir Oprimir. El & subraya la letra que sigue a continuación, esto habilita al botón a ejecutarse con las teclas Alt + o (letra subrayada).

3. Botón que Cierra el Programa.

a. Colocar un Botón (BitBtn). i. Cambiarle el Tamaño.

ii. Cambiar el Name a “Salir”. iii. Cambiar la Propiedad Kind seleccionando bkClose.

iv. Cambiar la Propiedad Caption, sin borrar el carácter “&”, escribir Salir. El & subraya la letra que sigue a continuación, esto habilita al botón a ejecutarse con las teclas Alt + s (letra subrayada).

4. Etiqueta que mostrará el cartel.

a. Colocar un Label. i. Cambiar el Name a “Etiqueta”.


ii. Cambiar Font Name a Georgia y Font Size a 20. iii. Borrar el Caption.

Para codificar los que harán los botones al oprimirse, hacer doble clic sobre los

mismos, automáticamente se genera el evento onclick del botón, es allí donde debemos escribir.

Ahora pasemos directamente a ver el código. Lo que está escrito en azul es lo que Builder genera sólo y en rojo lo que nosotros agregamos.

Este es el fHolaMundo.h //----------------------------------------------------------- #ifndef fHolaMundoH #define fHolaMundoH //----------------------------------------------------------- #include <Classes.hpp> #include <Controls.hpp> #include <StdCtrls.hpp> #include <Forms.hpp> #include <Buttons.hpp> //----------------------------------------------------------- class THola : public TForm { __published: // IDE-managed Components TBitBtn *Boton; TLabel *Etiqueta; TBitBtn *Salir; void __fastcall BotonClick(TObject *Sender); void __fastcall SalirClick(TObject *Sender); private: // User declarations public: // User declarations __fastcall TForm1(TComponent* Owner); }; //-----------------------------------------------------------


extern PACKAGE THola *Hola; //----------------------------------------------------------- #endif Como podemos apreciar en este archivo no realizamos ninguna modificación. Ahora veremos el fHolaMundo.cpp

//----------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include "fHolaMundo.h" //----------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" THola *Hola; //-----------------------------------------------------------

__fastcall THola::THola(TComponent* Owner) : TForm(Owner) { } //----------------------------------------------------------- void __fastcall THola::BotonClick(TObject *Sender) { Etiqueta->Caption="Hola Mundo"; } //-----------------------------------------------------------void __fastcall THola::SalirClick(TObject *Sender) { Close();


} //-----------------------------------------------------------

Como vemos en este archivo solo agregamos dos líneas y ya tenemos nuestro primer programa funcionando.

A continuación veremos cómo queda el formulario una vez ejecutado el programa y oprimido el botón “Oprimir”.


Capítulo 2: Programación Orientada a Objetos (POO) La idea básica que soporta el enfoque OO es muy simple, percibimos al mundo

como una variedad de objetos: televisores, lámparas y otros, pero cuando se enciende el televisor no se distingue entre sus elementos físicos (tubo de pantalla, antena, etc.) y su comportamiento. Sólo lo encendemos y seleccionamos un canal.

Los objetos modelan las características y el comportamiento de los elementos del mundo en que vivimos, son la abstracción de los datos más acabada hasta el momento. En la POO el sistema se organiza alrededor de los atributos y no de las acciones, lo cual permite obtener sistemas más estables ya que los datos tienen una vida útil mayor que las funciones.

En la POO las variables son activas, es decir, además de tener propiedades tienen comportamiento y es el comportamiento el que hace que la variable sea activa en lugar de estar esperando que algún código la manipule como las variables tradicionales.

La POO encapsula los datos (atributos) y el comportamiento (métodos) en paquetes llamados clases, las cuales son el la unidad básica.

Hay tres propiedades principales que caracterizan un lenguaje de POO, las cuales iremos describiendo más adelante:

• Encapsulamiento

• Herencia.

• Polimorfismo. La POO permite el ahorro de tiempo en el desarrollo de programas, promueve la

reutilización de código de alta calidad, probado y depurado, reduciendo así las posibilidades de errores.

Como resumen podemos enunciar algunas de las grandes ventajas que posee

• Disminuye el tiempo de desarrollo de aplicaciones.

• Fácil mantenimiento

• Simple extensibilidad.

Clases (class). Una clase es una abstracción, que modela las características y comportamientos de

un objeto, la cual debe incluir funcionalidades que permitan informar o modificar el estado de esa entidad, como así también, realizar diversas acciones para las cual fue diseñado.

Para el modelaje de esta clase, se debe determinar un conjunto de atributos que la definen, y un conjunto de funcionalidades que representan sus posibilidades de interacción.


Primero aprenderemos a definir una clase y luego veremos como podemos usarla creando un objeto, creando una clase derivada o como atributo de otra clase.

La definición de una clase se divide en dos partes, la declaración de la cabecera y la implementación (implementación de los métodos).

La declaración de la cabecera se realiza mediante la palabra reservada class. Una clase esta dividida en diferentes secciones, de acuerdo a la característica determinante de sus miembros. Cada sección esta encabezada por especificadotes de sección, las cuales pueden ser:

• private: indica que los miembros pertenecientes podrán ser accedidos solamente dentro de la clase.

• public: indica que los miembros pertenecientes podrán ser accedidos tanto dentro de la clase como por otras clases.

• protected: indica que los miembros pertenecientes podrán ser accedidos dentro de la clase y por sus descendientes, pero son privados para otras clases.

• published: los miembros pertenecientes, son idénticos a public, pero además toda propiedad será visualizada en el inspector de objetos.

La estructura es la siguiente: class NombreDeLaClase { private: tipo variable1; public: void Metodo1(void); void Metodo2(tipo variable2); tipo Metodo3(void); __property float Propiedad1 = {read = variable1, write = variable1}; };

Las palabras reservadas private y public son especificadores de acceso privado y publico respectivamente, es decir, todos los métodos declarados en el área publica podrán ser accedidos por cualquier clase, mientras los privados sólo por la misma clase. Otros especificadores de acceso son protected, published, y automated.

Se puede observar en esta estructura, que hemos declarado en la sección privada una variable global y dos métodos en la sección pública.

Cada variable debe ser de un tipo, es decir, a un tipo de dato existente en C++Builder. Como puede ser float, double, int, etc. También puede ser un tipo de dato definido por el programador. Además una variable posee un nombre lógico que la representa variable1.


En la declaración de los métodos, vemos que en el primer método llamado Metodo1 se antepone la palabra reservada void la cual hace referencia que este método no devuelve un ningún valor. Luego del nombre aparece encerrado entre paréntesis la palabra reservada void que representa que el método no recibe ningún valor como parámetro.

El Metodo2, al igual que el anterior, no devuelve ningún valor, mientras que este recibe un parámetro un variable llamada variable2 del tipo de dato tipo.

Para el Metodo3, este método devuelve un valor del tipo de dato tipo, mientras no recibe ningún parámetro.

Para la implementación de los métodos, se debe anteponer al nombre del método el nombre de la clase con doble dos puntos (::) entre ellos, luego se encierra entre llaves ({ ...}) el código que se va a ejecutar cuando sea llamado este método. Podemos observar la implementación del Metodo1: void NombreDeLaClase::Metodo1(void) { // código }

Por último, la Propiedad1 tiene la misma funcionalidad que los métodos que son capaces de escribir o leer valores en o desde los atributos de la clase, con la ventaja que no se tiene que implementar. Para definir qué variable va a leer o escribir, se debe escribir entre llaves las palabras reservadas read o write seguido del igual y el nombre del atributo sobre el que va a actuar.

A continuación, vamos a diseñar una clase que modele un rectángulo a la cual llamaremos TRectangulo, la cual debe poder calcular su superficie a partir de los lados.

Primero debemos pensar que elementos caracterizan un rectángulo, con lo cual encontramos el ancho, el alto y la superficie. Luego, necesitamos métodos que nos permitan manipular estos datos, para ello tenemos debemos incorporar los datos mediante los métodos IngresarAncho e IngresarAlto, un método que calcule la superficie llamado CalcularSup y por último uno que devuelva o informe el valor de la superficie llamado InformarSup.

La declaración de la cabecera clase se escribe como sigue:

class TRegtangulo { private: float Ancho, Alto; float Superficie;

Observación: el modelado de una clase puede variar de un programador a otro, por lo que no existe una única solución posible, ni una sola solución correcta.


public: void IngresarAncho(float Anchoi); void IngresarAlto (float Altoi); void CalcularSup(void); float InformarSup(void); };

La implementación de los métodos es:

void TRegtangulo::IngresarAncho(float Anchoi); { Ancho = Anchoi; } void TRegtangulo::IngresarAlto (float Altoi); { Alto = Altoi; } void TRegtangulo::CalcularSup(void) { Superficie = Ancho * Alto; } float TRegtangulo::InformarSup(void) { return Superficie; }

Para el método CalcularSup se observa que se realiza la asignación de las variables recibidas como parámetro a los atributos de la clase.

En el método CalcularSup realizamos el cálculo de la superficie que la almacenamos en el atributo Superficie.

Por último en el método InformarSup, devolvemos o retornamos el valor de superficie que hemos calculado, mediante la palabra reservada return.

Observación: toda expresión debe terminar con un punto y coma (;).


Diagrama de clase. Un modelo sencillo, que nos ayuda a esquematizar una clase para acelerar su diseño,

es el diagrama de clase. A su vez, nos permite interpretar rápidamente el diseño de una clase con una rápida lectura, con la particularidad de ser independiente del lenguaje con que se implemente la clase.

Como observamos, el diagrama de clase se representa mediante un rectángulo, dividido en tres secciones: NombreDeLaClase, Atributos y Métodos.

Para el ejemplo anterior, el diseño se observa en el diagrama de la derecha.

Constructor. El método constructor es un método especial de la clase que permite inicializar

atributos u otras variables necesarias de la clase. Este método es invocado automáticamente cuando se crea un objeto de esta clase. Posee algunas características importantes como:

• No retorna ningún valor (ni siquiera void).

• Puede recibir parámetros de cualquier tipo con excepción de la misma clase (si un puntero).

• Para su declaración se utiliza el mismo nombre que la clase. Para continuar con el ejemplo anterior, supongamos que deseamos inicializar los

valores del ancho y alto del rectángulo con los valores 10 y 20 respectivamente, y que realice el cálculo de la superficie para estos valores.

La declaración del constructor se realiza en la parte pública, como se observa: class TRegtangulo {


private: float Ancho, Alto; float Superficie; public: TRectangulo(void); void IngresarAncho(float Anchoi); void IngresarAlto (float Altoi); void CalcularSup(void); float InformarSup(void); };

La implementación del constructor, para realizar lo pedido es: TRectangulo::TRectangulo(void) { Ancho = 10; Alto = 20; // las dos expresiones anteriores // también se podrían escribir como // IngresarDatos(10, 20); CalcularSup(void); }

Destructor. También se trata de un método especial de una clase, pero que es invocado cuando

se destruye un objeto de esta clase. En él se debe liberar toda memoria o recurso especial que se halla pedido la clase. Posee algunas características importantes como:

• No retorna ningún valor (ni siquiera void).

• No recibe parámetros.

• Para su declaración se utiliza el símbolo ~ seguido por el mismo nombre que la clase. La declaración del constructor se realiza en la parte pública, como se observa:

class TRegtangulo { private: float Ancho, Alto; float Superficie; public: TRectangulo(void);


~TRectangulo(void); void IngresarAncho(float Anchoi); void IngresarAlto (float Altoi); void CalcularSup(void); float InformarSup(void); };

La implementación del constructor, para realizar lo pedido sería: ~TRectangulo::TRectangulo(void) { // no es necesario realizar nada para nuestro ejemplo }

Resumen de conceptos importantes: Clase: es una abstracción, que modela las características y el comportamiento de un

conjunto de elementos del mundo real. Incluye informaciones relevantes sobre el estado de esa entidad, y las diversas reacciones que la misma puede desarrollar frente a estímulos.

Atributo: es una propiedad, cualidad o característica que define el estado de una clase. Usualmente, las clases poseen varios atributos, cuyos valores pueden cambiar con el tiempo.

Funcionalidad o servicio de una clase: determina cómo la misma actuará o reaccionará bajo diversas solicitaciones.

Encapsulamiento: es el agrupamiento de atributos y servicios dentro de una clase. Instancia u objeto: es una ocurrencia particular de una clase, es decir, es una

instancia específica de una clase.

Evento: es un cambio en el entorno de una aplicación, las cuales pueden ser capturadas por una aplicación. Algunos eventos pueden ser: mover el mouse, presionar una tecla, hacer click o con doble click con el mouse, etc.

Cuándo y porque modelamos una clase. Un error común, después de haber terminado de estudiar la POO, es creer que toda

implementación o cálculo debe ir dentro de una clase. En vez de ello se pueden declarar simplemente funciones que realicen acciones específicas.

En C++Builder, existen funciones definidas que no pertenecen a ninguna clase (como IntToStr, FormatFloat, etc.) y existen funciones definidas dentro de clases, a las cuales llamamos métodos.

Entonces, cómo distinguimos cuando debemos modelar una clase? No es una pregunta que se pueda contestar fácilmente. Por ejemplo, si queremos saber la hora actual


del sistema no es necesario crear una objeto para que lo realice, sino simplemente implementar una función que llame al sistema preguntando la hora, como lo realiza la función Now(). Esta clase de acciones son directas y de vida corta. Recordemos que la creación de un objeto siempre es más lento y consume mayor cantidad de recursos que la simple llamada de una función.

Entonces…, para que construimos clases? Una clase es en esencia una estructura compleja cuya vida es dinámica, en la cual sus atributos van cambiando con el tiempo, pero siempre realizando una acción específica. Por ejemplo, podríamos tener una clase que se encargue de manejar el puerto serie. Entonces esta clase deberá saber como abrir el puerto, configurarlo, leer y escribir datos en él, generar un mensaje cuando halla leído un nuevo dato, etc. Vemos que las obligaciones de esta clase son complejas, pero con una acción específica.

Encapsulamiento Como definimos antes, el encapsulamiento es el agrupamiento de atributos y

servicios dentro de una clase. Esto significa, que podemos comunicarnos con una clase a través de sus interfaces bien definidas, pero no conocer como se encuentran implementadas.

Aunque podríamos conocer los detalles de su implementación de una clase, no debe escribirse código que dependa de ello, esto significa que la implementación de una clase en particular puede ser modificada o reemplazada sin afectar al resto del sistema, siempre y cuando no cambie la interfaz public y published;

Herencia. Una de las relaciones más importantes entre clases es la herencia. Es uno de los

pilares fundamentales de la POO, mediante la cual se produce la transmisión de atributos y funcionalidades de una clase a otra, lo cual trae aparejado grandes ventajas como la de reutilización de código en la que se crean nuevas clases a partir de clases ya existentes por medio de la absorción de sus atributos y comportamientos, sobreponiéndolos o mejorándolos con las capacidades que las nuevas clases requieran.

La herencia, nos permite definir una clase modificando una o más clases ya existentes. Estas modificaciones pueden consistir en añadir nuevos atributos y funcionalidades a la clase que se está definiendo, aunque también se pueden redefinir funcionalidades ya existentes.

A partir de lo anterior, se deduce que existe una clase primitiva (ya existente) de la que partimos, a la cual llamaremos clase base o clase padre, y una nueva clase que definiremos, a la cual llamaremos clase derivada o clase hija.

Esta clase hija, puede ser, a su vez, la clase padre de una o más nuevas clases derivadas. Creándose de esta manera, una jerarquía de clases.


Para especificar el uso de la herencia, después del nombre de la clase hija, se agrega el operados dos puntos (:), seguido por un especificador de acceso y luego el nombre de la clase padre, como se observa: class NombreClaseHija: public NombreClasePadre { private: // … public: // … };

El especificador de acceso (en este caso public), describe la forma de acceso a los miembros heredados de la o las clases padres. Puede ser:

• Public: todos los miembros public de la clase base son miembros public de la clase derivada. Miembros protected de la clase base son miembros protected de la clase derivada. Miembros private de la clase base permanecen privados a la clase base.

• Protected: tanto los miembros public y protected de la clase base son miembros protected de la clase derivada. Miembros private de la clase base permanecen privados a la clase base.

• Private: tanto los miembros public y protected de la clase base son miembros private de la clase derivada. Miembros private de la clase base permanecen privados a la clase base.

Resumiendo en una tabla:

Identificador Miembros clase madre Miembros clase hija

private protected public

private

protected protected public

protected

public protected public

protected public

Nota: si no se especifica, por defecto el especificador de acceso es private.

Nota: Cabe destacar que la clase base no debe ser modificada y esta debe modelar el objeto del problema para el cual fue diseñada.


Los miembros private de la clase base son siempre inaccesibles para los métodos de la clase derivada a menos que se declare explícitamente que es un miembro friend en la clase base. No se tratará sobre miembros friend en este texto.

Vamos a diseñar una clase que modele el volumen de un prisma a la cual llamaremos TPrisma. Para esta modelización recurriremos a la herencia que nos permitirá reutilizar código fuete ya existente.

Si analizamos tridimensionalmente un prisma, podríamos pensarlo como una caja, la cual consta de una base rectangular y posee una altura asociada, con la cual genera su volumen. Matemáticamente podríamos calcular su volumen (V) como el producto de la superficie de la base (S) por su altura (h).

V = S * h

Partimos así de tomar la clase antes diseñada TRectangulo, la cual utilizaremos como clase base. A continuación diseñaremos la clase hija.

Diseñando el diagrama de clase:


class TPrisma : public TRectangulo{ private: float Altura; float Volumen; public: void IngresarAltura(float Alturai); void CalcularVolumen(void); float InformarVolumen(void); };

La implementación de los métodos es: void TPrisma::IngresarAltura(float Alturai); { Altura = Alturai; } void TPrisma::CalcularVolumen(void); { CalcularSup();

// Aquí llamamos al método que calcula // la superficie de la base // perteneciente a la clase padre

Volumen = InformarSup() * Altura; } float TPrisma::InformarVolumen(void); { return Volumen; }

Es muy importante tener en cuenta que en la relación de herencia publica, la clase hija hereda automáticamente todo el contenido declarado en la parte publica en la clase madre y por ende puede utilizarla como si fuesen propios, pero a la parte privada sólo se puede acceder a través de sus métodos.

Veremos a continuación, un segmento de código que ejemplifica la implementación del evento click de un botón del formulario, en el cual declaramos la instancia u objeto particular de la clase TPrisma.


void __fastcall TForm1::BotonClick(TObject *Sender) { TPrisma Prisma; Prisma.IngresarAncho = StrToFloat(Edit1->Text); Prisma.IngresarAlto = StrToFloat(Edit1->Text); Prisma.IngresarAltura = StrToFloat(Edit1->Text); Prisma.CalcularVolumen(); Label1->Caption = FloatToStr(Prisma.InformarVolumen()); }

Clases contenedoras. El uso de clases contenedoras se centra en la idea que los objetos pueden estar

formados (o contienen) a otros objetos, llamados objetos miembro. Los objetos miembro se convierten en atributos de nuestra nueva clase. Esta capacidad de contener a otros objetos también es llamada composición.

Llevando este concepto a la vida real, podemos pensar a los objetos como formados por piezas de distinta naturaleza que contribuyen a un mismo fin. Este es el caso del objeto auto, el cual esta compuesto por otros objetos que son parte integra de él, como son el objeto motor, rueda, volante, etc.

Imaginemos ahora, un péndulo de un reloj bidimensional, como la conjunción de un rectángulo (brazo del péndulo) y un círculo (peso del péndulo), al cual queremos calcular el área.

La clase contenedora TPendulo, contendrá a las clases miembro TRectangulo y TCirculo. Para continuar con el concepto de reutilización de código, utilizaremos a la clase TRectangulo antes definida y sólo diseñaremos a la clase TCirculo y modelaremos la clase TPendulo.

Modelo bidimensional del péndulo de un reloj

class TCirculo { private: float Radio; float Superficie;

Nota: en la instanciación, sólo hacemos referencia a la clase hija, no se instancia la clase madre.


public: void IngresarRadio(float Radioi); void CalcularSup(void); float InformarSup(void); };

La implementación de los métodos es: void TCirculo::IngresarRadio(float Radioi); { Radio = Radioi; } void TCirculo::CalcularSup(void) { Superficie = M_PI * pow(Radio,2); } float TCirculo::InformarSup(void) { return Superficie; }

Ahora implementamos la clase TPendulo: class TPendulo { private: TRectangulo Rect; TCirculo Circ; float Superficie; public: void IngresarRadioPeso(float Radioi); void IngresarLargoBrazo(float Largoi); void IngresarAnchoBrazo(float Anchoi); void CalcularSup(void); float InformarSup(void); };

La implementación de los métodos es:


void TPendulo::IngresarRadioPeso(float Radioi) { Circ.IngresarRadio(Radioi); } void TPendulo::IngresarLargoBrazo(float Largoi) { Rect.IngresarLargo(Largoi); } void TPendulo::IngresarAnchoBrazo(float Anchoi) { Rect.IngresarAncho(Anchoi); } void TPendulo::CalcularSup(void) { Rect.CalcularSup(); Circ.CalcularSup(); Superficie = Rect.InformarSup() + Circ.InformarSup(); } float TPendulo::InformarSup(void) { return Superficie; }

En este ejemplo de contención se instanció las clases miembro en la parte privada de la clase (también se puede realizar en la parte publica, pero varia su implementación). Se implementaron métodos para ingresar los atributos, los cuales no se almacenaron en variables pertenecientes a esta clase, sino, se asignaron directamente a la clase contenida correspondiente.

En el método CalcularSup(), se llamó a los métodos CalcularSup() de cada una de las clases contenidas para que realicen el cálculo de su superficie y dispongan su valor, para realizar la suma de ambas superficies.Registros (struct).

Avanzado: Los objetos miembro se construyen en el orden en el que se declaran.


Los registros son los predecesores de las clases. Permiten definir tipos de datos agregados que se construyen empleando elementos de otros tipos, es decir, una estructura es un conjunto de diferentes datos agrupados bajo una única declaración. Un ejemplo de esta definición: struct Tiempo { int hora; int minutos; int segundos; };

En este ejemplo vemos que la palabra reservada struct define la estructura, que permitirá crear instancias de ella. La palabra Tiempo es el nombre del tipo de estructura.

Ahora podemos declarar instancias de esta estructura, de la forma: Tiempo Inicio;

Y podemos asignar valores a sus elementos usando el nombre de la instancia seguido por ‘.’ (punto), luego el nombre del elemento, igual como vimos su uso en clases, dado que las clases son una evolución de las estructuras. Inicio.hora = 10; Inicio.minutos = 35; Inicio.segundos = 21;

Diferencia entre Registros y Clases. Existe diferencia entre el uso de estructuras en C y C++, dado que en C, struct es un

registro, es decir una estructura que permite almacenar datos de todo tipo y que permite crear distintas estructuras que almacenaran distintos datos.

Ejemplo: siguiendo con la declaración anterior del struct Tiempo, creamos dos struct diferentes, es decir dos estructuras de datos distintas y le asignamos valores distintos: Tiempo TInicial; Tiempo TFinal; TInicial.hora = 10; TInicial.minutos = 35; TInicial.segundos = 21; TFinal.hora = 15; TFinal.minutos = 10; TFinal.segundos = 59;


En el caso de C++, los struct siguen existiendo, pero en ves de ser estructuras de

datos o registros, fueron implementadas como clases, las cuales permiten ser instanciadas para crear objetos distintos partiendo de la declaración inicial. El ejemplo es el mismo que para el struct de C, sólo con una diferencia de concepto, es decir en C es un registro de datos y en C++ es una clase en donde todos sus elementos son de uso público (public).


Capítulo 3: Lógica de control En la programación, son necesarias herramientas que nos permitan hacer elecciones

o tomar decisiones durante el proceso de ejecución de nuestro programa, permitiendo seleccionar un camino entre una, dos o mas posibilidades diferentes.

Para este uso, es que se hace uso de estructuras condicionales, que de acuerdo a una expresión lógica permitirá tomar una decisión.

Expresión lógica. Una expresión lógica es una combinación de constantes, variables y funciones

lógicas, con operadores lógicos y relacionales.

Para comenzar a entender su uso, podemos definir una variables lógicas como una variable que puede contener sólo dos valores posibles: verdadero (true o 1) o falso (false o 0). En C++ este tipo de variable se llama bool.

Los operadores lógicos son aquellos que nos permiten concatenar o modificar expresiones lógicas, resultando un valor lógico. Ellos son:

Operador Nombre Operación lógica ! not negación

&& and y lógico

|| or o lógico

Para entender mejor su uso, vamos a ver como trabajan a traves de un ejemplo. Supongamos que tenemos dos variables lógicas A y B.

A !A 0 1 1 0

A B A && B 0 0 0 0 1 0 1 0 0 1 1 1

A B A || B


0 0 0 0 1 1 1 0 1 1 1 1

Los operadores relacionar relacionales son aquellos que nos permiten comparar dos valores, resultando un valor lógico. Ellos son:

Operador Nombre Operación lógica

> mayor mayor que < menor menor que

<= menor o igual menor o igual que >= mayor o igual mayor o igual que

!= distinto distinta que

== igual igual que

Vamos a ver como trabajan a través de un ejemplo. Supongamos que tenemos tres variables A=5, B=5 y C=7.

Expresión Resultado A>B 0 A>=B 1 A<=C 1 A!=B 0 A!=C 1 A==B 1 A==C 0

Estructura condicional “if” Es una estructura simple que permite ejecutar una instrucción o un bloque de

instrucciones sólo si se cumple una expresión lógica, es decir, se ejecuta sólo si el resultado de la expresión lógica es verdadero. if (expresión_lógica) {acción;};

Observación: No hay que confundir el operador ==, con el operador =, dado que el primero significa comparación, mientras el segundo asignación.


Si la expresión lógica es verdadera (o 1) la acción se ejecuta, si es falsa se ignora la

acción y se continua con la instrucción siguiente a la estructura condicional. Si se quiere ejecutar una sola acción el uso de las llaves es opcional.

Esta estructura también permite ejecutar una acción si no se cumple (else) la expresión lógica. Su estructura sería: if (expresión_lógica) {acción_1;} else {acción_2;};

En este caso, si la expresión lógica es verdadera (o 1) la se ejecuta la acción_1, si es falsa se ejecuta la acción_2.

Ejemplificando: if (A > B) C = A - B; else C = A + B;

En este ejemplo, de acuerdo al valor de A y B realizamos acciones diferentes. Muchas veces queremos comprobar el valor que posee una variable lógica,

supongamos A, con la cual queremos realizar una acción sólo si su valor es verdadero. En este caso se puede utilizar directamente esta variable como una expresión lógica y no es necesario realizar la comparación con true, por ejemplo: if (A == true) C = A - B;

if (A) C = A - B;

La expresión se evalúa como true, siempre y cuando la variable contenga cualquier valor distinto de cero. Esto se conoce como “fundido de tipos” (type casting), y es realizado automáticamente por C++, reconociendo como falso al valor 0 y como verdadero a distinto de 0.

Obsérvese en los ejemplos anteriores que el operador de igualdad tiene un doble signo de igual (==), en tanto que el operador de asignación sólo tiene uno (=). Uno de los errores comunes es el empleo del operador de asignación cuando se quiere utilizar el de igualdad. Por ejemplo, si escribimos: if (x = 20) {acción};

En este caso se asigna a x el valor 20 y, como la operación tendrá éxito, la expresión será evaluada como true. Un error como este, aunque aparentemente obvio, puede ser difícil de localizar.


Las instrucciones if se pueden anidar en caso de ser necesario. Anidar no es más que emplear una instrucción if como acción de seguida de una o más instrucciones if adicionales: if (x > 10) if (x < 20) {acción};

Estructura condicional “switch” La instrucción switch se podría considerar como una extensión de la instrucción

if. Permitiendo ejecutar múltiples acciones evaluando una sola variable de control a la cual llamaremos selector, que de acuerdo a su valor en el instante que se evalúa corresponderá la acción a ejecutar. Su sintaxis es: switch (selector) { case valor_1: {accion_1; break;} case valor_2: {accion_2; break;} ... case valor_n: {accion_n; break;} default: {accion_por_defecto;} }

El selector debe ser una variable ordinal, es decir, una variable que posea una secuencia definida (ordenada) y acotada (finitas posibilidades), como puede ser una variable del tipo int, bool, cualquier tipo definido por el usuario, o el resultado de una expresión; siempre y cuando cumplan con la condición.

Cada uno de los valores de los casos para los cuales hemos definido una acción, deben corresponder a un valor que pertenece al tipo de dato del selector.

Esta estructura también permite la definición de una acción que se ejecutará por defecto si ninguno de los casos anteriores se cumple. Pero su definición es opcional.

En el caso de que un caso se cumpla, se ejecuta la acción definida para este caso hasta que se encuentra con la instrucción break, que es una instrucción que permite salir del bloque de código que se esta ejecutando, en este caso del bloque switch. Si no lo encuentra, se seguirán ejecutando las acciones de los casos siguientes hasta terminar todos los casos o hasta encontrarse con un break.

Debe notarse que la instrucción switch sólo funciona cuado existe una igualdad entre el selector y alguno de los case, por lo que no será de utilidad en el caso de situación


que impliquen desigualdad (> o <), tampoco para datos de tipo flotante dato que no poseen un secuencia bien definida.

Vamos a ver dos ejemplos de su uso. En el primero queremos analizar la paridad de un número ingresado por el usuario, almacenando en una variable lógica (bool) llamada par:

switch (num%2) { case 0: {par = true; break;} case 1: {par = false; break;} };

Se analizan solamente los casos 0 y 1 dado a que el resto de la división por 2 sólo puede tomar estos valores.

El mismo ejemplo se podría haber resuelto de tres formas más sencillas, que dejamos acá para analizar:

if (num%2 == 0) par = true; else par = false;

if (!num%2) par = true; else par = false;

par = !bool(num%2)

Para el segundo ejemplo queremos determinar si un caracter es un vocal o no, y si es una vocal determinar cual. Vamos a analizar una variable caracter del tipo de dato llamado char que corresponde a un caracter, y devolveremos el resultado en una cadena de caracteres del tipo de datos AnsiString llamada Resultado: switch (caracter) { case ‘a’: {Resultado = “es la vocal a”; break;} case ‘e’: {Resultado = “es la vocal e”; break;}

case ‘i’: {Resultado = “es la vocal i”; break;} case ‘o’: {Resultado = “es la vocal o”; break;} case ‘u’: {Resultado = “es la vocal u”; break;} default: {Resultado = “no es vocal”;} }


Capítulo 4: Estructuras Repetitivas Normalmente dentro de un programa, es necesario realizar acciones de forma

repetida, por ejemplo, imaginemos que queremos ejecutar 100 veces una acción, podríamos escribir 100 veces la misma línea o bien indicar que ejecute 100 veces la misma línea.

Para ello, se creó en el lenguaje de programación, las estructuras for, while, y do while, que son las que nos permitirán codificar ciclos o bucles según sea necesario.

Primero, debemos saber que todo ciclo, tiene una condición inicial, que inicia el ciclo, una condición final, que, cuando se cumple, el bucle finaliza, y un cuerpo o bloque de código que el ciclo realizará.

El cuerpo contiene la instrucción que se ejecuta cada vez por medio del ciclo y puede incluir cualquier código válido en C++.

Revisemos cada ciclo por separado:

Ciclo for.

La estructura for (“para”), se utiliza para realizar, generalmente, una acción cierta cantidad determinada y definida de veces. Para ello, consta de tres parámetros que debemos definir:

• Inicialización,

• Condición de salida

• Incremento En la inicialización, se procede a declarar una variable auxiliar, llamada variable de

control, cuyo ámbito de existencia y trabajo es dentro del ciclo, dándole un valor inicial, por ejemplo el valor uno.

Para establecer la condición de salida, se debe saber cuántas veces el ciclo debe ser repetido, y se procede a darle a la variable de control un valor final, siendo preferente determinarle el rango de trabajo, es decir, si deseo que la variable de control llegue al valor final diez, la sentencia de finalización sería i == 10 (en este caso el ciclo se ejecutará si la condición es false), pero es preferente determinarle el rango de 1 a 10 haciendo i < = 10, mientras esta condición se mantenga en true, el ciclo realizará la acción que el cuerpo determine, al momento de no cumplirse la condición de salida, el programa sigue ejecutando la sentencia que sigue inmediatamente al cuerpo del ciclo.

En síntesis, si como condición de salida especifico un rango de la variable de control, el ciclo se ejecutará mientras esta condición se mantenga en true, en cambio si especifico un valor preciso para la variable de control, el ciclo se ejecutará mientras ésta se mantenga en false.


También, debo determinar la manera de incrementar la variable de control, es decir, especificar si i varía de uno en uno, dos en dos, u otra forma de incrementar.

Estamos entonces en condiciones de presentar la estructura codificada de este ciclo. for (inicialización; condición de salida; incremento) {acción;};

Ejemplo: a continuación, implementaremos una función, en la que se reproducirá la

función pow incluida en la librería math. int Potencia(int base, int exponente) { int resultado = 1; for (int i=1; i<=abs(exponente); i++) resultado = resultado * base; if(exponente < 0) resultado = 1/resultado; return resultado; }

En este caso, es ciclo se ejecuta exponente cantidad de veces en forma repetitiva, evaluándose siempre primero la condición de salida, y en cada paso del ciclo, las variables puestas en juego toman los siguientes valores:

Condición Finalización

i Resultado

Antes de entrar al for

----- No existe 1

Primer paso true 1 Base Segundo paso true 2 Base^2 Tercer paso true 3 Base^3 true ... exponente paso true exponente Base^exponente Saliendo del for false No existe Base^exponente Condición if No existe Depende del signo

del exponente

Nota: La utilización de la variable i tiene su origen en el lenguaje FORTRAN y es tradicional en los ciclos for. Naturalmente, podemos usar cualquier nombre de variable, para la variable de control.


Si fuera necesario contar o realizar el ciclo en forma descendente, se puede utilizar el conteo hacia abajo, como por ejemplo: int Potencia(int base, int exponente) { int resultado = 1; for (int i=abs(exponente); i>=1; i--) resultado = resultado * base; if(exponente < 0) resultado = 1/resultado; return resultado; }

Es bueno recordar que el ciclo for acepta sólo una sentencia, de manera tal que si se requiere realizar más de una acción, debemos encerrar todo el bloque de código del ciclo entre llaves (sentencia compuesta), por ejemplo: for (int i=10; i>=0; i--) { acción_1; acción_2; . . acción_n; }

Ciclo while El ciclo while ("mientras") difiere del ciclo for en que sólo contiene una condición

de prueba, que se verifica al principio de cada iteración. Mientras la condición sea true el ciclo continúa funcionando. La sintáxis correspondiente es: while (expresión_lógica) {acción_1; acción_2; . . acción_n;};

En la misma, la acción se realiza mientras la expresión lógica sea verdadera (valor distinto de cero). Es de vital importancia que la acción tenga alguna forma de modificar el valor de la expresión lógica, para que, en algún momento, sea falsa y el ciclo finalice. Si de entrada la expresión lógica da falsa, la acción del ciclo nunca se realiza.

Veamos un ejemplo de la utilización de esta estructura, supongamos que obtener la potencia a la cual hay que elevar el número 2 para obtener el valor 1024.


Hacemos: int x = 1024; int n; while (x >= 2){ n++; //n lo utilizo de contador x = x / 2; }

Ahora, n guarda el valor de la potencia de 2 para obtener el valor 1024. Notamos nuevamente que el valor de la variable de control x, cambia dentro del propio ciclo, evitando que el ciclo se haga infinitamente.

Ciclo do-while.

Este ciclo es prácticamente igual al while. Sin embargo, la diferencia entre los dos es importante, ya que el ciclo while evalúa la expresión condicional al principio del ciclo; en el caso de do-while ("hacer – mientras"), la expresión se evalúa al final del propio ciclo. La sintaxis de este bucle es:

do {acción;} while (exprlógica);

Debido a la manera como funciona el ciclo do-while, el código en el cuerpo del ciclo se ejecuta al menos una vez, sin importar el valor de la condición de prueba (ya que se evalúa al final del ciclo). En el caso del while, la condición se evalúa al principio, por lo que es posible que nunca se ejecute el cuerpo del ciclo.

También en este caso, la modificación de la expresión lógica debe ser explícita en el bloque de código, para que el ciclo finalice en algún momento, cuando la expresión condicional resulte falsa.

Un ejemplo sería: int x = 1024; int n; do {x = x / 2; n++;} while (x > 1);


Donde n, guarda nuevamente la potencia a la que hay que elevar el valor 2 para

obtener el número 1024.

Es un error común, que se trate de realizar una acción en el do que no se pueda realizar, es decir, hay que tener en cuenta que como el ciclo siempre se ejecuta al menos una vez, no debemos por ejemplo implementar en el cuerpo del do, una acción imposible tal como el la división por cero, por ejemplo.

Para ver más gráficamente el error, analizaremos un código erróneo para ejemplificar. float x = 0; float y; do {y = 512 / x; //error al tratar de dividir por cero!!! x = x + 2.0;} //acumulo en x el valor anterior de x más 2 //x en este caso es un acumulador while (y != 1);

Instrucciones break y continue Antes de terminar el tema de los ciclos, haremos referencia a dos palabras clave que

ayudan a controlar la ejecución del ciclo en el programa.

La instrucción continue se emplea para forzar la ejecución del programa hasta el final del ciclo, saltando cualquier expresión situada después de continue.

La instrucción break se usa para detener la ejecución de un ciclo antes de que se cumpla la condición de prueba normal del ciclo. Existen muchas situaciones cuando las instrucciones continue y break son útiles. Al igual que gran parte de los temas desarrollados, requerirá cierta experiencia de programación en C++ para descubrir todos los posibles usos de estas dos instrucciones.

De todas maneras, a continuación veremos la utilización de la palabra clave break en un ciclo for, el cual utilizaremos de modo particular, y el condicional if.

Para ello, es necesario saber que el puerto paralelo, posee tres partes: data, control y status, y, supongamos que en nuestro programa, necesitamos leer un pin (bit) del control de nuestro puerto paralelo, que nos dará la confirmación de que podemos leer los 8 bits de data. Utilizaremos dos funciones genéricas (estas funciones no están implementadas, son sólo a modo de ejemplo) una para leer un bit del control a la que llamaremos LeerBitControl (suponemos que esta función devuelve true si se puede leer el puerto data), y una que nos permitirá leer el data, que llamaremos LeerDato(suponemos que esta función devuelve el valor entero del dato leído).


for(;;){ if(LeerBitControl())break; } int x = LeerDato();

En este caso, el for se utiliza a modo de delay o retardo hasta que llegue la confirmación de lectura del puerto.

En el caso que consideremos usar un bit de status para que haga comenzar o detenga la adquisición del dato, según sea true o false.

int x=0; for(;;){ if(LeerBitStatus())break; for(;;){ if(LeerBitControl())break; } x += LeerDato(); }

Para ejemplificar el uso de la instrucción continue, podemos considerar el caso anterior, haciendo la salvedad de que el siguiente ejemplo es un ciclo infinito, y es sólo a modo de ejemplo.

int x=0; while(!detener){ if(LeerBitStatus())continue; for(;;){ if(!LeerBitControl())break; } x += LeerDato(); }

Avanzado: verificar que si al for le falta alguno o varios de sus parámetros, también funciona, si utilizamos la sentencia break.


Capítulo 5: Vectores y Matrices Se hace evidente que a lo largo de un programa, necesitamos guardar información, o

bien, trabajar con información que debemos almacenar en distintas estructuras. De esta necesidad, surgen un tipo de estructura de datos llamados genéricamente como arreglo (array). De esta manera, surgen los vectores que son arreglos unidimensionales y las matrices que son arreglos multidimensionales.

Declaración Para declarar vectores y matrices, la sintaxis es la siguiente, primero se define el

tipo de dato que almacenará este arreglo, luego el nombre que le asignaremos a dicho arreglo y entre corchetes la cantidad de elementos de cada dimensión, si el arreglo es un vector, la sintaxis es: int NombreDelVector[5];

En cambio si el arreglo es bidimensional, o matriz de dos dimensiones, la sintaxis es: int NombreDeLaMatriz[45][20];

El número entre corchetes indica la cantidad de valores del tipo que se indican, NO es el subíndice del mayor elemento. Además todos los subíndices comienzan en cero, es decir el primer valor del vector es en la posición cero, y el último es en n-1 (en el caso anterior, n-1=5-1=4).

Observemos de manera esquemática como sería la asignación de memoria por parte del compilador:

Vector[0] Vector[1] Vector[2] Vector[3] Vector[4] Valor int A Valor int B Valor int C Valor int D Valor int E

Teniendo en cuenta que cada int requiere 4 bytes de almacenamiento, el arreglo

completo ocupará 20 bytes en la memoria. De manera análoga, para la matriz bidimensional, asignamos memoria para M*N números enteros (en total 4*45*20 = 3600 bytes).

Para referirse a cada elemento de un vector unidimensional se utiliza un índice, recordando que el primer elemento tiene índice [0]. Para las matrices o arreglos n-dimensionales se requieren tantos subíndices como dimensiones tenga el espacio en el que estemos trabajando.


Hay que prestar atención especial a no sobreescribir el final de un arreglo. Una

característica poderosa de C++ es el acceso directo a memoria; debido a ella, C++ no nos impide escribir a una ubicación determinada de la memoria, aunque sea una posición a la que se supone que no debe tener acceso el programa que estamos elaborando. El siguiente código es válido, pero producirá la detención del programa: int vector[5]; vector[5]=31;

Este es un error que se comete frecuentemente, dado que los arreglos tienen base 0. Podríamos pensar que el último elemento del arreglo es 5, cuando en realidad es 4.

Es posible solicitar que, automáticamente, se verifique que los índices se encuentren dentro del rango de la definición del arreglo, activando la directiva de compilación $R, accediendo a Project options/Pascal/Range checking.

Hay una diferencia notable entre el índice de un elemento de un vector (que es siempre de tipo entero), y el valor contenido en la posición del vector marcada por el índice, que puede ser de cualquier tipo (entero, flotante, booleano, etc.).

Ejemplo.

Ejemplo 1. Se desea crear un objeto que contenga una matriz cuadrada de 23 elementos lógicos,

llenada al azar. La matriz debe poder ser visualizada en pantalla y también se debe poder intercambiar los 1 lógicos por la letra “T” y los 0 lógicos por la letra “F”.

Veremos el código del archivo uMatriz.h. class TDeterminar { private: bool m[23][23]; public: void Generar(void); bool Informar(int i, int j); };

//uMatriz.cpp


void TDeterminar::Generar(void) { int i, j; randomize(); for(i=0; i<24;i++) for(j=0; j<24;j++) m[i][j]=random(2); } bool TDeterminar::Informar(int i, int j) { return m[i][j]; }

Ahora veremos los archivos asociados al formulario. // fMatriz.h class TDeterminacion : public TForm { __published: // IDE-managed Components TStringGrid *Grilla; TBitBtn *BitBtn1; TBitBtn *BitBtn2; TBitBtn *BitBtn3; void __fastcall BitBtn1Click(TObject *Sender); void __fastcall BitBtn2Click(TObject *Sender); void __fastcall BitBtn3Click(TObject *Sender); void __fastcall FormDestroy(TObject *Sender); private: // User declarations public: // User declarations TDeterminar D; //Aquí instanciamos la clase __fastcall TDeterminacion(TComponent* Owner); }; // fMatriz.cpp


__fastcall TDeterminacion::TDeterminacion(TComponent* Owner) : TForm(Owner) { Grilla->Visible=false; } //-----------------------------------------------------------void __fastcall TDeterminacion::BitBtn1Click(TObject *Sender) { D.Generar(); Grilla->Visible=True; int i,j; for(i=0;i<24;i++) for(j=0;j<24;j++) Grilla->Cells[i][j]=IntToStr(D.Informar(j,i)); } //-----------------------------------------------------------void __fastcall TDeterminacion::BitBtn2Click(TObject *Sender) { int i,j; for(i=0;i<24;i++) for(j=0;j<24;j++) if(D.Informar(i,j)) Grilla->Cells[j][i]='T'; else Grilla->Cells[j][i]='F'; } //----------------------------------------------------------- void __fastcall TDeterminacion::BitBtn3Click(TObject *Sender) { Close(); }


//----------------------------------------------------------- El uso de randomize() y random() están explicado en el apéndice.

Ejemplo 2. Implemente una clase que contenga un vector de 3700 elementos reales.

Implemente métodos para ingresar los valores del vector y para poder mostrar un elemento particular del vector. A su vez, implemente un método que permita llenar al azar el vector con valores entre 500 y 1000. Además la clase debe poder informar el valor máximo y mínimo del vector y sus posiciones.

Veamos el código.

//uVector.h //-----------------------------------------------------------#ifndef uVectorH #define uVectorH //----------------------------------------------------------- class TVector{ private: float v[3700]; float maximo; float minimo; int posi_maxi; int posi_mini; public: void llenar_vector(); void ingresar_valor(int i,float val); float ver_valor(int i); void search_max_min(); int largo_vector(); __property float ver_max={read=maximo}; __property float ver_min={read=minimo}; __property int pos_max={read=posi_maxi}; __property int pos_min={read=posi_mini};


}; //uVector.cpp //----------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include "uVector.h" #include <math.h> //----------------------------------------------------------- #pragma package(smart_init) void TVector::llenar_vector(){ randomize(); for (int i=0;i<sizeof(v)/sizeof(float);i++) v[i] = 500+500*random(RAND_MAX)*1.0/RAND_MAX; }; void TVector::ingresar_valor(int i,float val){ v[i]=val; }; void TVector::search_max_min(){ maximo=v[0]; minimo=v[0]; posi_maxi=0; posi_mini=0; for (int i=1;i<sizeof(v)/sizeof(float);i++){ if (v[i]>maximo) { maximo=v[i];


posi_maxi=i; } if (v[i]<minimo) { minimo=v[i]; posi_mini=i; } } }; float TVector::ver_valor(int i) { return v[i]; }; int TVector::largo_vector() { return sizeof(v)/sizeof(float); }; //fVector.h //-----------------------------------------------------------#ifndef fVectorH #define fVectorH //-----------------------------------------------------------#include <Classes.hpp> #include <Controls.hpp> #include <StdCtrls.hpp> #include <Forms.hpp> #include <Buttons.hpp> #include <ComCtrls.hpp>


#include <Grids.hpp> #include "uVector.h" //----------------------------------------------------------- class TForm1 : public TForm { __published: // IDE-managed Components TBitBtn *IngresarValor; TBitBtn *VerValor; TEdit *Valor; TLabel *Label1; TLabel *Label2; TEdit *Posicion; TUpDown *UpDown1; TLabel *VisorValor; TBitBtn *LlenarAzar; TStringGrid *Grilla; TBitBtn *BuscarMaxMin; TMemo *Visor; TBitBtn *Salir; void __fastcall SalirClick(TObject *Sender); void __fastcall LlenarAzarClick(TObject *Sender); void __fastcall IngresarValorClick(TObject *Sender); void __fastcall VerValorClick(TObject *Sender); void __fastcall BuscarMaxMinClick(TObject *Sender); void __fastcall FormCreate(TObject *Sender); private: // User declarations public: // User declarations TVector vec; __fastcall TForm1(TComponent* Owner); }; //-----------------------------------------------------------extern PACKAGE TForm1 *Form1;


//------------------------------------------------------ #endif //fVector.cpp //-----------------------------------------------------------#include <vcl.h> #pragma hdrstop #include "fVector.h" #include "uVector.h" //-----------------------------------------------------------#pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //-----------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner) { } //-----------------------------------------------------------void __fastcall TForm1::SalirClick(TObject *Sender) { Close(); } //-----------------------------------------------------------void __fastcall TForm1::LlenarAzarClick(TObject *Sender) { vec.llenar_vector(); for (int i=0;i<vec.largo_vector();i++) Grilla->Cells[1][i] =

FormatFloat("###0.00",vec.ver_valor(i)); } //-----------------------------------------------------------


void __fastcall TForm1::IngresarValorClick(TObject *Sender) { if(Valor->Text != "") { vec.ingresar_valor(StrToInt(Posicion->Text)-1,

StrToFloat(Valor->Text)); Grilla->Cells[1][StrToInt(Posicion->Text)-1]=Valor->Text; } else ShowMessage(AnsiString("Ingrese un Valor")); } //----------------------------------------------------------- void __fastcall TForm1::VerValorClick(TObject *Sender) { VisorValor->Caption=FormatFloat("###0.00", vec.ver_valor(StrToInt(Posicion->Text)-1)); } //----------------------------------------------------------- void __fastcall TForm1::BuscarMaxMinClick(TObject *Sender) { Visor->Clear(); vec.search_max_min(); Visor->Lines->Add("El valor mínimo es " +

FormatFloat("###0.00",vec.ver_min)); Visor->Lines->Add("en la posición " +

IntToStr(vec.pos_min+1)); Visor->Lines->Add("");


Visor->Lines->Add("El valor máximo es " +

FormatFloat("###0.00",vec.ver_max)); Visor->Lines->Add("en la posición " +

IntToStr(vec.pos_max+1)); } //----------------------------------------------------------- void __fastcall TForm1::FormCreate(TObject *Sender) { for(int i=0;i<vec.largo_vector();i++) Grilla->Cells[0][i]=i+1; } //-----------------------------------------------------------

Por último, veremos el formulario del programa ejecutándose.


Observación. Como vemos, hemos instanciado la clase en la parte pública de la clase Tform1, lo

cual nos permitirá poder hacer uso de esa instancia en cualquiera de los bloques de código del cpp, sin importar a qué botón o elemento visual pertenezca esa codificación. Es decir el ámbito de existencia esta instancia es todo el cpp, es una instancia global.


Capítulo 6: Cadenas de caracteres Una cadena de caracteres se puede definir como una secuencia o un vector de

caracteres, que están agrupados bajo un mismo nombre.

Existen varias formas de manipular las cadenas de caracteres, por que vamos a definir primeramente el tipo de datos char, lo cual nos va a permitir entender el resto de los tipos.

char Es un tipo de dato que permite definir un carácter de la tabla ASCII (Anexo I). Esta

tabla es una tabla de correspondencia entre un caracter y un número asociado al mismo entre 0 y 255.

En este ejemplo definimos un variable llamada Caracter a la cual le asignamos el mismo caracter “A” de dos maneras diferentes: char Caracter = ‘A’; char Caracter = 65;

c-string Es un arreglo de caracteres, es decir, es una cadena de caracteres que se define en

forma de un vector de caracteres. Esta definición es heredada del lenguaje “c” aunque su uso ha disminuido. Pero conserva algunas ventajas como son su simpleza y el menor recurso ocupado. Se definición tiene la forma: Char Nombre[longitud];

Donde Nombre es el nombre de la variable que definimos y longitud es la cantidad de caracteres que va a contener. En este ejemplo, vemos que se permite asignarle toda una cadena de forma directa. char Cadena[12] = “Computacion”;

También se puede realizar la asignación a cada caracter: Cadena[2] = ‘n’;

Nota: es importante diferenciar cuando se asigna un carácter a una variable se utiliza comillas simple (‘A’), mientras para las cadenas se utilizan comillas dobles (“Computación”)


Cadena[3] = ‘P’; // ahora cadena vale “ConPutación” Hay que recordar que al igual que los vectores el primer elemento es el 0 (cero).

c++ string Es una clase asociada a un arreglo de caracteres que posee métodos para su

manipulación. Para su utilización no es necesario especificar la longitud en la definición, dado que se puede modificar en forma dinámica con la asignación de una nueva cadena. string Cadena = “Bioingenieria”;

Esta clase es muy flexible y práctica, aunque no la vamos a desarrollar dado que C++Buider posee su propia definición de cadena de caracteres que veremos a continuación.

AnsiString Es una clase especialmente diseñada para la manipulación de cadenas de caracteres

definida por Borland®. Su definición tiene la forma: AnsiString Cadena = “Bioingenieria”;

Esta clase define varios métodos que facilitan la manipulación de las cadenas, entre las cuales se destacan (los ejemplos son siempre sobre la cadena original “Bioingenieria”):

Delete(pos, cant) Permite borrar una cantidad (cant) de caracteres de la propia cadena a partir de

una posición (pos) Cadena.Delete(1, 3); // Cadena = “ingenieria”

SubString(pos, cant)

Devuelve una nueva cadena que es una subcadena de la propia. La subcadena contiene cant caracteres y comienza desde pos. Sub = Cadena.SubString(6, 2); // Sub = “ge”

Nota: es importante diferenciar que en la cadena c++string el subíndice del primer caracter es el 0 (cero), mientras que para AnsiString es el 1 (uno).


Length() Devuelve la longitud (el número de bytes) de la cadena

int Longitud = Cadena.Length(); // Longitud = 13

Insert(subcadena, pos) Inserta una subcadena en nuestra cadena en la posición pos.

SubCad = “Super”; Cadena.Insert(Subcad, 1); // Cadena = “SuperBioingenieria”

SetLength(cant)

Cambia la longitud de la cadena a la especificada por cant. Si la cant es menor que la longitud de la cadena, entonces la trunca, es decir, borra todos los caracteres desde la posición cant+1 en adelante. Si cant es mayor a la longitud, el contenido de los caracteres restantes es incierto. Cadena.SetLength(10); // Cadena = “Bioingenie”

Pos(subcadena)

Devuelve la posición del inicio donde se encuentra la subcadena dentro de la cadena original. Si la cadena no posee la subcadena retorna el valor 0 (cero). Si la cadena posee repetida la subcadena dentro de ella, devuelve la posición del primero. int posicion = Candena.Pos(“in”); // posicion = 4

LowerCase()

Devuelve la cadena en minúscula. AnsiString cad = Cadena.LowerCase(); // cad = “bioingenieria”

UpperCase();

Devuelve la cadena en mayúscula. AnsiString cad = Cadena.UpperCase(); // cad = “BIOINGENIERIA”


Ejemplos

Ejemplo 1 Diseñar una función que informe si un número dado es capicúa o no.

Para diseñar esta función, primero pensamos en que parámetros debe recibir y cuales debe informar. Como dice el enunciado de nuestro problema, debemos recibir un número entero (int) que vamos a analizar e informar una variable lógica (bool) que indique si es capicúa o no. Nuestra función quedaría: bool EsCapicua (int numero);

Existen varias formas de resolver este problema, vamos a desarrollar aquí una sencilla mediante el uso de cadenas de caracteres. La idea principal es convertir la el número de entrada en una cadena, luego en una cadena auxiliar vamos copiando carácter por carácter en forma inversa, y al final comparamos estas dos cadenas para ver si son iguales. bool EsCapicua (int numero) { bool capicua = false; AnsiString Num = IntToStr(numero); AnsiString NumInv = “”; for (int i=Num.Length(); i>=1; i--) { NumInv += Num.SubString(i,1); } if (Num == NumInv) capicua = true; return capicua; }

Ejemplo 2 Diseñar una función que cuente la cantidad de palabras que se encuentran en una

cadena de caracteres.

De nuevo debemos pensar primero los parámetros de entrada y de salida de nuestra función. La entrada es una cadena de caracteres (AnsiString) y como salida un numero entero (int) que represente la cantidad de palabras.


int CantidadPalabras (AnsiString cadena); Para resolver nuestro problema, pensemos en que cada palabra esta separada por un

espacio, entonces contando la cantidad de espacios que hay en la cadena, representará la cantidad de palabras -1, es decir, a la cantidad de espacios hay que sumar 1.

Para contar la cantidad de espacios realizamos un ciclo, mientras exista un espacio en blanco, incrementamos un contador y lo borramos. Para poder saber si existe un espacio en blanco, hacemos uso del método pos de la clase AnsiString, dado que cuando la cadena contenga un espacio el valor devuelto será mayor a cero. Veamos como se hace: int CantidadPalabras (AnsiString cadena) { int cant = 0; AnsiString cad = cadena; while (cad.Pos(‘ ’) > 0) { cant++; cad.Delete(cad.Pos(‘ ’), 1); } return ++cant; }

En la función anterior se podría obviar la comparación mayor a cero, dado que cualquier valor distinto de cero en la condición será considerado como verdadero, cuyo efecto es el mismo. La última sintaxis ++cant se realiza para de esta forma dado que queremos que primero se incremente la variable cant y luego se retorne.

Si analizamos un poco mas profundo esta resolución, veremos que tiene varios problemas al resolver casos especiales. Estos son: cuando la cadena de entrada esta vacía nos dice que tiene una palabra, si tenemos dos palabras separadas por dos espacios nos dice que tenemos tres palabras, si existe un espacio al principio o al final también cuanta estos como palabras.

¿Como hacemos para eliminar estos espacios que no deberían ser contados? Para el primer debemos verificar si el primer carácter es un espacio si es así, lo borramos. Pero se debe hacer tantas veces como espacios en blancos contenga. Para eso implementamos un ciclo que, mientras el primer carácter sea igual al espacio en blanco, lo borre.

Para los espacios del final, se resuelve de manera igual, mientras el último carácter sea igual al espacio en blanco, lo borre.

Para el caso de los espacios repetidos entre dos palabras, una vez encontrado la ubicación del espacio, borramos en esa misma posición hasta que no posea espacios en blanco en ese lugar.


La implementación queda así: int CantidadPalabras (AnsiString cadena) { int cant = 0; int posi; AnsiString cad = cadena; if (cad.Length()) { while (cad[1] == ' ') cad.Delete(1,1); while (cad[cad.Length()] == ' ') cad.Delete(cad.Length(),1); while (cad.Pos(' ')) { cant++; posi = cad.Pos(' '); cad.Delete(posi, 1); while (cad[posi] == ' ') cad.Delete(posi,1); } cant++; } return cant; }


Capítulo 7: Archivos de Texto. Hasta ahora hemos visto cómo procesar información, y hemos mantenido el flujo de

entrada / salida de información a través de componentes visuales. Pero muchas veces la información necesaria, de entrada o salida, se presentará en estructuras de datos llamadas archivos, almacenadas en nuestro disco rígido.

Es por ello, que en este capítulo nos centraremos en el manejo del flujo de entrada / salida de información desde y hacia el HD.

Los archivos de texto tienen la capacidad de almacenar caracteres de la tabla ASCII, y su nombre físico (nombre con el cuál está almacenado en el HD) tiene el mismo formato que cualquier otro archivo, a saber:

NombreFísico.extensión, por ejemplo el archivo de texto “Leame.txt”, su nombre es Leame y su extensión es txt (de texto). No necesariamente el archivo de texto debe tener la extensión txt, puede poseer cualquier otra extensión.

Los archivos de texto, poseen algunos caracteres especiales dentro de él, que normalmente no son visibles cuando se abre el archivo con un editor de texto, pero que nos permiten delimitarlo. Ellos son: el caracter de fin de línea y el caracter de fin de archivo (EOF, end of file)

Para manipular los archivos, C++ nos presenta una jerarquía de clases especialmente diseñadas para ello. Donde nos concentraremos en dos de ellas: ifstream para manipular archivos de entrada de datos y ofstream para manipular archivos de salida de datos.

Existen algunas operaciones básicas que se realizan sobre los archivos, estas son:

• Creación del objeto.

• Apertura del archivo.

• Manipulación del archivo.

• Cierre del archivo.

Creación del objeto. Para la creación del objeto debemos declarar una variable cuyo tipo es algunas de

las clases nombradas. Por ejemplo, si queremos un trabajar con un archivo de entrada de datos, declaramos: ifstream ArchivoEnt;

Si el archivo fuera de salida de datos, declaramos: ofstream ArchivoSal;


Apertura del archivo. La apertura de un archivo establece la conexión entre el nombre lógico y el nombre

físico de nuestro archivo, abre el archivo y lo prepara para su manipulación.

Esto se puede realizar de dos maneras, la primera es a través del método open: void open(const char *nombre_archivo, openmode modo);

Este método puede recibir dos parámetros, el primero es una cadena de caracteres que representa el nombre físico del archivo que será abierto, y opcionalmente puede recibir un segundo parámetro que representa al modo que se abrirá.

Puede ser alguna de las siguientes opciones: ios::in Abre el archivo para lectura

ios::out Abre el archivo para escritura ios::ate Abre un archivo existente y se posiciona al final

ios::app Abre un archivo de salida para agregar al final

ios::nocreate Abre un archivo sólo si ya existe.

ios::noreplace Abre un archivo sólo si no existe.

ios::trunc Abre un archivo, si ya existe borra todo su contenido

ios::binary Abre un archivo en modo binario. Por defecto es modo texto.

Estas opciones se pueden combinar utilizando el operador or |, pero no todas las combinaciones son posibles. Un ejemplo seria: ArchivoSal.open(“datos.txt”, ios::out | ios::app);

Como dijimos anteriormente, el modo de apertura es un parámetro opcional del método, dado que de acuerdo a la clase hayamos creado el objeto, posee un modo de apertura por defecto. Estos son:

Clase Modo por defecto ofstream ios::out | ios::trunc ifstream ios::in fstream ios::in | ios::out

La segunda manera de abrir un archivo, es combinándola con la creación del objeto. Esto se puede realizar gracias a que el constructor de estas clases puede recibir el nombre del archivo físico como parámetro y realiza internamente la llamada al método open. ifstream ArchivoEnt(“datos.txt”);


Cierre del archivo. Como se abra dado cuenta nos salteamos, el apartado correspondiente a la

manipulación del archivo. Esto lo hacemos dado que es la parte más compleja, y preferimos dejarlo para el final.

Al terminar la manipulación del archivo, se debe cerrar el vínculo que hemos creado con nuestro archivo físico, para liberarlo y permitir que otros programas (o procesos) puedan usarlo. A demás se realizan otras acciones internas como liberar la memoria de un buffer creado, terminar de escribir sobre el archivo (dado que esta acción se realiza de a bloques), etc.

Esta acción se realiza mediante la llamada al método close().

ArchivoEnt.close(); Una vez cerrado el archivo, este objeto esta disponible para abrir nuevamente otro

archivo o ser destruido.

El cierre del archivo también se realiza de forma automática cuando el objeto es destruido. Esto se debe a que el destructor de la clase verifica si existe un archivo abierto, y si es así, llama al método close().

Manipulación del archivo. Con este término nos referimos, a la acción de leer o escribir sobre un archivo. A

pesar de que estas acciones son simples, se pueden armar estructuras complejas de acuerdo a la necesidad de cada problema.

Estas acciones, se pueden realizar mediante operadores o llamadas a métodos.

Operadores de lectura / escritura Existen dos operadores:

1. Operador de inserción: << Este operador permite insertar o escribir dentro del archivo un texto. El texto puede

ser una cadena de caracteres o no, gracias a que estas clases saben realizar la conversión de tipo de forma automática. Vamos a ver algunos ejemplos:

Código ejemplo Archivo salida

En este primer ejemplo vemos como se inserta una simple cadena de caracteres a un archivo de texto tipo ofstream llamado ArchivoSal

ArchivoSal << “alumno”; alumno


En el siguiente ejemplo, vemos que podemos realizar el mismo efecto insertando el contenido de la variable Texto.

string Texto = “Hola” ArchivoSal << Texto;

Hola

En este ejemplo, vemos que se pueden realizar inserciones sucesivas de dentro de

una misma fila, con la separación de un carácter de espacio que se realiza de forma automática. Al final de cada renglón agregamos endl para insertar un caracter de fin de línea, para movernos a la siguiente línea.

string Texto = “Hola”; ArchivoSal << Texto << “1” << endl; ArchivoSal << Texto << “ 2” << endl;

Hola1 Hola 2

Ahora vemos que podemos también realizar la inserción del contenido una variable

entera, cuyo contenido se convierte de forma automática en una cadena de caracteres. A demás se puede observar otra forma de insertar el caracter de fin de línea agregando \n

int num = 1; ArchivoSal << num << “Hola\n”; Num++; ArchivoSal << num << “ Hola\n”;

1Hola 2 Hola

Por último vamos a mostrar un ejemplo completo, con muchas combinaciones de

guardado, para que analicen la salida.

string Texto1 = "Hola"; string Texto2 = "Mundo"; int num = 1; Archi << Texto1 << Texto2 << endl; Archi << Texto1 << " " << Texto2 << endl; Archi << num << num++ << endl; Archi << num << " " << num++ << endl; Archi << num++ << " " << num << endl; Archi << Texto1 << num << "\n"; Archi << num++ << Texto2 << endl;

HolaMundo Hola Mundo 21 3 2 3 3 Hola4 4Mundo


2. Operador de extracción: >>

Este operador permite extraer el contenido de archivo un texto. Este operador extrae todo el contenido de la cadena y se lo asigna a nuestra variable hasta que encuentra un caracter de espacio o de fin de línea. Similar al anterior, el texto puede ser una cadena de caracteres o no, gracias a que estas clases saben realizar la conversión de tipo de forma automática, la conversión se realizará de acuerdo al tipo de dato de la variable que definamos. Vamos a ver algunos ejemplos:

Archivo entrada Código ejemplo

variables

En este primer ejemplo vemos como extrae una simple cadena de caracteres de un archivo de texto tipo ifstream llamado ArchivoEnt.

alumno string Texto; ArchivoEnt >> Texto; Texto = “alumno”

En este par de ejemplos, vemos como el mismo código permite leer cadenas de

caracteres sucesivos independientes que estén separadas por un caracter de espacio o de fin de línea.

alumno1 alumno2 string Texto1, Texto2; ArchivoEnt >> Texto1 >> Texto2; Texto1 = “alumno1”

Texto2 = “alumno2” alumno1 alumno2

string Texto1, Texto2; ArchivoEnt >> Texto1 >> Texto2;

Texto1 = “alumno1” Texto2 = “alumno2”

Ahora vemos que también podemos extraer la información independiente de que este sea un entero. Dado que la segunda extracción la hacemos sobre una variable del tipo int, la conversión se realiza automáticamente. Hay que tener cuidado que el dato a leer sea un entero, dado que C++ realiza la lectura igualmente pudiéndose obtener información errónea.

alumno 1 int num; string Texto; ArchivoEnt >> Texto >> num;

Texto = “alumno” num = 1


Métodos de lectura / escritura Como dijimos anteriormente, la lectura y escritura de datos también se puede

realizar mediante llamadas a métodos de la clase. Veamos cuales son:

• get() y getline(): Estos métodos permiten realizar la lectura de toda una línea, hasta que encuentra un

caracter de terminación.

Reciben tres parámetros. El primero es un puntero a un vector de caracteres (buffer), el segundo el tamaño del vector, y el tercero (opcional) el caracter de terminación. Por defecto este caracter es el “\n”, llamado caracter de fin de línea.

Si el primer caracter de la línea es el carácter de terminación, devuelven un vector de longitud cero. Pero su gran diferencia radica, en que el método get() se detiene, y una segunda llamada al método devuelve el mismo resultado, hasta que se cambie el caracter de terminación. En cambio, una segunda llamada al método getline() devuelve la siguiente línea, por lo que normalmente se utiliza este método.

Otra diferencia radica en que el método get() puede ser llamado sin ningún parámetro. En este caso devuelve el caracter siguiente.

Para aclarar un poco el tema, vamos a ver algunos ejemplos:

Archivo entrada Código ejemplo

Archivo salida

En este primer ejemplo vemos una simple lectura de una cadena de caracteres de un archivo llamado entrada.txt y su escritura en el archivo salida.txt.

alumno char buff[10]; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); ArchiEnt.getline(buff, 10); ArchiSal << buff << endl;

alumno

Ahora la diferencia de leer el texto de una línea que posee más caracteres que los que pedimos leer. Veremos la diferencia de la implementación con la función get() y con getline().

Alumno que no piensa no aprueba

char buff[10]; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); ArchiEnt.getline(buff, 10); ArchiSal << buff << endl; ArchiEnt.getline(buff, 10); ArchiSal << buff << endl;

Alumno qu Alumno qu


Alumno que no piensa no aprueba

char buff[10]; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); ArchiEnt.get(buff, 10); ArchiSal << buff << endl; ArchiEnt.get(buff, 10); ArchiSal << buff << endl;

Alumno qu e no pien

Ahora vemos que pasa cuando se tiene una línea vacía. Aclaramos que en la salida del segundo ejemplo, hay dos líneas vacías.

Alumno no aprueba

char buff[10]; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); for (int i=1; i<=3; i++) { ArchiEnt.get(buff, 10); ArchiSal << buff << endl; }

Alumno no aprueb Alumno no aprueba

char buff[10]; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); for (int i=1; i<=3; i++) { ArchiEnt.get(buff, 10); ArchiSal << buff << endl; }

Alumno

Ahora veremos como hacemos si queremos leer una línea y asignárselo

directamente a una variable del tipo string, no es tan simple como parece. Para resolver el problema hacemos uso de tres funciones de la clase string. La función begin() que nos devuelve un puntero al primer caracter de la cadena. Para especificar la cantidad de caracteres a leer podemos colocar simplemente un número que lo indica, si sabemos que las líneas del archivo no superan ese valor, o usar la función max_size() que nos devuelve la máxima cantidad de caracteres que soporta la clase string; a este valor hay que dividirlo por 2, dado que es el doble que el máximo valor del entero (int) que pide como parámetro la función. Por último, hay que utilizar la función c_str() para que nos devuelva el valor de la cadena contenida.

Alumno que no piensa string Texto; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); ArchiEnt.getline(Texto.begin(),

Alumno que no piensa


Texto.max_size()/2); ArchiSal << Texto.c_str() << endl;

Hay que destacar que el método getline, escribe directamente en una porción de memoria del string, que contiene la cadena c_string sin modificar ninguna de las propiedades de la clase string. Es por ello, que al querer escribir en un archivo se debe especificar que se desea escribir el contenido c_str() del string, dado que si quiero escribir directamente el string, como no se modificaron sus propiedades, la longitud de la cadena es cero, y por lo tanto “virtualmente” la cadena esta vacía.

Una forma de forzar a que se actualicen las propiedades del string, es realizar una asignación de su propio contenido:

Alumno que no piensa string Texto; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); ArchiEnt.getline(Texto.begin(), Texto.max_size()/2); Texto = Texto.c_str(); ArchiSal << Texto << endl;


La verdad es que parece un poco complejo, y poco recomendable leer una simple

línea de longitud indeterminada con el método anterior.

Por suerte, existe una función llamada getline() que realiza este procedimiento de forma más simple. Remarcamos que es una función y no un método como el que vimos antes. Esta función recibe un primer parámetro que es un ifstring, el segundo es un string, y opcionalmente puede recibir un tercer parámetro que es el carácter de terminación.

Esta función esta especialmente diseñada para leer string, por lo que no es necesario especificar el largo de la cadena.

Alumno que no piensa string Texto; ifstream ArchiEnt("entrada.txt"); ofstream ArchiSal("salida.txt"); getline(ArchiEnt, Texto); ArchiSal << Texto << endl;



Métodos especiales • eof()

Es uno de los métodos más importantes. Devuelve true si se llegó al final de archivo. Encontró el carácter EOF (End Of File).

• is_open() Este método devuelve true si se abrió correctamente el archivo.

• good() Este método devuelve true si no ocurrió ningún error.

• bad() Este método devuelve true si ocurrió algún error con el buffer.

• fail() Este método devuelve true si ocurrió algún error que no afecte al buffer.

Ejemplos

Ejemplo 1 Implementar una función que lea un archivo de texto llamado “Datos.txt”, que

contiene un número indeterminado de números ordenados en columna, y devuelva su promedio.

Para resolverlo debemos realizar un ciclo que lea línea por línea cada uno de los números, los vaya sumando y contando la cantidad de datos leídos, y por último calcule e informe el resultado. float PromedioDatos() { float x, suma = 0; int cont = 0; ifstream Archivo(“Datos.txt”); while (!Archivo.eof()) { Archivo >> x; suma += x;


cont++; } return suma/cont; }

Ejemplo 2 Implementar una función que lea un archivo de texto llamado “Lineas.txt”, que

contiene un número indeterminado de renglones, que contiene frases, y devuelva la cantidad líneas que contienen la palabra “casa”.

Para resolverlo debemos realizar un ciclo que lea línea por línea cada uno de los renglones, busque la palabra “casa” y los cuente, y por último informe el resultado. float CantidadCasas() { int cont = 0; string s; AnsiString Linea; ifstream Archivo(“Lineas.txt”); while (getline(Archivo, s)) { Linea = s.c_str(); if (Linea.Pos(“casa”) cont++; } return cont; }


ANEXO I: Tabla de caracteres ASCII

ASCII: American Standard Code for Information Interchange.


ANEXO II: funciones Dado que muchos de nuestros programas pueden requerir de acciones comunes

(como conversión de tipo de datos o generar un numero al azar), C++ Builder provee una gran cantidad de funciones ya implementadas disponibles para su uso, más una interfase a una gran cantidad de funciones del sistema operativo (API).

A continuación comentaremos algunas de las funciones más comunes, agrupadas por la acción que realizan.

Conversiones de tipo Este es el grupo más utilizado, dado que permite convertir un tipo de dado a otro.

IntToStr: permite convertir un número entero (int) a una cadena de caracteres (AnsiString).

StrToInt: permite convertir una cadena de caracteres (AnsiString) a un número entero (int).

FloatToStr: permite convertir un número flotante (float o double) a una cadena de caracteres (AnsiString).

StrToFloat: permite convertir una cadena de caracteres (AnsiString) a un número flotante (float o double).

FormatFloat: permite convertir un número flotante (float o double) a una cadena de caracteres (AnsiString) con un determinado formato. El formato permite especificar la cantidad de decimales, etc. AnsiString FormatFloat(AnsiString Fomato, Extended numero);

Funciones matemáticas pow: permite calcular la potencia de un número.

double pow(double base, double exponente); random: permite generar un número al azar entre 0 y el número especificado menos

uno. int random(int numero);

randomize: permite inicializar el generador de números aleatorios con un valor aleatorio. Esta función puede ser llamada al comenzar el programa o antes de comenzar a generar números aleatorio con la función random.

sqrt: permite calcular la raiz cuadrada de un número dado.


double sqrt(double numero); floor: redondea un número flotante hacia abajo, es decir, el mayor número entero no

mayor al número dado. double floor(double numero);

ceil: redondea un número flotante hacia arriba, es decir, el menor número entero no menor al número dado. double ceil(double numero);

Programación en C++ con C++Builder

Documents

Transcript of Programación en C++ con C++Builder