Manual de Mingw

UNIVERSIDAD PONTIFICIA COMILLAS
ESCUELA TCNICA SUPERIOR DE INGENIERA (ICAI)

INGENIERO EN INFORMTICA
PROYECTO FIN DE CARRERA
PROGRAMACIN ORIENTADA A OBJETOS MEDIANTE MINGW DEVELOPER STUDIO
AUTOR: JACOBO IGLESIAS JATO MADRID, Septiembre de 2008
Autorizada la entrega del proyecto del alumno:
Jacobo Iglesias Jato
EL DIRECTOR DEL PROYECTO Eduardo Alcalde Lancharro
Fdo.:
Fecha: 05/ 09 / 08
VB DEL COORDINADOR DE PROYECTOS Eduardo Alcalde Lancharro
Fdo.:
Fecha: 12/ 09/ 08
El verdadero progreso es el que pone la tecnologa al alcance de todos.
Henry Ford. (1863-1947)
Programacin Orientada a Objetos en C mediante MinGW Developer Studio.
AGRADECIMIENTOS
A mis padres, por darme la oportunidad de demostrar mi vala y por su gran apoyo econmico y emocional durante estos cinco aos de carrera.
A mis hermanos, por su apoyo incondicional en los buenos y malos momentos.
A Jaime, Luis y Nico, porque durante estos aos han estado siempre ah y han hecho de ellos una etapa inolvidable en mi vida.
A Alba, por aguantarme y confiar en m durante todo este tiempo.
A Edu, por su apoyo y confianza durante estos ltimos aos.
Al Director del proyecto, Eduardo, por su cercana e inestimable ayuda a la hora de desarrollar este proyecto.
A Santiago Canales, porque sin su apoyo en aquellos primeros momentos difciles no habra alcanzado la meta.
RESUMEN
Se ha realizado un estudio y anlisis detallado del compilador de libre difusin (freeware) MinGW Developer Studio. Dado que este compilador es freeware, se puede descargar de la red sin ningn coste si bien no trae documentacin alguna. Esto es debido a que, al ser gratuito, se facilita su uso y expansin pero carece de documentacin o manual de ayuda al usuario. Por esta razn se ha realizado un anlisis profundo del compilador en el que se especifican todos los aspectos que faciliten al usuario su utilizacin como herramienta software de procesamiento de programas en los lenguajes C y C++.
En el proyecto se ha llevado a cabo una explicacin del entorno de desarrollo del compilador, del proceso de creacin de aplicaciones, de la estructura del programa y del proceso de depuracin de aplicaciones. Adems, se han explicado en detalle los diferentes comandos existentes en el men de la aplicacin as como las diferentes barras que componen la interfaz.
El estudio del funcionamiento del compilador en la parte que se corresponde a Orientacin a Objetos tambin ha sido objeto de estudio del proyecto. Para ello se han explicado los diferentes conceptos clave propios de la Programacin Orientada a Objetos (POO) as como los principales paradigmas que caracterizan a este enfoque de programacin.
Para poder llevar a cabo POO en MinGW Developer Studio es preciso emplear el lenguaje de programacin C++. Este lenguaje permite programar tanto en estilo procedimental (orientado a algoritmos), como en estilo orientado a objetos, como en ambos a la vez. Por ello, se han estudiado todas las opciones que ofrece este lenguaje en cuanto a Orientacin a Objetos as como las opciones que ofrece el compilador para permitir programar empleando el citado lenguaje de programacin.
II
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. El estudio de las libreras grficas del compilador para permitir desarrollar interfaces grficos de usuario (GUI) es otro de los aspectos que se abordan en el proyecto. Para ello, se ha explicado en detalle el proceso de creacin de ventanas, as como el manejo de algunos elementos bsicos como cuadros de dilogo o mens.
Para poder llevar a cabo programacin de interfaces grficas de usuario (GUI) en MinGW Developer Studio es preciso emplear el API de Windows (WinAPI), que es un conjunto de interfaces de programacin de aplicaciones (application programming interfaces - API) de Microsoft disponible en los sistemas operativos Microsoft Windows.
III
ABSTRACT
A detailed study and analysis about the freeware compiler MinGW Developer has been carried out in this project. Though this is a freeware compiler, it can be downloaded for free from the Internet without any additional costs but it does not include any documentation. This is due to the fact that being freeware makes its use and expansion easier but it lacks documentation or user help manual. For this reason, an exhaustive compiler analysis has been carried out where all the aspects that make its use as a C and C++ programs processing software tool easier are specified.
A detailed explanation about several aspects of the compiler has also been carried out. Aspects such as the development environment, the applications creation process, program structure and applications debugging have been explained in a thorough way. All the different commands and bars that make the interface up have also been described.
The running of the compiler in the part related to Object Oriented Programming (OOP) has also been studied. For that reason, all the different basic concepts about OOP have been explained as well as the main programming paradigms that characterize this programming approach.
It is necessary to use C++ programming language to carry out OOP in MinGW Developer Studio. This language makes possible for users to program in procedural style (algorithm oriented programming) and also in object oriented style, as well as both at the same time. Due to that, all the options that this language offers related to Object Orientation have been studied as well as all the alternatives that this compiler offers to allow programming using the aforementioned programming language.
The study of the compilers graphic libraries that make graphical user interfaces (GUI) development possible is another aspect that has been tackled
IV
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. in the project. Therefore, the windows creation process as well as the use of some basic elements such as dialog boxes or menus has also been explained in detail.
To carry out graphical user interfaces (GUI) programming in MinGW Developer Studio it is necessary to use Windows API (WinAPI), which is a group of Microsofts application programming interfaces available in all Microsoft Windows operative systems.
NDICE
PARTE I: Estudio del compilador ................................................................... 1 1. Entorno de desarrollo de MinGW Developer Studio ................................. 2 2. Iniciar MinGW Developer Studio ............................................................... 5 2.1. Descarga e instalacin de MinGW Developer Studio ...................... 6 2.2. Iniciar MinGW Developer Studio...................................................... 8 3. Crear una aplicacin en lenguaje de programacin C ............................ 10 4. Estructura del entorno de desarrollo de MinGW Developer Studio ......... 14 4.1. Zonas principales .......................................................................... 15 4.1.1. Zona de workspace ................................................................. 15 4.1.2. Zona de edicin ....................................................................... 21 4.1.3. Zona de salida ......................................................................... 23 4.2. Barras de tareas ............................................................................ 27 4.2.1. Men principal ......................................................................... 27 4.2.2. Barra de herramientas ............................................................ 66 5. Depuracin de programas (Debugging) .................................................. 67 5.1. Men Debug .................................................................................. 69
PARTE II: Funcionamiento del compilador en la parte que corresponde a Orientacin a Objetos (C++) ................................................. 79 1. Introduccin ............................................................................................ 80 2. Creacin de aplicaciones C++ en MinGW Developer Studio .................. 84 2.1. Opciones de MinGW Developer Studio relacionadas con C++ ..... 88 3. Programacin Orientada a Objetos (POO) en C++ ................................. 90 3.1. Clase ............................................................................................. 93 3.2. Constructor y destructor ................................................................ 95 3.3. Creacin de objetos....................................................................... 96 3.4. Especificadores de acceso ............................................................ 98 3.5. Ficheros de cabecera y espacio de nombres ................................ 99 3.6. Ejemplo de aplicacin orientada a objetos mediante MinGW Developer Studio ......................................................................... 101
VI
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. 3.7. Operadores de entrada/salida ..................................................... 103 3.8. Modificadores .............................................................................. 105 3.9. Variable reservada this ................................................................ 107 3.10. Mtodos inline ............................................................................. 109 3.11. Clases y mtodos friend .............................................................. 110 4. Paradigmas de programacin ............................................................... 113 4.1. Encapsulamiento ......................................................................... 114 4.2. Ocultacin.................................................................................... 116 4.3. Abstraccin .................................................................................. 117 4.4. Herencia ...................................................................................... 118 4.4.1. Herencia mltiple .................................................................. 127 4.5. Polimorfismo ................................................................................ 128 4.5.1. Implementacin de los mtodos virtuales ............................. 131 4.5.2. Mtodos virtuales puros ........................................................ 133 4.5.3. Clases abstractas .................................................................. 134 4.5.4. Destructores virtuales............................................................ 135
PARTE III: Estudio de las libreras grficas del compilador para permitir desarrollar interfaces grficas de usuario (GUI) ............................ 136 1. Introduccin .......................................................................................... 137 2. API de Windows (WinAPI) .................................................................... 140 2.1. Introduccin ................................................................................. 141 2.2. Caractersticas de la programacin en Windows ......................... 143 2.2.1. Independencia de la mquina ............................................... 143 2.2.2. Recursos ............................................................................... 143 2.2.3. Ventanas ............................................................................... 144 2.2.4. Eventos ................................................................................. 144 2.2.5. Controles ............................................................................... 146 2.3. Creacin de proyectos WinAPI en MinGW Developer Studio...... 147 2.4. Componentes de una ventana..................................................... 150 2.5. Notacin hngara ........................................................................ 152 2.6. Estructura de un programa Windows GUI ................................... 154
VII
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. 2.6.1. Cabeceras ............................................................................. 154 2.6.2. Prototipos .............................................................................. 155 2.6.3. Funcin de entrada WinMain ................................................ 155 2.6.3.1. Parmetros de entrada de WinMain ............................. 155 2.6.3.2. Funcin WinMain tpica................................................. 156 2.6.3.3. Declaracin ................................................................... 158 2.6.3.4. Inicializacin ................................................................. 158 2.6.3.5. Bucle de mensajes ....................................................... 159 2.6.4. Definicin de funciones ......................................................... 159 2.7. El procedimiento de ventana ....................................................... 160 2.7.1. Sintaxis.................................................................................. 160 2.7.2. Prototipo de procedimiento de ventana ................................. 161 2.7.3. Implementacin de procedimiento de ventana simple........... 161 2.8. Ejemplo GUI mediante MinGW Developer Studio ....................... 162 3. Mens y cuadros de dilogo ................................................................. 165 3.1. Mens ............................................................................................. 166 3.1.1. Funcin MessageBox ............................................................ 170 3.1.2. Ejemplo completo de mens y cuadros de mensaje ............. 174 3.2. Cuadros de dilogo ........................................................................ 178 3.2.1. Procedimiento de dilogo ...................................................... 181 3.2.2. Paso de parmetros a un cuadro de dilogo......................... 185 3.2.3. Ejemplo completo de cuadros de dilogo.............................. 189 4. Creacin de recursos mediante el editor de recursos ........................... 194
PARTE IV: Valoracin y conclusiones........................................................ 203 1. Valoracin econmica y planificacin ................................................... 204 1.1. Valoracin econmica ................................................................. 205 1.1.1. Coste de tecnologa .............................................................. 205 1.1.2. Coste de implantacin ........................................................... 206 1.2. Planificacin del proyecto ............................................................ 208 2. Conclusiones ........................................................................................ 210 3. Bibliografa ............................................................................................ 213
VIII
PARTE I: Estudio del compilador
-1-
Captulo
Entorno de desarrollo de MinGW Developer Studio
-2-
CAPTULO 1. Entorno de desarrollo de MinGW Developer Studio.

El compilador MinGW Developer Studio es de libre difusin (freeware), esto es, puede descargarse de forma gratuita desde la pgina web de Parinya (www.parinyasoft.com) en las siguientes versiones:
Nombre Fichero
Tamao (MB)
Sistema Operativo
Versin
Fecha de creacin 01-042005
Contenido Entorno de desarrollo y compilador. Entorno de desarrollo y compilador. Incluye
MinGWStudioFullSetup2_05.exe
26
Windows
2.05
MinGWStudioFullSetupPlus2_05.exe
125
Windows
2.05
01-042005
adems las libreras wxWidgets 2.6.0 para crear entornos grficos.
Mingw-devstudio_linux2.06.tar.gz
Linux
2.06
08-072005
Entorno de desarrollo y compilador.
Adems, en caso de descargarse para el sistema operativo Windows Vista es necesario llevar a cabo los siguientes pasos:
Despus de instalar el compilador se debe editar la variable de entorno PATH. Esto se hace en Panel de control avanzada del sistema avanzadas Sistema Configuracin Opciones
Propiedades del sistema
Variables de entorno.
-3-
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Aadir a la variables de entorno PATH los siguientes directorios:
C:\MinGWStudio;C:\MinGWStudio\MinGW\bin;C:\MinGWStudio\MinGW\lib\gcc\mingw32\3.4.2
-4-
Captulo
Iniciar MinGW Developer Studio
-5-
CAPTULO 2. Iniciar MinGW Developer Studio.

Antes de explicar el inicio del entorno de desarrollo de MinGW Developer Studio se explicarn los pasos que hay que dar a la hora de descargar e instalar el software.
2.1. Descarga e instalacin de MinGW Developer Studio.

Para descargar el programa se accede a la pgina Web de Parinya (www.parinyasoft.com). En el apartado Download aparecen una serie de versiones del software que se pueden descargar. La versin que se recomienda descargar es la nmero 3 de MS-Windows por ser la ms completa y la que incluye todas las herramientas disponibles para el software. Se descarga, por tanto, el fichero MinGWStudioFullSetupPlus-2_05.exe.
Una vez descargado el fichero de instalacin, se ejecuta y aparece un asistente de descarga del software llamado Simtel Downloader.
-6-
Una vez que el asistente de descarga alcanza el 100% de progreso aparece el asistente de instalacin de MinGW Developer Studio.
Se pulsa el botn Next y se siguen los pasos del asistente en los que se solicitar la aceptacin de los trminos de licencia, la seleccin de los componentes a instalar y el directorio de instalacin. Una vez instalado el software tras pulsar el botn Install aparece una ventana de confirmacin de instalacin donde aparecen marcadas por defecto las opciones Show Readme para ver los crditos del software y Run MinGW Developer Studio 2.05 para
-7-
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. ejecutar la aplicacin. Se desactivan las opciones que no interesen y se pulsa el botn Finish. En este momento el software ya estar instalado.
2.2. Iniciar MinGW Developer Studio.

Para iniciar el entorno de desarrollo de MinGW Developer Studio se hace lo siguiente:
i.
En el escritorio de Windows, se sita el puntero del ratn en el men Inicio, en la esquina inferior izquierda, y se pulsa el botn izquierdo del ratn.
ii. Se elige la opcin Todos los programas o Programas (Men Inicio clsico) en el men Inicio.
iii. En el siguiente men, se encontrar la opcin MinGW Developer Studio, y se sita sobre ella el ratn.
iv. Se elige la opcin MinGW Developer Studio en el men.
-8-
v. Transcurrido el tiempo de carga, se muestra el escritorio de MinGW Developer Studio.
-9-
Captulo
Crear una aplicacin en lenguaje de programacin C
C
- 10 -
CAPTULO 3. Crear una aplicacin en lenguaje de programacin C.

Inicialmente, el rea de trabajo del entorno de desarrollo est vaca. Para crear ahora la estructura de una nueva aplicacin, se procede del siguiente modo:
a. Se elige la opcin New en el men File (o se pulsan las teclas Ctrl y N simultneamente) o bien se pulsa el botn herramientas. de la barra de
b. A continuacin, se presenta una ventana en la que se puede elegir el tipo de aplicacin que se desea crear. Se selecciona la pestaa Projects y la aplicacin de tipo Win32 Console Application. Ahora se procede a nombrar el proyecto escribiendo el nombre que se desea en el cuadro Project name. En el cuadro Location se permite especificar la ruta de acceso al directorio, es decir, el directorio donde se crear la carpeta de nombre igual al del proyecto y que contendr todos los ficheros relativos
- 11 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. al proyecto (ejecutables, cdigo fuente, etc.). Una vez especificado el nombre del proyecto y la ruta de acceso se confirma el cuadro de dilogo pulsando OK y ya se ha creado un proyecto nuevo. En el directorio especificado en el cuadro Location se habr creado un fichero llamado nombre_del_proyecto.msp (MinGWStudio Project Files). Puede darse la situacin de que el fichero creado tenga extensin *.mdsp en vez de *.msp. Esto se debe a que algunas versiones del compilador ponen dicha extensin a los ficheros de proyecto.
c. El paso siguiente es crear un fichero y aadirlo al proyecto actualmente vaco. Se elige la opcin New del men File (o se pulsan las teclas Ctrl y N simultneamente) o se pulsa el botn de la barra de herramientas.
Se selecciona la pestaa Files y el fichero de tipo C/C++ Source File para crear un fichero de lenguaje de programacin C (*.c) que contenga el cdigo fuente. Se nombra el fichero (se debe aadir la extensin .c) en el cuadro File name y se confirma pulsando OK. El campo Location no debe ser modificado ya que por defecto se muestra la ruta de acceso al directorio del proyecto creado anteriormente. Adems, la checkbox Add to project se encuentra activada para aadir el fichero al proyecto que se haba creado previamente. Por tanto, la ruta de acceso y la checkbox no deben ser modificadas. En el directorio del proyecto se habr creado un fichero llamado nombre_del_fichero.c (C Source File).
- 12 -
d. El entorno ya est listo para introducir el cdigo en la zona de edicin.
A continuacin se describir la estructura del entorno de desarrollo as como los componentes y sus propiedades ms importantes.
- 13 -
Captulo
Estructura del entorno de desarrollo de MinGW Developer Studio
- 14 -
CAPTULO 4. Estructura del entorno de desarrollo de MinGW Developer Studio.

A continuacin se explicar la estructura del entorno de desarrollo en su pantalla inicial. Dicha pantalla consta de tres zonas principales y dos barras de tareas.
4.1. Zonas principales.

Se distinguen tres zonas principales: la zona de workspace, la zona de edicin y la zona de salida.
4.1.1. Zona de workspace.

En esta zona aparecer el nombre del proyecto que se cree as como los diferentes ficheros asociados a l. Los ficheros son agrupados en cuatro carpetas principales en funcin de su tipologa. Estas carpetas son presentadas
- 15 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. en estructura de rbol de tal forma que se pueden minimizar y maximizar para ocultar y ver su contenido respectivamente haciendo doble clic sobre ellas o sobre el smbolo situado a su izquierda. Las cuatro carpetas en las que son agrupados son: Source Files (Ficheros Fuente), Header Files (Ficheros de cabecera), Resource Files (Ficheros de recursos) y Other Files (Otros ficheros). Por ejemplo, en el proyecto del captulo 3, la zona de workspace fue la siguiente:
Source Files: en esta carpeta aparece el fichero fuente asociado al proyecto. Este fichero puede tener las siguientes extensiones: *.c, *.cc, *.cpp, *.cxx. Se pueden aadir ficheros fuente a un proyecto ya creado pulsando la carpeta Source Files con el botn derecho del ratn y seleccionando Add source files to project Se selecciona el fichero con la extensin apropiada y se aade al proyecto.
- 16 -
Header Files: en esta carpeta aparecen los ficheros de cabecera asociados al proyecto. Estos ficheros pueden tener las siguientes extensiones: *.h, *.hh, *.hpp, *.hxx. Se pueden aadir ficheros de cabecera a un proyecto ya creado pulsando la carpeta Header Files con el botn derecho del ratn y seleccionando Add header files to project Se selecciona el fichero con la extensin apropiada y se aade al proyecto.
- 17 -
Resource Files: en esta carpeta aparecen los ficheros con extensin *.rc y *.rc2 asociados al proyecto. Estos ficheros son empleados por GTK+ (GIMP Tool Kit) para tratar las opciones predeterminadas de las aplicaciones. Con ellos se pueden cambiar los colores de cualquier control, poner un dibujo de fondo, etc. GTK+ es un grupo importante de bibliotecas o rutinas para desarrollar interfaces grficas de usuario (GUI) mediante C, C++ y otros lenguajes de programacin. Se pueden aadir ficheros *.rc y *.rc2 a un proyecto ya creado pulsando la carpeta Resource Files con el botn derecho del ratn y seleccionando Add resource files to project Se selecciona el fichero con la extensin apropiada y se aade al proyecto.
- 18 -
Other Files: en esta carpeta aparecen ficheros de cualquier tipo distinto a los anteriormente citados que haya sido asociado al proyecto. Al igual que en las tres carpetas anteriores, se pueden aadir ficheros a un proyecto ya creado pulsando la carpeta Other Files con el botn derecho del ratn y seleccionando Add other files to project Se selecciona el fichero con la extensin apropiada y se aade al proyecto.
- 19 -
Finalmente, en la zona de workspace es posible ejecutar acciones sobre el proyecto o sus ficheros asociados pulsando con el botn derecho del ratn sobre su icono correspondiente. De esta forma se evita tener que buscar en el men principal la opcin correspondiente al
comportamiento que se desea realizar. Sobre un proyecto aparecen las siguientes opciones: o Close: mismo comportamiento que File Close. Set Active
o Set Active Configuration: mismo comportamiento que Build Configuration. o Settings: mismo comportamiento que Project o Build: mismo comportamiento que Build o Rebuild: mismo comportamiento que Build Settings.
Build. Rebuild. Build All
o Build All Configurations: mismo comportamiento que Build Configurations. o Clean: mismo comportamiento que Build Clean.
o Clean All Configurations: mismo comportamiento que Build Configurations. o Execute: mismo comportamiento que Build Execute.
Clean All
o Export Makefile: mismo comportamiento que Project - 20 -
Export Makefile.
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Los comportamientos correspondientes a cada opcin sern explicados en detalle en el apartado 4.2.1 Men principal.
Por otra parte, si se pulsa con el botn derecho un fichero asociado a un determinado proyecto aparecen las siguientes opciones: o Open nombre_fichero: abre el fichero seleccionado en la zona de edicin. o Compile nombre_fichero: compila el fichero seleccionado. o Remove nombre_fichero from project: elimina el fichero seleccionado del proyecto.
La opcin Compile nombre_fichero slo aparece en los ficheros Source Files y en los ficheros Header Files mientras que las otras dos opciones son comunes a los cuatro tipos de ficheros que pueden asociarse a un proyecto.
4.1.2. Zona de edicin.

En esta zona se podr editar el cdigo asociado al proyecto. Dicho cdigo es presentado al usuario en diferentes colores para permitir diferenciar segmentos de cdigo en funcin de su tipologa. El color verde es empleado para destacar los comentarios y observaciones que se escriban en el cdigo mientras que el color azul se utiliza para destacar palabras clave del lenguaje de programacin tales como tipos de variables (int, char, float, ), operadores (==, &, *, ), palabras reservadas (do, if, for, return, ), etc. Por otra parte, las directivas del precompilador (include, define, ) se muestran en color marrn mientras que el texto a presentar con printf y el tipo de variable a leer con scanf se muestran en color prpura. Finalmente, los nombres de variables y las funciones propias del lenguaje como printf, scanf, gets, fflush, stdin, etc. se muestran en color negro. A continuacin se muestra un ejemplo de cdigo fuente donde se observan los diferentes colores en la zona de edicin segn la tipologa del cdigo.
- 21 -
En el ejemplo anterior tambin se puede observar que el compilador presenta en el lado izquierdo de la zona de edicin la numeracin de las lneas del cdigo. De esta forma se facilita el seguimiento del cdigo y la futura estimacin de la complejidad del programa. Adems, se ofrece la posibilidad de ocultar bloques de cdigo independientes como declaraciones de estructuras, funciones, bloques if-else, bloques while o do-while, bloques for o incluso la propia funcin principal (main). De esta forma se optimiza la bsqueda de errores en cdigo permitiendo al usuario ocultar bloques de cdigo en los que se descarta la aparicin de fallos.
Tambin hay que destacar que existe una manera de ampliar la zona de edicin para facilitar la visualizacin del cdigo o en caso de que el usuario tenga problemas de vista. Esta forma de hacer zoom sobre la zona de edicin consiste en situarse sobre la misma y pulsar la tecla Ctrl y girar la rueda del ratn hacia atrs simultneamente. Si, por el contrario, se pulsa la tecla Ctrl y se gira la rueda del ratn hacia delante simultneamente entonces se disminuir el zoom sobre la zona de edicin. De esta manera tan sencilla se permite al usuario ajustar el rea de visin de la zona de edicin en funcin de sus necesidades. - 22 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Por ltimo, cuando se abre un fichero aparece una pestaa con su nombre en la parte superior de la zona de edicin. Si se pulsa con el botn derecho sobre dicha pestaa aparecen una serie de opciones que permiten ejecutar acciones sobre el fichero sin necesidad de buscar la opcin en el men principal. Estas opciones son las siguientes: o Close: mismo comportamiento que File o Save: mismo comportamiento que File o Save As: mismo comportamiento que File o Find: mismo comportamiento que Edit Close. Save. Save As.
Find. Replace.
o Replace: mismo comportamiento que Edit o Print: mismo comportamiento que File
Print. Print Preview.
o Print Preview: mismo comportamiento que File
Los comportamientos correspondientes a cada opcin sern explicados en detalle en el apartado 4.2.1 Men principal.
4.1.3. Zona de salida.

En esta zona se mostrarn mensajes acerca de las operaciones efectuadas por el compilador a la hora de compilar, enlazar y ejecutar un programa. As mismo, se mostrar informacin acerca de los errores y warnings (advertencias) que se produzcan al efectuar alguna de las operaciones anteriormente comentadas. Estos mensajes sern presentados en la pestaa Build, primera de las tres pestaas de las que consta la zona de salida. La segunda pestaa (Debug) presenta informacin acerca de las operaciones del depurador de errores si bien el funcionamiento del mismo se ver en el captulo 5 Depuracin de programas. La tercera y ltima pestaa (Find in Files) se encarga de presentar los resultados de la bsqueda en ficheros, es decir, la informacin relativa a la bsqueda de palabras en ficheros del proyecto. La bsqueda en ficheros ser explicada con mayor detalle en el apartado 4.2.1 Men principal. A continuacin se explicar en detalle la pestaa Build donde
- 23 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. se muestran mensajes relativos a la compilacin, enlazado y ejecucin de programas. Bajo estas lneas se muestra un ejemplo de un programa que, tras ser compilado, presenta errores y warnings:
Como se puede observar, el programa presenta tres errores y un warning. Las dos primeras lneas de la zona de salida muestran un mensaje donde se informa de que el proyecto de nombre Proyecto ha sido compilado. La segunda lnea (Compiling) es generada antes de llevarse a cabo la compilacin y presenta informacin acerca de su resultado. La tercera lnea indica el nombre del fichero compilado (programa.c) mientras que la cuarta lnea indica el nombre de la funcin donde se han producido los errores y warnings (main). Las cuatro lneas siguientes (tantas como errores y warnings se han producido) muestran informacin acerca de cada uno de los errores y warnings. Por cada fallo se presenta la siguiente informacin: fichero en el que se ha producido el fallo, nmero de lnea dentro del fichero en el que se ha producido el fallo, tipo de fallo (error o warning) y breve descripcin del fallo producido. Hay que destacar que el warning que se muestra en el ejemplo es caracterstico de MinGW Developer Studio ya que se debe introducir una lnea en blanco al final del cdigo fuente. En caso contrario, el compilador presentar una advertencia que, si bien no - 24 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. afecta a la ejecucin del programa, resulta molesto para el usuario. Finalmente, la ltima lnea muestra un resumen del resultado de la compilacin en el que se muestra el nmero total de errores y warnings que se han producido tras la compilacin. Adems, a la izquierda de esta informacin aparece el nombre de un fichero: programa.o. Este fichero es generado por el compilador al hacer la compilacin y aparece en la carpeta Debug del directorio del proyecto que ha sido compilado.
Una de las caractersticas que presenta el compilador en la zona de salida es la facilidad a la hora de localizar de forma rpida y precisa errores y warnings en cdigo. Aunque el compilador informa acerca del nmero de lnea en que se producen los errores y warnings tal y como se ha comentado anteriormente, la forma ms fcil y rpida de localizar dichos fallos es haciendo doble clic sobre la lnea de la zona de salida en la que se informa acerca del fallo. Una vez hecho esto, la lnea correspondiente al fallo se sombrear en color amarillo y en la zona de edicin se mostrar el segmento de cdigo en el que se produjo el fallo. Dentro de este segmento faltara localizar la lnea en la que se produjo el fallo. Pues bien, esto se realiza por medio de una flecha de color verde situada en el margen izquierdo de la zona de edicin. Esta flecha est situada a la derecha del nmero de lnea en que se produjo el fallo y apunta a la lnea que lo contiene. De esta forma el fallo ya ha sido localizado y se puede corregir de forma rpida sin necesidad de realizar una bsqueda en la zona de edicin para encontrar la lnea en que se produjo. La situacin anteriormente descrita se ilustra en la siguiente captura:
- 25 -
Si en vez de realizar la compilacin del programa se hiciera el enlazado del mismo, se presentaran las siguientes diferencias:
La segunda lnea mostrara el mensaje Compiling source file(s) en vez de Compiling ya que llevara a cabo la compilacin y enlazado de todos los ficheros fuente asociados al proyecto. En la compilacin, nicamente se compila un fichero. Si el enlazado es satisfactorio se muestra el mensaje Linking antes de mostrar el resultado del enlazado sin fallos. Si por el contrario el enlazado tiene fallos, se muestran los fallos al igual que en la compilacin.
La ltima lnea muestra el nombre del fichero programa.exe que se genera al hacer el enlazado y que aparece en la carpeta Debug del directorio del proyecto que ha sido compilado. Este fichero sustituye al fichero programa.o que haba sido generado en la compilacin dado que al realizar el enlazado tambin se hace la compilacin.
Si se realizara la ejecucin del programa, la zona de salida contendra informacin relativa al enlazado puesto que ste es imprescindible para ejecutar
- 26 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. el programa. Si se intenta ejecutar el programa sin llevar a cabo el enlazado se presenta el siguiente cuadro de dilogo:
El cuadro de dilogo sobre estas lneas informa al usuario que el fichero ha sido modificado desde el ltimo enlazado o compilacin o bien no ha sido enlazado todava. Si se pulsa S el compilador llevar a cabo el enlazado (incluye la compilacin) del programa y su ejecucin. Si, por el contrario, se pulsa No se llevar a cabo la ejecucin del programa con la ltima versin enlazada del fichero (el fichero *.exe en la carpeta Debug del directorio del proyecto) y, por tanto, se estar ejecutando un cdigo distinto al que hay en la zona de edicin. Si se hubiera pulsado Cancelar el cuadro de dilogo simplemente habra desaparecido.
4.2. Barras de tareas.

Adems de las zonas principales explicadas anteriormente, existen dos barras de tareas en la parte superior de la pantalla que permiten manejar las diversas opciones del programa, realizar ajustes y ejecutar de forma directa las operaciones ms comunes por medio de iconos. Estas dos barras de tareas son: el men principal y la barra de herramientas.
4.2.1. Men principal.

Consta de nueve mens que permiten al usuario llevar a cabo operaciones tales como el guardado del proyecto, la creacin de un nuevo proyecto, ajustar las opciones del compilador, etc. Estos mens son: File (Archivo), Edit (Editar), View (Vista), Project (Proyecto), Build (Construir), Debug (Depurar), Tools (Herramientas), Window (Ventana) y Help (Ayuda). Cada uno de los mens ser explicado con mayor detalle a continuacin. - 27 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. File: Consta de catorce opciones como son New (Nuevo), Open (Abrir), Close (Cerrar), Close All (Cerrar todo), Save (Guardar), Save As (Guardar como), Save All (Guardar todo), Export (Exportar), Page Setup (Configurar pgina), Print (Imprimir), Print Preview (Vista previa de impresin), Recent Files (Ficheros recientes), Recent Projects
(Proyectos recientes) y Exit (Salir).
o New: Puede activarse tambin pulsando simultneamente las teclas Ctrl y N. Esta opcin permite crear un nuevo proyecto tal y como se ha explicado en el captulo 3 si bien solo se explic cmo crear un proyecto de aplicacin de consola Win32. Hay que recordar que los programas de consola se desarrollan mediante Funciones de consola, las cuales proporcionan compatibilidad con el modo de caracteres en ventana de consola. Las bibliotecas en tiempo de ejecucin del compilador MinGW Developer Studio
tambin proporcionan entrada y salida de ventanas de consola con funciones estndar de E/S, como printf() y scanf(). Las aplicaciones de consola no tienen interfaz grfica de usuario. Al compilarse producen un fichero .exe que se puede ejecutar como una aplicacin independiente desde la lnea de comandos.
Otro tipo de proyecto que se puede crear es el de aplicacin Win32. Una aplicacin Win32 es un programa ejecutable (EXE) escrito en C o C++, que utiliza llamadas a la API Win32 para crear una interfaz grfica de usuario.
El tercer tipo de proyecto que se permite crear es el de biblioteca de vnculos dinmicos (DLL) Win32. Un fichero DLL para Win32 es un fichero binario, escrito en C o C++, que utiliza llamadas a la API Win32 en lugar de llamadas a clases
- 28 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. MFC (Microsoft Foundation Classes) y que acta como una biblioteca compartida de funciones que pueden utilizar simultneamente mltiples aplicaciones.
El cuarto tipo de proyecto que se permite crear es el de biblioteca esttica. Una biblioteca esttica, tambin conocida como fichero, consiste en un conjunto de rutinas que son copiadas en una aplicacin por el compilador o el enlazador, produciendo ficheros con cdigo objeto y un fichero ejecutable independiente. Este proceso, y el fichero ejecutable, se conocen como construccin esttica de la aplicacin objetivo. La direccin real, las referencias para saltos y otras llamadas a rutinas se almacenan en una direccin relativa o simblica, que no puede resolverse hasta que todo el cdigo y las bibliotecas son asignados a direcciones estticas finales.
Otro tipo de proyecto que se puede crear es el de aplicacin GTK+. Una aplicacin GTK+ es un programa escrito en lenguaje de programacin C que realiza llamadas a bibliotecas o rutinas GTK (GIMP Toolkit) para desarrollar interfaces grficas de usuario (GUI). La gran ventaja de GTK+ es que es multiplataforma por lo que se pueden escribir programas en plataforma Windows y que stos sean portables a plataforma Linux, por ejemplo. Adems, GTK+ es software libre (bajo la licencia LGPL) y parte importante del proyecto GNU, que tiene por objetivo la creacin de un sistema operativo completamente libre: el sistema GNU.
El ltimo tipo de proyecto que se puede crear es el de aplicacin wxWindows (actualmente wxWidgets). Una
aplicacin wxWindows es un programa escrito en lenguaje de programacin C++ que realiza llamadas a bibliotecas o rutinas wxWindows (wxWidgets) para desarrollar interfaces grficas de usuario (GUI). Al igual que GTK+, wxWindows tambin es multiplataforma y
- 29 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. software libre (bajo la licencia LGPL). Hay que resaltar que el compilador MinGW Developer Studio fue publicado en el ao 2002, un ao antes de que Microsoft interpusiera una demanda contra wxWindows por una posible confusin con el nombre de su sistema operativo. Desde entonces, wxWindows recibe el nombre de wxWidgets. Las wxWidgets proporcionan una interfaz grfica basada en las bibliotecas ya existentes en el sistema (nativas), con lo que se integran de forma ptima y resultan muy portables entre distintos sistemas operativos. El 22 de Abril de 2005 fue incluida la versin 2.6 de wxWidgets en la versin 2.05 de MinGW Developer Studio.
Adems de los tipos de proyecto citados anteriormente existen cuatro tipos de ficheros que se pueden crear mediante MinGW Developer Studio: C/C++ Source File (fichero fuente C/C++), C/C++ Header File (fichero de cabecera C/C++), Resource Script (script de recurso) y Text File (fichero de texto).
El fichero C/C++ Source File es un fichero que contiene el cdigo fuente del programa escrito en lenguaje de programacin C o C++ y que aparecer en la carpeta Source Files de la zona de workspace. Este fichero puede tener extensin *.c, *.cc, *.cpp o *.cxx. El fichero C/C++ Header File, sin embargo, es un fichero, a menudo en cdigo fuente, que es incluido automticamente en otro fichero fuente (source file) por parte del compilador. Tpicamente, los ficheros de cabecera son incluidos en otro fichero fuente por medio de directivas del compilador al comienzo (o cabecera) de ste. Un fichero de cabecera contiene normalmente declaraciones de subrutinas (funciones), variables y otros identificadores. Los identificadores que necesitan ser declarados en ms de un fichero fuente pueden declararse en un fichero de cabecera que ser incluido posteriormente cuando su contenido sea requerido. Este
- 30 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. fichero aparecer en la carpeta Header Files de la zona de workspace y tendr extensin *.h, *.hh, *.hpp o *.hxx.
Por otra parte, el fichero Resource Script contiene declaraciones que definen todos los elementos que sern incluidos en el fichero binario de recursos compilado (compiled binary resource file). Cada declaracin describe un elemento de recurso (resource item), identificado por un ID, y parmetros adicionales (que varan en funcin del tipo de recurso). Un resource script puede incluso referenciar un resource item que est almacenado en un fichero independiente, como un bitmap o un icono. Este fichero aparecer en la carpeta Resource Files de la zona de workspace y tendr extensin *.rc o *.rc2.
Por ltimo, el fichero Text File contiene comentarios, informacin administrativa (versin, desarrollador/es, fecha, etc.) y cualquier otra informacin que se quiera adjuntar al proyecto. Este fichero aparecer en la carpeta Other Files de la zona de workspace y tendr extensin *.txt.
o Open: Puede activarse tambin pulsando simultneamente las teclas Ctrl y O. Esta opcin permite abrir un fichero de los siguientes tipos: C/C++ Files incluye Source Files, Header Files y Resource Files (extensiones *.c, *.cc, *.cpp, *.cxx, *.h, *.hh, *.hpp, *.hxx, *.rc y *.rc2), Text Files (extensin *.txt), MinGWStudio Project Files (extensin *.msp o *.mdsp) y cualquier otro fichero con extensin vlida para ser abierta por el software. A continuacin se muestra una captura de la ventana que aparece al pulsar la opcin Open y que permite seleccionar el fichero a abrir.
- 31 -
o Close: Esta opcin cierra el fichero que se encuentre activo en la zona de edicin. Es decir, de entre todos los ficheros que pueden encontrarse abiertos simultneamente en la zona de edicin y que se visualizan por medio de pestaas en la parte superior cierra el fichero que se est visualizando. La opcin Close se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin.
o Close All: Esta opcin cierra todos los ficheros que se encuentren abiertos simultneamente y que se visualizan por medio de pestaas en la parte superior de la zona de edicin. La opcin Close All se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin.
o Save: Puede activarse tambin pulsando simultneamente las teclas Ctrl y S. Esta opcin guarda los cambios efectuados en el fichero que se encuentre activo en la zona de edicin. El fichero modificado es guardado en el directorio del proyecto donde se encuentra ubicado si bien la opcin Save As que se ver a continuacin permite guardarlo en otra ubicacin diferente. La opcin Save se encontrar desactivada si no se ha realizado cambio alguno en el fichero desde su ltimo guardado o bien si no hay ningn fichero abierto en la zona de edicin.
- 32 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Save As: Esta opcin guarda los cambios efectuados en el fichero que se encuentre activo en la zona de edicin en una ubicacin que se debe especificar. Esta opcin permite, por tanto, guardar el fichero en otra ubicacin diferente a la del directorio del proyecto as como renombrarlo. Una vez pulsada esta opcin se muestra un cuadro de dilogo en el que se solicita la confirmacin del guardado. Si se pulsa S (en cualquier otro caso se renuncia a guardar los cambios) aparecer entonces un segundo cuadro de dilogo en el que se puede especificar el directorio en el que se quiere guardar el fichero, la extensin que se le quiere dar y el nombre. La opcin Save As se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin. A continuacin se muestran los cuadros de dilogo que aparecen al pulsar sobre esta opcin e intentar guardar un fichero de cabecera.
- 33 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Save All: Esta opcin guarda todos los cambios efectuados en los ficheros que se encuentren abiertos y que aparezcan en las pestaas en la parte superior de la zona de edicin. La opcin Save All se encontrar desactivada si no se ha realizado cambio alguno en los ficheros abiertos desde la ltima vez que se produjo el guardado de los mismos o bien si no hay ningn fichero abierto en la zona de edicin. Si alguno de ellos ha sido modificado, entonces la opcin Save All llevar a cabo el guardado de todos ellos a pesar de que algunos no haban sido modificados. La nica condicin, por tanto, para que la opcin se encuentre activa es que al menos uno de los ficheros abiertos haya sufrido cambios desde la ltima vez que se produjo su guardado. En tal caso el resultado de esta opcin ser el mismo que con la opcin Save.
o Export (to HTML): Esta opcin permite pasar a formato HTML (HyperText Markup Language) el fichero que se muestre en la zona de edicin y cuyo nombre se visualizar en la pestaa activa en la parte superior de dicha zona. Esta funcin es de gran utilidad dado que HTML es el lenguaje de marcado predominante para la construccin de pginas Web. Es usado para describir la estructura y el contenido en forma de texto, as como para complementar el texto con objetos tales como imgenes. Adems de permitir la conversin a formato HTML tambin permite especificar la ubicacin donde se quiere guardar el fichero ya convertido. La opcin Export se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin. A continuacin se muestra una captura del cuadro de dilogo que permite la conversin a formato HTML as como del fichero HTML resultante.
- 34 -
o Page Setup: Esta opcin permite configurar las opciones de pgina para la impresin y est muy relacionada con la opcin Print que se explicar en el siguiente punto. Esta opcin permite ajustar el papel a utilizar (tamao y origen), la orientacin (vertical u horizontal) y los mrgenes de pgina (izquierdo, derecho, superior e inferior). Adems, permite seleccionar la impresora a utilizar para la impresin y ajustar sus propiedades pulsando el botn Impresora. Por ltimo, se permite - 35 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. seleccionar para la impresin una impresora de la red (por defecto Red de Microsoft Windows) pulsando el botn Red dentro del cuadro que aparece al pulsar Impresora. La opcin Page Setup se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin. A continuacin se muestran los cuadros que aparecen al pulsar la opcin Page Setup, al pulsar el botn Impresora y al pulsar el botn Red.
- 36 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Print: Puede activarse tambin pulsando simultneamente las teclas Ctrl y P. Esta opcin permite imprimir el fichero que aparece en la zona de edicin. Al pulsarla aparece el cuadro de impresin de Microsoft Windows donde se pueden especificar aspectos como el nmero de copias a imprimir, las preferencias de impresin, el intervalo de pginas a imprimir, etc. La opcin Print se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin. A continuacin se muestra el cuadro de impresin que aparece al pulsar esta opcin.
o Print Preview: Esta opcin permite la previsualizacin de pgina antes de su impresin. Al pulsarla aparece una nueva ventana titulada
MinGWStudio Preview que permite visualizar el documento que se imprimira en caso de pulsar la opcin Print. Adems, esta ventana permite invocar a la opcin Print directamente por medio del botn Print situado en la parte superior de forma que no hay que cerrar la ventana y pulsar la opcin desde el men File. El botn Close cierra la ventana de previsualizacin mientras que los cuatro botones de direccin permiten (de izquierda a derecha) ir a la primera pgina, retroceder, avanzar e ir a la ltima pgina respectivamente. Por ltimo, la combo box situada en la parte derecha permite ajustar el zoom de visualizacin de pgina (desde
- 37 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. 10% hasta 200%). La opcin Print Preview se encontrar desactivada si no hay ningn fichero abierto en la zona de edicin. A continuacin se muestra una captura de la ventana MinGWStudio Preview que aparece al pulsar la opcin Print Preview.
o Recent Files: Esta opcin muestra los ficheros que han sido abiertos ms recientemente de forma que se facilita su rpida apertura sin necesidad de buscarlos en el directorio y abrirlos con la opcin Open. Los ficheros se muestran ordenados por orden de visualizacin (el ms reciente ser el nmero 1 y el ms antiguo ser el ltimo nmero). El mximo nmero de ficheros recientes que mostrar esta opcin es nueve. El fichero ms reciente ser denotado por el nombre y su extensin mientras que los ficheros restantes mostrarn tambin su ruta de acceso. A continuacin se muestra una captura de la opcin Recent Files.
- 38 -
o Recent Projects: Esta opcin presenta la misma funcionalidad que la opcin Recent Files en el punto anterior si bien esta opcin se refiere a proyectos en vez de a ficheros. Permite, por tanto, ver los proyectos que han sido abiertos ms recientemente. La nica diferencia que presenta respecto de la opcin Recent Files es que en este caso todos los proyectos recientes muestran la ruta de acceso adems del nombre del proyecto con su correspondiente extensin (*.msp o *.mdsp). A continuacin se muestra una captura de la opcin Recent Projects.
o Exit: Puede activarse tambin pulsando simultneamente las teclas Alt y X. Esta opcin cierra la aplicacin. En el caso de que exista un proyecto abierto y alguno o varios de sus ficheros presenten cambios entonces la aplicacin preguntar si se desean guardar cada uno de los ficheros que han sido modificados. A continuacin se muestra una captura del cuadro que presenta la aplicacin en caso de que un fichero presente cambios.
- 39 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Edit: Consta de diecisis opciones como son Undo (Deshacer), Redo (Rehacer), Cut (Cortar), Copy (Copiar), Paste (Pegar), Select All (Seleccionar todo), Find (Buscar), Find Next (Buscar siguiente), Find Previous (Buscar anterior), Find in Files (Buscar en ficheros), Replace (Reemplazar), Match Brace (Encontrar llave), Go To (Ir a), Advanced (Avanzado), File Format (Formato de fichero) y Options (Opciones).
o Undo: Puede activarse tambin pulsando simultneamente las teclas Ctrl y Z. Esta opcin permite deshacer todos los pasos dados desde la ltima vez que se guard el fichero. Esta opcin se encuentra desactivada si no hay ningn proyecto abierto o si hay un proyecto abierto y ninguno de sus ficheros ha sido modificado. o Redo: Puede activarse tambin pulsando simultneamente las teclas Ctrl e Y. Esta opcin permite rehacer la ltima accin realizada as como acciones que se han deshecho por medio de la opcin Undo explicada anteriormente. Esta opcin se encuentra desactivada si no hay ningn proyecto abierto o si hay un proyecto abierto y ninguno de sus ficheros ha sido modificado y luego se ha pulsado la opcin Undo.
o Cut: Puede activarse tambin pulsando simultneamente las teclas Ctrl y X. Esta opcin se aplica sobre trozos de cdigo o texto, ahorrando gran trabajo cuando se quieren desplazar dichos trozos de un lugar a otro. El primer paso a la hora de cortar un texto es seleccionarlo para indicarle al programa sobre qu texto se quiere ejecutar la accin. Cuando se aplica esta opcin sobre un texto, ste desaparece del lugar de origen. Para depositarlo en otro sitio se utiliza la opcin Paste que se explicar posteriormente. Una vez que un texto se ha cortado permanece en la memoria mientras no se copie o corte otra cosa. Esta opcin se encuentra desactivada si no hay ningn proyecto abierto o si hay un proyecto abierto y no ha sido seleccionado texto alguno. - 40 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Copy: Puede activarse tambin pulsando simultneamente las teclas Ctrl y C. Esta opcin, al igual que la anterior, se aplica sobre trozos de cdigo o texto y permite repetir sentencias de cdigo, bucles, etc. Al igual que en el caso anterior, el primer paso es seleccionar el texto a copiar. El texto copiado no desaparece del lugar de origen, pero el ordenador ha creado una copia de l. Para depositarlo en otro sitio se utiliza la opcin Paste que se explicar posteriormente. Una vez que un texto se ha copiado permanece en la memoria mientras no se copie o corte otra cosa. As, si se necesita volver a pegar ese mismo texto no hace falta volver a copiar. Esta opcin se encuentra desactivada si no hay ningn proyecto abierto o si hay un proyecto abierto y no ha sido seleccionado texto alguno.
o Paste: Puede activarse tambin pulsando simultneamente las teclas Ctrl y V. Esta opcin permite pegar el texto copiado o cortado y del cual el ordenador ha creado una copia que permanece en la memoria mientras no se copie o corte otra cosa. Esta opcin se encuentra desactivada si no hay ningn proyecto abierto o si hay un proyecto abierto y no ha sido copiado o cortado texto alguno.
o Select All: Puede activarse tambin pulsando simultneamente las teclas Ctrl y A. Esta opcin permite seleccionar todo el texto del fichero que se encuentre abierto en la zona de edicin. Esta opcin se encuentra desactivada si no hay ningn fichero en la zona de edicin.
o Find: Puede activarse tambin pulsando simultneamente las teclas Ctrl y F. Esta opcin permite buscar palabras y frases en el fichero que se encuentre abierto en la zona de edicin. A continuacin se muestra una captura del cuadro que aparece al pulsar sobre esta opcin y que ayudar en la explicacin.
- 41 -
En el cuadro de texto Find what hay que escribir la palabra o frase a buscar. La caja Direction permite seleccionar si la bsqueda a realizar va a ser de abajo a arriba desde la posicin actual (seleccionada opcin Up) o de arriba abajo (seleccionada opcin Down) en el texto. La checkbox Match whole word only permite especificar que solo se presenten los resultados de palabras que coincidan exactamente con la palabra a buscar y que no est contenida o sea parte de otra. La checkbox Match case permite presentar resultados independientemente de si stos estn en maysculas o en minsculas. Por ltimo, la checkbox Wrap around, que por defecto se encuentra activada, permite reanudar la bsqueda desde el principio una vez que sta ha llegado al final. Acta, por tanto, de forma circular. Una vez que se ha introducido la palabra o frase a buscar y se han activado las opciones que interesen se pulsa el botn Find Next que sombrear en el propio texto de la zona de edicin el resultado de la bsqueda (match). Si el resultado no es el que se buscaba se pulsar de nuevo el botn Find Next para reanudarla y as sucesivamente hasta encontrar el resultado esperado. La opcin Find se encuentra desactivada si no hay ningn fichero en la zona de edicin. o Find Next: Puede activarse tambin pulsando la tecla F3. Esta opcin permite ver el siguiente resultado de la bsqueda efectuada con la opcin Find. Su funcionamiento es igual al del botn Find Next que aparece en el cuadro de bsqueda de la opcin Find explicado anteriormente. En caso de que se pulse sobre la opcin Find Next sin haber iniciado una bsqueda se ejecutar la opcin Find. La opcin Find Next se encuentra desactivada si no hay ningn fichero en la zona de edicin.
- 42 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Find Previous: Puede activarse tambin pulsando simultneamente las teclas Shift y F3. Esta opcin permite ver el resultado anterior de la bsqueda efectuada con la opcin Find. Su funcionamiento es igual al de la opcin Find Next con la diferencia de que se muestra el resultado anterior en vez del resultado siguiente. En caso de que se pulse sobre la opcin Find Previous sin haber iniciado una bsqueda se ejecutar la opcin Find. La opcin Find Previous se encuentra desactivada si no hay ningn fichero en la zona de edicin.
o Find in Files: Esta opcin permite buscar palabras o frases en ficheros con extensiones soportadas por MinGW Developer Studio y que se encuentren en cualquier directorio. Para ello se muestra un cuadro de bsqueda que permite especificar la palabra o frase a buscar, la extensin de los ficheros en los que se quiere buscar (*.c, *.cc, *.cpp, *.cxx, *.h, *.hh, *.hpp, *.hxx, *.rc, *.rc2, *.def, *.htm, *.html, *.txt, *.*) y el directorio en el que se quiere buscar. Adems, muestra tres checkboxes que permiten especificar propiedades de bsqueda. Las checkboxes Match whole Word only y Match case ya han sido explicadas en la opcin Find y sus funciones son las mismas. La checkbox Look in subfolders est activada por defecto y permite realizar la bsqueda en subcarpetas del directorio especificado en la pestaa In folder. El resultado de la bsqueda ser mostrado en la pestaa Find in Files de la zona de salida. A continuacin se muestra una captura del cuadro de bsqueda de la opcin Find in Files.
- 43 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Replace: Puede activarse tambin pulsando simultneamente las teclas Ctrl y H. Esta opcin permite reemplazar una palabra o frase por otra que se debe especificar. La palabra o frase a reemplazar se escribe en el cuadro de texto Find what mientras que la palabra o frase que la reemplace se escribe en el cuadro Replace with. Las tres checkboxes y sus funciones ya han sido explicadas en la opcin Find mientras que el cuadro Replace in permite realizar el reemplazo en todo el fichero (opcin Whole file, que est activada por defecto) o solo en una parte de l que debe ser seleccionada (opcin Selection). El botn Find Next ya ha sido explicado anteriormente, mientras que el botn Replace ejecuta un nico reemplazo frente a Replace All que reemplaza todos los resultados de la bsqueda simultneamente. La opcin Replace se encuentra desactivada si no hay ningn fichero en la zona de edicin.
o Match Brace: Puede activarse tambin pulsando simultneamente las teclas Ctrl y B. Esta opcin permite localizar la llave inicial ({) o final (}) de un bloque de cdigo. Esto es especialmente til en programas con un gran nmero de lneas de cdigo para localizar el comienzo o el fin de funciones, bucles (for, while, do-while), bloques if-else, switch, etc. Para localizar el inicio/fin de un bloque de cdigo hay que situarse en la llave final (})/inicial ({) y ejecutar la opcin. La opcin Match brace se encuentra desactivada si no hay ningn fichero en la zona de edicin.
- 44 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Go To: Puede activarse tambin pulsando simultneamente las teclas Ctrl y G. Esta opcin permite ir directamente a una lnea de cdigo determinada que se debe especificar en un cuadro de dilogo que aparece al ejecutar la opcin. La opcin Go to se encuentra desactivada si no hay ningn fichero en la zona de edicin. A continuacin se muestra una captura del cuadro que aparece al ejecutar la opcin Go to.
o Advanced: Esta opcin permite realizar cuatro acciones diferentes sobre un fragmento de cdigo que se debe seleccionar. La primera opcin se llama Make Selection C style comment y convierte el fragmento seleccionado a estilo de comentario en lenguaje de programacin C, es decir, el fragmento precedido de /* y con */ al final. Esta opcin tambin puede ejecutarse pulsando simultneamente las teclas Ctrl e Insert. La segunda opcin se llama Make Selection C++ style comment y convierte el fragmento seleccionado a estilo de comentario en lenguaje de programacin C++, es decir, el fragmento con // en cada lnea. Esta opcin tambin puede ejecutarse pulsando simultneamente las teclas Ctrl, Shift e Insert. La tercera opcin se llama Make Selection Uppercase y convierte el fragmento seleccionado a maysculas. Esta opcin tambin puede ejecutarse pulsando simultneamente las teclas Ctrl, Shift y U. La ltima opcin se llama Make Selection Lowercase y convierte el fragmento seleccionado a minsculas. Esta opcin tambin puede ejecutarse pulsando simultneamente las teclas Ctrl y U. La opcin Advanced se encuentra desactivada si no hay ningn fichero en la zona de edicin. A continuacin se muestra una captura de las acciones posibles de la opcin Advanced.
- 45 -
o File Format: Esta opcin permite codificar el fichero que se encuentre en la zona de edicin de tal forma que sea portable a Windows, UNIX y Macintosh por medio de tres opciones especficas: Windows (CR/LF), UNIX (LF) y Macintosh (CR). Al editar ficheros en MinGW Developer Studio y guardarlos, las lneas se terminan con la combinacin de caracteres CR/LF, que significan retorno de carro/avance o fin de lnea. Esto se produce en sistemas Windows mientras que en sistemas UNIX se terminan slo con avance de lnea. En sistemas Macintosh, por otro lado, terminan slo con retorno de carro. Esta opcin, por tanto, favorece la portabilidad de ficheros entre los tres tipos de sistemas ms utilizados. La opcin File Format se encuentra desactivada si no hay ningn fichero en la zona de edicin.
o Options: Esta opcin permite modificar una serie de parmetros agrupados en ocho categoras: Project (Proyecto), Editor (Editor), Tabs (Tabulaciones), Compiler (Compilador), Build (Construir), Directories (Directorios), Help (Ayuda) y Format (Formato).
La categora Project permite cargar el ltimo proyecto abierto cuando se inicia el programa y cargar los documentos asociados a un proyecto cuando ste se abre.
- 46 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. La categora Editor permite modificar opciones de guardado de ficheros, opciones de autocompletado, opciones de pestaas en la visualizacin de ficheros y opciones de impresin.
La categora Tabs permite modificar parmetros relativos a las tabulaciones del texto de la zona de edicin. Se puede modificar el espaciado, el sangrado, insertar espacios, mantener tabulaciones, realizar un sangrado automtico, etc.
La categora Compiler permite especificar el directorio que utiliza el programa (MinGW path) y donde se encuentran los ficheros de librera (carpeta lib), los ficheros de include (carpeta include), los ficheros de recursos (carpeta include), etc.
La categora Build permite guardar un fichero automticamente antes de ser compilado y ejecutado cuando se pulsa la opcin Build. Adems, permite escribir siempre las dependencias cuando se escribe un fichero Makefile. Este fichero se compone de un conjunto de dependencias y reglas. Una dependencia tiene un fichero objetivo (target), que es el fichero a crear, y un conjunto de ficheros fuente de los cuales depende el fichero objetivo. Una regla describe cmo crear el fichero objetivo a partir de los ficheros de los que ste depende.
La categora Directories muestra los directorios donde se encuentran los ficheros de include (Include files), los ficheros de librera (Library files) y los ficheros de recursos (Resource files). Adems, permite modificar estos directorios mediante una serie de botones que permiten eliminar el directorio actual y buscar manualmente el directorio nuevo.
La categora Help muestra los directorios donde se encuentran los ficheros de ayuda de win32 y de wxWindows as como modificar dichos
- 47 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. directorios. Adems, permite especificar que las sugerencias (Call tips) se muestren segn el estndar ANSI C y la API de Windows (WinAPI).
La categora Format permite modificar opciones de estilo de texto en la zona de edicin y en la zona de salida. Se permite modificar el tamao del texto, la fuente, el color (del texto, del fondo, del sombreado de errores,) y el estilo de fuente (negrita, cursiva y subrayado). Estos cambios pueden visualizarse en el propio cuadro de opciones gracias a la ventana Sample que muestra el resultado de los cambios en caso de que stos se lleven a cabo.
A continuacin se muestra una captura del cuadro Options en la categora Format.
- 48 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. View: Consta de once opciones como son Toolbar (Barra de herramientas), Status Bar (Barra de estado), Toggle Current Fold (Ocultar bloque actual), Toggle All Folds (Ocultar todos los bloques), End Of Line (Fin de Lnea), Line Numbers (Nmeros de Lnea), Indentation Guides (Guas de sangrado), Margin (Margen), Fold Margin (Margen de bloque), Project Window (Ventana de Proyecto) y Output Window (Ventana de Salida). o Toolbar: Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) la barra de herramientas, que se explicar en el apartado 4.2.2 Barra de herramientas. o Status Bar: Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) la barra de estado. Esta barra est situada debajo de la zona de salida y est dividida en dos zonas diferenciadas.
Una zona muy amplia situada en el lado izquierdo muestra informacin acerca de la accin que realiza cada una de las opciones de los mens cuando el cursor se encuentra situado sobre cada opcin. La segunda zona est situada en el lado derecho y muestra el nmero de lnea y columna en el que se encuentra el cursor en la zona de edicin as como el modo de teclado activo (INS/OVR) (insercin/sobreescritura).
o Toggle Current Fold: Cuando se explic la zona de edicin se deca que se pueden ocultar bloques de cdigo independientes como declaraciones de estructuras, funciones, bloques if-else, bloques while o do-while, bloques for o incluso la propia funcin principal (main). Pues bien, la opcin Toggle Current Fold permite ocultar o mostrar estos bloques de cdigo independientes. Para ello hay que situar el cursor al comienzo del bloque (a la derecha del smbolo de minimizar/maximizar) y pulsar sobre esta opcin. Si el bloque est oculto se mostrar, mientras que si se
- 49 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. estaba mostrando se ocultar. Esta opcin se encuentra desactivada si no hay ningn fichero en la zona de edicin.
o Toggle All Folds: Esta opcin permite ocultar todos los bloques de cdigo independientes tal y como se ha explicado en la opcin anterior. La nica diferencia que presenta respecto de dicha opcin es que no influye la situacin del cursor a la hora de ejecutar la accin puesto que todos los bloques sern ocultados/mostrados. Esta opcin se encuentra
desactivada si no hay ningn fichero en la zona de edicin.
o End of Line: Esta opcin permite visualizar el fin o avance de lnea (LF) y el retorno de carro (CR) en cada una de las lneas del fichero que se encuentra en la zona de edicin. El avance de lnea y el retorno de carro ya fueron explicados en la opcin File Format del men Edit.
o Line Numbers: Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) los nmeros de lnea que se encuentran a la izquierda del fichero cargado en la zona de edicin.
o Indentation Guides: Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) los puntos suspensivos azules situados en cada tabulacin que ayudan a ordenar el cdigo para facilitar su seguimiento y a localizar el inicio y fin de bloques if-else, do-while, while, bucles for, etc.
o Margin: Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) el margen situado entre los nmeros de lnea y el cdigo del fichero cargado en la zona de edicin.
o Fold Margin: Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) el margen y la llave de seguimiento situados en los bloques de cdigo independientes ya explicados. El margen y la llave de
- 50 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. seguimiento permiten una rpida localizacin de dichos bloques por lo que no es recomendable su ocultacin.
o Project Window: Puede activarse tambin pulsando simultneamente las teclas Alt y 0. Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) la zona de workspace.
o Output Window: Puede activarse tambin pulsando simultneamente las teclas Alt y 2. Esta opcin permite mostrar (opcin activada) o esconder (opcin desactivada) la zona de salida.
- 51 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Project: Consta de siete opciones como son New Project (Nuevo Proyecto), Open Project (Abrir Proyecto), Save Project (Guardar Proyecto), Close Project (Cerrar
Proyecto), Add To Project (Aadir al Proyecto), Settings (Ajustes) y Export Makefile (Exportar fichero Makefile).
o New Project: Puede activarse tambin pulsando simultneamente las teclas Ctrl y N. Esta opcin presenta el mismo comportamiento que la opcin New del men File ya explicado y se encuentra activada si no hay ningn proyecto en la zona de workspace.
o Open Project: Esta opcin permite abrir un abrir un fichero de proyecto MinGWStudio Project Files (extensin *.msp o *mdsp). Esta opcin se encuentra activada si no hay ningn proyecto en la zona de workspace. A continuacin se muestra una captura de la ventana que aparece al pulsar la opcin y que permite seleccionar el proyecto a abrir.
o Save Project: Esta opcin permite guardar los cambios realizados en la configuracin del proyecto mediante la opcin Settings que se explicar posteriormente y que forma parte de este men. Esta opcin no guarda cambios realizados en los ficheros del proyecto.
- 52 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Close Project: Esta opcin cierra el proyecto que se encuentre abierto en la zona de workspace. Antes de cerrar el proyecto aparece un cuadro de confirmacin de cierre de proyecto. Adems, en caso de que alguno de los ficheros del proyecto haya sido modificado aparecer un segundo cuadro que preguntar acerca de la posibilidad de guardar los cambios realizados.
o Add To Project: Esta opcin permite aadir al proyecto ficheros de proyecto u otro tipo de ficheros. Para ello, existen dos opciones diferentes que se muestran en un submen: New y Files. New presenta el mismo comportamiento que la opcin New Project de este mismo men y que la opcin New del men File. Por otra parte, el submen Files permite aadir ficheros al proyecto. Estos ficheros pueden tener cualquiera de las extensiones soportadas por el programa y que fueron explicadas en la opcin Open del men File.
o Settings: Esta opcin permite establecer una serie de propiedades del proyecto agrupadas en cuatro categoras: General (General), Compile (Compilar), Link (Enlazar) y Resources (Recursos).
La categora General permite escribir datos relativos al directorio de trabajo, a los argumentos del programa y a los directorios de ficheros de salida (tanto intermedios como de salida).
La
categora
Compile
permite
escribir
definiciones
del
preprocesador, opciones extra de compilacin y directorios adicionales de include. Adems, permite especificar opciones adicionales relativas a warnings, informacin de Debugging (depuracin), niveles de optimizacin y lenguaje C++ (informacin en tiempo de ejecucin y gestin de excepciones). A continuacin se muestra una captura del cuadro Project Settings en la categora General, que es la que aparece por defecto al pulsar sobre la opcin Settings.
- 53 -
o Export Makefile: Esta opcin crea un fichero Makefile a partir del fichero que se encuentre abierto en la zona de edicin. El fichero Makefile ya fue explicado al detallar la categora Build del submen Options del men Edit. El fichero Makefile aparecer en el mismo directorio del proyecto una vez que se pulsa esta opcin. A continuacin se muestra una captura del fichero Makefile creado a partir de un fichero.
- 54 -
- 55 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Build: Consta de diez opciones como son Compile (Compilar), Build (Construir), Rebuild All (Reconstruir todo), Build All Configurations (Construir todas las configuraciones), Build and Execute (Construir y Ejecutar), Clean (Limpiar), Clean All Configurations (Limpiar todas las configuraciones), Stop (Parar), Execute (Ejecutar) y Set Active activa).
Configuration
(Establecer
configuracin
Ninguna de estas opciones estar activa a menos que haya un proyecto en la zona de workspace. En tal caso estarn todas las opciones activas menos Compile que requiere que haya un fichero abierto en la zona de edicin y Stop que slo estar activa durante el tiempo que se est llevando a cabo alguna de las acciones situadas por encima de ella en el men.
o Compile: Puede activarse tambin pulsando simultneamente las teclas Ctrl y F7. Esta opcin permite compilar el fichero que se encuentre abierto en la zona de edicin. Los mensajes que aparecen en la zona de salida ya se explicaron cuando se coment dicha zona.
o Build: Puede activarse tambin pulsando la tecla F7. Esta opcin permite compilar y enlazar el fichero que se encuentre abierto en la zona de edicin. Los mensajes que aparecen en la zona de salida ya se explicaron cuando se coment dicha zona.
o Rebuild All: Esta opcin compila y enlaza el fichero que se encuentre abierto en la zona de edicin tras eliminar los ficheros intermedios y ficheros de salida generados en anteriores compilaciones, enlazados y ejecuciones con la configuracin Debug que se explicar en el siguiente punto. Una vez ejecutada, se habr creado la carpeta Debug en el directorio del proyecto y contendr el fichero con extensin *.o generado tras la compilacin y el fichero con extensin *.exe generado tras el enlazado.
- 56 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Build All Configurations: Un proyecto de MinGW tiene configuraciones diferentes para las versiones de lanzamiento (Release) y de depuracin (Debug) del programa. Como sus nombres indican, la versin Debug se construye para depuracin mientras que la versin Release se construye para la distribucin final del programa en su lanzamiento. Si se crea un programa con MinGW, ste crea automticamente las configuraciones y establece opciones apropiadas por defecto y otros ajustes. Con las opciones por defecto:
La
configuracin
Debug
del
programa
es
compilada
con
informacin simblica de depuracin y sin optimizacin. La optimizacin complica la depuracin porque la relacin entre el cdigo fuente y las instrucciones generadas es de mayor complejidad. La configuracin Release del programa est completamente optimizada y no contiene informacin simblica de depuracin.
Una vez explicadas las dos configuraciones posibles, la opcin Build All Configurations crea ambas configuraciones en el directorio del proyecto. En dicho directorio aparecen, por tanto, la carpeta Debug y la carpeta Release con sus respectivas configuraciones. Si no se pulsa esta opcin, el compilador crear nicamente la versin Debug, que es la establecida por defecto.
o Build
and
Execute:
Esta
opcin
construye
el
programa
(ver
comportamiento de la opcin Build explicada anteriormente) y lo ejecuta. Por tanto, compila, enlaza y ejecuta el fichero que se encuentre abierto en la zona de edicin. En caso de que la compilacin o el enlazado presenten errores la ejecucin se suspender y aparecer un cuadro con el mensaje Cannot execute program (No se puede ejecutar el programa).
- 57 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Clean: Esta opcin borra los ficheros intermedios y los ficheros de salida generados con la configuracin Debug. Elimina, por tanto, la carpeta Debug del directorio del proyecto.
o Clean All Configurations: Esta opcin borra los ficheros intermedios y los ficheros de salida generados con las configuraciones Debug y Release. Elimina, por tanto, las carpetas Debug y Release del directorio del proyecto.
o Stop: Esta opcin permite parar la ejecucin de las acciones situadas por encima de ella en el men Build. Permite, por tanto, parar la ejecucin de las opciones Compile, Build, Rebuild All, Build All Configurations, Build and Execute, Clean y Clean All Configurations una vez que alguna de ellas haya sido pulsada y sin que haya terminado la ejecucin de la tarea que realiza.
o Execute: Puede activarse tambin pulsando simultneamente las teclas Ctrl y F5. Esta opcin ejecuta el programa (el fichero *.exe generado tras el enlazado en la carpeta Debug del directorio del proyecto). En caso de que el programa no haya sido compilado o enlazado, MinGW desplegar un cuadro informando acerca de la situacin (The target is out of date) y preguntando si se quiere realizar el compilado y enlazado. Este cuadro se muestra a continuacin.
o Set Active Configuration: Esta opcin permite seleccionar la configuracin (Debug o Release) de la versin del proyecto. La configuracin por defecto es Debug. Ambas configuraciones ya fueron explicadas anteriormente (ver opcin Build All Configurations). - 58 -
Debug: Este men ser explicado posteriormente en el apartado 5.1 Men Debug del captulo 5.
- 59 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Tools: Consta de una nica opcin como es Resource Editor (Editor de recursos).
o Resource Editor: Puede activarse tambin pulsando simultneamente las teclas Ctrl y R. Esta opcin abre el editor de recursos. El editor de recursos permite crear ficheros resource script (extensin *.rc) de forma rpida e intuitiva. El editor cuenta con una interfaz grfica muy cmoda para disear el aspecto de ventanas, iconos, botones, barras de herramientas y otros muchos tipos de recursos grficos. Hay que recordar que los ficheros *.rc son empleados por GTK+ (GIMP Tool Kit) para tratar las opciones
predeterminadas de las aplicaciones. Con ellos se pueden cambiar los colores de cualquier control, poner un dibujo de fondo, etc. GTK+ es un grupo importante de bibliotecas o rutinas para desarrollar interfaces grficas de usuario (GUI) mediante C, C++ y otros lenguajes de programacin. A continuacin se muestra una captura del editor de recursos.
- 60 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Window: Consta de ocho opciones como son Close (Cerrar), Close All (Cerrar todo), Cascade (Cascada), Tile Horizontally (Mosaico Horizontal), Tile Vertically (Mosaico Vertical), Arrange Icons (Ordenar iconos), Next (Siguiente) y Previous (Anterior). Adems, a continuacin de las ocho opciones muestra el nombre de los ficheros que se encuentran abiertos ordenados de arriba hacia abajo en orden de apertura (el primero ser el que se abri primero y el ltimo ser el que se abri ms recientemente). Adems, a la izquierda del fichero que se encuentre abierto en la zona de edicin se mostrar el smbolo indicando dicha situacin.
o Close: Esta opcin cierra el fichero que se encuentre abierto en la zona de edicin. Adems, elimina su correspondiente pestaa de la zona superior de la zona de edicin y la entrada con su nombre en el men Window.
o Close All: Esta opcin cierra todos los ficheros abiertos. Adems, elimina sus correspondientes pestaas de la zona superior de la zona de edicin y las entradas con sus nombres en el men Window. Como resultado, la zona de edicin queda en color gris al igual que al iniciar la aplicacin.
o Cascade: Esta opcin permite visualizar los ficheros abiertos en cascada dentro de la zona de edicin tal y como se muestra a continuacin.
- 61 -
o Tile Horizontally: Esta opcin permite visualizar los ficheros abiertos en mosaico horizontal dentro de la zona de edicin tal y como se muestra a continuacin.
- 62 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Tile Vertically: Esta opcin permite visualizar los ficheros abiertos en mosaico vertical dentro de la zona de edicin tal y como se muestra a continuacin.
o Arrange Icons: Esta opcin permite ordenar las ventanas que se encuentren minimizadas en la zona de edicin. Si varias ventanas se encuentran minimizadas en la zona de edicin tras visualizarlas mediante mosaico horizontal, vertical o cascada esta opcin permite ordenarlas en el mismo orden en que fueron minimizadas. De esta forma se sitan los iconos de las ventanas ordenados en la parte inferior izquierda de la zona de edicin. o Next: Esta opcin permite activar el fichero (la ventana) siguiente al que se encuentra activo en los modos de visualizacin en cascada, mosaico horizontal y mosaico vertical. De este modo, se activa la siguiente ventana y el cursor se sita donde se haba quedado la ltima vez que dicho fichero estuvo activo. Si nunca lo estuvo, se situar al comienzo del fichero.
- 63 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Previous: Esta opcin permite activar el fichero (la ventana) anterior al que se encuentra activo en los modos de visualizacin en cascada, mosaico horizontal y mosaico vertical. De este modo, se activa la ventana anterior y el cursor se sita donde se haba quedado la ltima vez que dicho fichero estuvo activo. Si nunca lo estuvo, se situar al comienzo del fichero.
- 64 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Help (About MinGW Developer Studio): Esta opcin abre un cuadro de dilogo con crditos acerca de la aplicacin (versin, fecha de creacin y software que se emplea GNU GCC, MINGW, wxWindows, wxStyledTextCtrl, Scintilla and SciTE y ResEd con una breve explicacin de cada uno y un enlace web).
- 65 -
4.2.2. Barra de Herramientas.

La barra de herramientas es un sistema cmodo y rpido para ejecutar directamente cualquier opcin de los mens explicados en el apartado anterior. Consta de veintisiete iconos que permiten realizar acciones como crear un nuevo proyecto, abrir un fichero, compilar un programa, depurar un programa, solicitar ayuda, etc. Cada uno de los iconos ser explicado a continuacin mediante una tabla que muestra la equivalencia entre los iconos de la barra de herramientas y la opcin del men que es ejecutada cuando se pulsa el icono.
Icono
Accin ejecutada
File New (Ctrl+N) File Open (Ctrl+O) File Save (Ctrl+S) File Save All Edit Cut (Ctrl+X) Edit Copy (Ctrl+C) Edit Paste (Ctrl+V) Edit Undo (Ctrl+Z) Edit Redo (Ctrl+Y) View Project Window (Alt+0) View Output Window (Alt+2) Previous (Alt+Left Arrow) Next (Alt+Right Arrow) Build Compile (Ctrl+F7) Build Build (F7) Build Stop Build Execute (Ctrl+F5) Debug Go (F5) Debug Toggle Breakpoint (F9) Debug Step Into (F11) Debug Step Over (F10) Debug Step Out of Function (Shift+F11) Debug Run to Cursor (Ctrl+F10) Debug QuickWatch (Shift+F9) File Print Preview File Print (Ctrl+P) Help About MinGW Developer Studio
- 66 -
Captulo
Depuracin de Programas (Debugging)
- 67 -
CAPTULO 5. Depuracin de programas (Debugging).

Debugging es el nombre que recibe el proceso de eliminacin y limpieza de bugs (errores) de los programas. Para realizar la depuracin de programas se emplea el debugger, que es una herramienta diseada para revisar las instrucciones de un programa paso a paso y examinar su estado en cada paso.
El Debugging comienza en cuanto el usuario se empieza a preguntar las razones por las que su programa no produce los resultados deseados. La primera tarea que se debe realizar es asegurarse de que el cdigo C/C++ compila y enlaza sin errores. Si se produce algn error, el cdigo debe ser modificado de tal manera que no ocurra.
La segunda tarea que se debe realizar es examinar el cdigo y comparar los resultados deseados con los que se estn obteniendo. Sin embargo, en muchas ocasiones sucede que tras realizar un examen profundo del cdigo sigue sin aparecer el error. Es en estos casos en los que es necesario emplear el debugger, que puede realizar las siguientes acciones: Recorrer las sentencias del programa paso a paso, bien over (por encima de) o into (dentro de) las funciones. En el primer caso (over) se omite el recorrido dentro de las funciones mientras que en el segundo caso se recorren las sentencias de las funciones y se vuelve a la funcin principal.
Ejecutar el programa hasta un cierto punto (bien hasta el cursor o hasta un breakpoint) y luego detener la ejecucin. En el primer caso (cursor) se ejecuta el programa hasta el lugar del cdigo donde est situado el cursor antes de comenzar el debugging. En el segundo caso (breakpoint) el programa se ejecutar hasta un breakpoint o punto de parada que se habr situado en el cdigo antes de comenzar el debugging. Mostrar los valores (o el contenido) de las variables en cada punto durante la ejecucin del programa.
- 68 -
5.1. Men Debug.

El men Debug consta de nueve opciones como son Go (Iniciar), Stop Debugging (Detener la
depuracin), Step Into (Ejecutar dentro de), Step Over (Ejecutar por encima de), Run to Cursor (Ejecutar hasta el cursor), Step Out of Function (Salir de la funcin), Back trace (Visualizacin de origen), Toggle Breakpoint (Situar/Eliminar breakpoint) y QuickWatch (Vista rpida).
o Go: Puede activarse tambin pulsando la tecla F5. Esta opcin inicia la depuracin del fichero que se encuentre abierto en la zona de edicin. Sin embargo, la depuracin del programa es tan rpida que no permite ver paso a paso la evolucin del mismo. Esto puede evitarse situando un breakpoint (mediante la opcin Toggle Breakpoint que se explicar posteriormente) en el punto del cdigo donde se quiere detener la depuracin o bien por medio de la opcin Run to Cursor que se explicar posteriormente. La pestaa Debug situada en la zona de salida mostrar el mensaje Debug has started (La depuracin ha comenzado) cuando se pulse esta opcin y Debug has stopped (La depuracin ha finalizado) cuando finalice la depuracin tal y como se muestra a continuacin.
o Stop Debugging: Puede activarse tambin pulsando simultneamente las teclas Shift y F5. Esta opcin detiene la depuracin del fichero que se encuentre abierto en la zona de edicin. La depuracin puede haberse iniciado por medio de la opcin Go, la opcin Step Into o la opcin Run to cursor. Al pulsar esta opcin la pestaa Debug situada en la zona de
- 69 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. salida mostrar el mensaje Debug has stopped (La depuracin ha finalizado).
o Step Into: Puede activarse tambin pulsando la tecla F11. Esta opcin permite la ejecucin paso a paso del fichero que se encuentre abierto en la zona de edicin. La primera vez que se pulse esta opcin sin haberse iniciado la depuracin, sta comenzar. Cuando comienza la depuracin aparece la ventana de consola y una flecha amarilla se sita a la derecha del nmero de lnea de la primera sentencia del programa. Si se pulsa de nuevo se avanzar por medio de la flecha amarilla hasta la siguiente sentencia del programa y as sucesivamente siguiendo el flujo de ejecucin del programa. En caso de que una sentencia sea una llamada a una funcin desde la funcin principal, la opcin Step Into permite saltar directamente a la primera sentencia de la funcin y ver las sentencias de sta hasta que vuelve o retorna a la funcin principal. Una vez que se pulsa esta opcin estando en la ltima sentencia del programa la ventana de consola contendr la ejecucin completa del programa con sus respectivas salidas y la pestaa Debug situada en la zona de salida mostrar el mensaje Debug has stopped (La depuracin ha finalizado). A continuacin se muestra una captura del debugging una vez se ha pulsado la opcin Step Into.
- 70 -
Como se puede ver en la captura sobre estas lneas, cuando el debugger llega a la sentencia de llamada a la funcin Suma (res=Suma(a,b);) y se pulsa la opcin Step Into, la flecha amarilla avanza hasta la primera sentencia de la funcin (suma=0;) y permite revisar su comportamiento. Si se vuelve a pulsar repetidamente, el debugger continuar revisando las sentencias de la funcin hasta llegar al final (denotado por }) y volver a la funcin llamante (main).
o Step Over: Puede activarse tambin pulsando la tecla F10. Esta opcin realiza exactamente lo mismo que la opcin anterior (Step Into) con la diferencia de que si una sentencia es una llamada a una funcin desde la funcin principal no salta a la primera sentencia de la funcin y permite revisar sus sentencias sino que salta a la siguiente sentencia de la funcin principal tras haber realizado las acciones que desempeaba la funcin. En resumen, se pasa a la siguiente sentencia de la funcin principal omitiendo la revisin de todas las sentencias de la funcin aunque a
- 71 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. efectos de resultado es como si se hubiera realizado. De este modo se ahorra tiempo de revisin de funciones donde se descarta la aparicin de errores (bugs). A continuacin se muestra una captura de la ejecucin del debugger una vez se ha pulsado la opcin Step Over.
Como se puede ver, cuando el debugger llega a la sentencia de llamada a la funcin Suma (res=Suma(a,b);) y se pulsa la opcin Step Over, la flecha amarilla avanza hasta la siguiente sentencia de la funcin principal (printf) omitiendo la revisin de las sentencias de la funcin Suma.
o Run to Cursor: Puede activarse tambin pulsando simultneamente las teclas Ctrl y F10. Esta opcin permite llevar a cabo la depuracin del fichero que se encuentre abierto en la zona de edicin hasta el lugar donde se haya situado el cursor antes de iniciar la depuracin. De este modo se ejecutan las sentencias del programa slo hasta un determinado punto especificado por el usuario antes de comenzar la depuracin.
- 72 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Step Out of Function: Puede activarse tambin pulsando simultneamente las teclas Shift y F11. Esta opcin slo se encuentra activa cuando el debugger se encuentra situado en una sentencia de una funcin y permite regresar a la funcin principal omitiendo la revisin del resto de sentencias de la funcin. Cuando regresa a la funcin principal, las sentencias restantes no se revisan aunque sus acciones se han ejecutado.
o Back trace: Puede activarse tambin pulsando la tecla F12. Esta opcin imprime en la pestaa Debug de la zona de salida informacin acerca de la sentencia que se est revisando. La informacin que se muestra es: level (nivel de profundidad), addr (direccin de memoria de la instruccin), func (nombre de la funcin), file (nombre del fichero que se est depurando) y line (nmero de lnea de la sentencia). El nivel de profundidad ser el ms alto si se trata de la funcin principal, el anterior al de la funcin principal si se trata de una funcin llamada por la funcin principal, el anterior al anterior al de la funcin principal si se trata de una funcin llamada por una funcin llamada por la funcin principal y as sucesivamente. Cuando se pulsa la opcin Back trace sobre una sentencia de una funcin se muestra informacin acerca de la sentencia de la funcin y acerca de la sentencia de la funcin principal que llam a dicha funcin. A continuacin se muestra una captura de la zona de salida una vez pulsada la opcin Back trace estando el debugger en una sentencia de una funcin.
- 73 -
o Toggle Breakpoint: Puede activarse tambin pulsando la tecla F9. Esta opcin aade/elimina un punto de parada (breakpoint) en la sentencia del programa donde se site el cursor. Como ya se ha comentado, los breakpoints sirven para ejecutar el debugger hasta el lugar donde estn situados. La sentencia en la que se site un breakpoint se distinguir del resto ya que aparecer un crculo de color rojo a la derecha del nmero de lnea. A continuacin se muestra una captura de la opcin Toggle Breakpoint en la que se observa el punto rojo situado al lado de la sentencia (printf) donde se ha colocado el breakpoint.
- 74 -
o QuickWatch: Puede activarse tambin pulsando simultneamente las teclas Shift y F9. Esta opcin abre una ventana de observacin de variables que permite visualizar el valor de las variables del programa a medida que avanza el debugger. A continuacin se muestra una captura de la ventana de observacin que ayudar en la explicacin.
En el cuadro de texto Expression se escribe el nombre de la variable que se desea observar. Al pulsar el botn Add Watch, dicha variable se introducir en el cuadro Current value e inicialmente tomar un valor desconocido (??). Al pulsar una variable del cuadro Current Value se podrn realizar las siguientes acciones: eliminarla (botn Delete) o cambiarle el valor (botn Set Value). La opcin Set Value es til para ver
- 75 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. los resultados que se produciran en caso de que las variables tomasen otros valores. El botn Delete All elimina todas las variables del cuadro Current value mientras que el botn Close cierra la ventana de observacin.
Una vez que todas las variables que se desean observar han sido introducidas y aparecen en el cuadro Current value ya se puede iniciar el debugger para ver los valores que van tomando. De esta forma en cada paso del debugger se observarn los valores que toman las distintas variables del cuadro Current value y se podr modificar el programa para obtener los resultados esperados. Para ello, con la opcin Set Value se pueden modificar los valores de las variables y ver la ejecucin que se produce. A continuacin se muestra la ventana de observacin de la opcin QuickWatch al ejecutar un programa con el debugger.
- 76 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. La ventana de observacin del ejemplo anterior se produjo cuando el debugger se encontraba en la segunda vuelta del bucle for (i=2) por lo que todas las variables tomaban un valor salvo res puesto que la funcin an no haba terminado su ejecucin. Es por ello que en dicha variable aparece el mensaje No symbol res in current context informando acerca de dicha situacin.
Existe otra forma alternativa de ver los valores que toman las variables en cada sentencia en la que se detiene el debugger. Esta forma consiste en situar el cursor encima de la variable que se quiere observar en la zona de edicin. De esta forma aparecer una etiqueta que mostrar el mismo valor que se muestra en la ventana de observacin de la opcin QuickWatch. Esta manera de ver el valor de las variables es ms rpida que con la opcin QuickWatch si bien no permite monitorizar todas las variables en una misma ventana, algo que s es posible con la citada opcin.
- 77 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Por ltimo hay que comentar que MinGW Developer Studio no puede cerrarse si el debugger est funcionando por lo que es necesario detener su ejecucin si se quiere abandonar la aplicacin. Por ello, se mostrar un cuadro informando acerca de dicha situacin en caso de intentar salir del programa con el debugger funcionando. Dicho cuadro se muestra a continuacin.
El cuadro de la figura muestra el mensaje You cannot close the Project while debugging. Select the Stop Debugging befote closing the project (No puedes cerrar el proyecto mientras est funcionando el debugger. Selecciona la opcin Stop Debugging antes de cerrar el proyecto) para indicar la situacin comentada en el prrafo anterior.
- 78 -
PARTE II: Funcionamiento del compilador en la parte que se corresponde a Orientacin a Objetos (C++)
- 79 -
Captulo
Introduccin
- 80 -
CAPTULO 1. Introduccin.
El compilador MinGW Developer Studio permite llevar a cabo
programacin orientada a objetos (POO) por medio del lenguaje de programacin C++, uno de los ms empleados en la actualidad. Se puede decir que C++ es un lenguaje hbrido, ya que permite programar tanto en estilo procedimental (orientado a algoritmos), como en estilo orientado a objetos, como en ambos a la vez. Adems, tambin se puede emplear mediante programacin basada en eventos para crear programas que usen interfaz grfica de usuario (GUI). Como lenguaje procedimental se asemeja al C y es compatible con l, aunque presenta ciertas ventajas. Como lenguaje orientado a objetos se basa en una filosofa completamente distinta, que exige del programador un completo cambio de mentalidad.
El nacimiento de C++ se sita en el ao 1980, cuando Bjarne Stroustrup, de los laboratorios Bell, desarroll una extensin de C llamada C with Classes (C con Clases) que permita aplicar los conceptos de la programacin orientada a objetos con el lenguaje C. Stroustrup se bas en las caractersticas de orientacin a objetos del lenguaje de programacin Simula, aunque tambin tom ideas de otros lenguajes importantes de la poca como ALGOL68 o ADA.
Durante los siguientes aos, Stroustrup continu el desarrollo del nuevo lenguaje y en 1983 se acu el trmino C++ (C Plus Plus).
En 1985, Bjarne Stroustrup public la primera versin de The C++ Programming Language (El lenguaje de programacin C++), que a partir de entonces se convirti en el libro de referencia del lenguaje.
En la actualidad, este lenguaje se encuentra estandarizado a nivel internacional mediante el estndar ISO/IEC 14882:1998 con el ttulo Information Technology Programming Languages C++, publicado el 1 de Septiembre de 1998. En el ao 2003 se public una versin corregida del estndar (ISO/IEC
- 81 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. 14882:2003). Finalmente, en la actualidad se est preparando una nueva versin del lenguaje, llamada C++0X, que se espera que est preparada para el ao 2010.
En C, la unidad de programacin es la funcin, con lo cual, se trata de una programacin orientada a la accin. Por el contrario, en C++ la unidad de programacin es la clase a partir de la cual, los objetos son producidos. Se trata, pues, de una programacin orientada a objetos.
Las bibliotecas estndar de C++ proporcionan un conjunto extenso de capacidades de entrada/salida. C++ usa entrada/salida de tipo seguro por lo que no podrn introducirse datos equivocados dentro del sistema.
Se pueden especificar entradas/salidas de tipos definidos por el usuario, as como de tipos estndar. Esta extensibilidad es una de las caractersticas ms valiosas de este lenguaje de programacin.
C++ permite un tratamiento comn de entradas/salidas de tipos definidos por usuario. Este tipo de estado comn facilita el desarrollo de software en general y de la reutilizacin de software en particular.
Las principales ventajas que presenta el lenguaje C++ son:
o Difusin: al ser uno de los lenguajes ms empleados en la actualidad, posee un gran nmero de usuarios y existe una gran cantidad de libros, cursos, pginas Web, etc. dedicados a l.
o Versatilidad: C++ es un lenguaje de propsito general, por lo que se puede emplear para resolver cualquier tipo de problema.
o Portabilidad: el lenguaje est estandarizado y un mismo cdigo fuente se puede compilar en diversas plataformas.
- 82 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Eficiencia: C++ es uno de los lenguajes ms rpidos en cuanto a ejecucin.
o Herramientas: existe una gran cantidad de compiladores, depuradores, libreras, etc.
- 83 -
Captulo
Creacin de aplicaciones C++ en MinGW Developer Studio
- 84 -
CAPTULO 2. Creacin de aplicaciones C++ en MinGW Developer Studio.

Inicialmente, el rea de trabajo del entorno de desarrollo est vaca. Para crear ahora la estructura de una nueva aplicacin C++, se procede del siguiente modo:
b. A continuacin, se presenta una ventana en la que se puede elegir el tipo de aplicacin que se desea crear. Se selecciona la pestaa Projects y la aplicacin de tipo Win32 Console Application. Ahora se procede a nombrar el proyecto escribiendo el nombre que se desea en el cuadro Project name. En el cuadro Location se permite especificar la ruta de acceso al directorio, es decir, el directorio donde se crear la carpeta de nombre igual al del proyecto y que contendr todos los ficheros relativos
- 85 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. al proyecto (ejecutables, cdigo fuente, etc.). Una vez especificado el nombre del proyecto y la ruta de acceso se confirma el cuadro de dilogo pulsando OK y ya se ha creado un proyecto nuevo. En el directorio especificado en el cuadro Location se habr creado un fichero llamado nombre_del_proyecto.msp (MinGWStudio Project Files). Puede darse la situacin de que el fichero creado tenga extensin *.mdsp en vez de *.msp. Esto se debe a que algunas versiones del compilador ponen dicha extensin a los ficheros de proyecto.
Se selecciona la pestaa Files y el fichero de tipo C/C++ Source File para crear un fichero de lenguaje de programacin C++ (*.cpp) que contenga el cdigo fuente. Se nombra el fichero en el cuadro File name y se confirma pulsando OK. El campo Location no debe ser modificado ya que por defecto se muestra la ruta de acceso al directorio del proyecto creado anteriormente. Adems, la checkbox Add to project se encuentra activada para aadir el fichero al proyecto que se haba creado previamente. Por tanto, la ruta de acceso y la checkbox no deben ser modificadas. En el directorio del proyecto se habr creado un fichero llamado
nombre_del_fichero.cpp (C Plus Plus Source File).
- 86 -
- 87 -
2.1. Opciones de MinGW Developer Studio relacionadas con C++.

El compilador dispone de una serie de opciones relacionadas con el lenguaje de programacin C++ que se vern a continuacin.
o Comentarios en estilo C++: el compilador dispone de una opcin que permite convertir un texto seleccionado en comentario C++ (cada lnea de comentario precedida de //). Esta opcin se encuentra en el men Edit Advanced
Make Selection C++ style comment y es preciso seleccionar el texto a convertir en comentario C++ antes de pulsarla. A continuacin se muestra un ejemplo de comentario C++.
// stdafx.h: include file for standard system include files, // or project specific include files that are used frequently, but // are changed infrequently
o Manejo de excepciones e informacin en tiempo de ejecucin: el compilador dispone de dos opciones relativas al lenguaje C++ que permiten habilitar o deshabilitar el manejo de excepciones y la informacin de tipo Runtime. El manejo de excepciones es una estructura de control del lenguaje C++ diseada para manejar condiciones anormales que pueden ser tratadas por el mismo programa que se desarrolla. La informacin de tipo Runtime (RTTI Run-Time Type Information) es un sistema C++ que guarda en memoria informacin acerca del tipo de datos de un objeto en tiempo de ejecucin. RTTI resulta til cuando se trabaja con punteros a objetos en los que, en general, no se puede determinar el tipo de objeto al que referencian. Las dos opciones anteriormente descritas se encuentran en el men Project Settings y en la pestaa Compile. En dicha pestaa hay una groupbox llamada C++ Language que contiene ambas opciones. A continuacin se muestra una captura del cuadro Settings en la pestaa Compile donde se muestran las opciones relativas a C++.
- 88 -
Cuando se desarrollan aplicaciones orientadas a objetos es necesario declarar las clases (este concepto se ver en el captulo 3) en ficheros independientes. El tipo de fichero que se emplea para declarar las clases es el fichero de cabecera (C/C++ Header File). Para crear un fichero de cabecera y aadirlo al proyecto se elige la opcin New del men File (o se pulsan las teclas Ctrl y N simultneamente) o se pulsa el botn de la barra de herramientas.
Se selecciona la pestaa Files y el fichero de tipo C/C++ Header File para crear un fichero de cabecera (*.h) que contenga la declaracin de la clase. Se nombra el fichero en el cuadro File name con el mismo nombre que se le quiera dar a la clase y se confirma pulsando OK. El campo Location no debe ser modificado ya que por defecto se muestra la ruta de acceso al directorio del proyecto creado anteriormente. Adems, la checkbox Add to project se encuentra activada para aadir el fichero de cabecera al proyecto que se haba creado previamente. Por tanto, la ruta de acceso y la checkbox no deben ser modificadas. En el directorio del proyecto se habr creado un fichero llamado nombre_de_la_clase.h.
- 89 -
Captulo
Programacin Orientada a Objetos (POO) en C++
- 90 -
CAPTULO 3. Programacin Orientada a Objetos (POO) en C++.

Para explicar la POO (Programacin Orientada a Objetos) se partir de un ejemplo sencillo en el que se vern algunos conceptos clave. A continuacin se muestra un objeto de la clase Persona.
La zona amarilla muestra los atributos del objeto (nombre y edad) mientras que el resto de colores muestran los mtodos del objeto (getNombre, getEdad, setNombre y setEdad), es decir, las acciones y tareas que puede desempear dicho objeto. A los atributos de un objeto nunca se tendr acceso directo (como una especie de caja negra) y slo se acceder a ellos a travs de los mtodos. Se necesitarn, pues, dos tipos de mtodos para manejar los objetos: los que obtengan los datos (getters) y los que asignen datos (setters). Los mtodos definen lo que se conoce por interfaz de un objeto, es decir, la parte que maneja el usuario y a la que se puede acceder. Los atributos, sin embargo, forman parte de la zona oculta al usuario y a la que no se tiene acceso. Las peticiones que se pueden hacer a un objeto se encuentran definidas en su interfaz y es el tipo de objeto el que determina la interfaz. La interfaz establece qu peticiones pueden hacerse a un objeto particular.
La forma de acceder a los objetos es invocando sus mtodos de la siguiente manera: objeto.mtodo(). A continuacin se muestran objetos creados de la clase Persona:
- 91 -
Ejemplos de tareas a realizar con estos objetos:
Obtener el nombre de la persona p1 y la edad de la persona p4.
p1.getNombre(); p4.getEdad();
// Devuelve Pedro // Devuelve 23
Cambiar el nombre de la persona p2 y la edad de la persona p3.
p2.setNombre(Alberto); p3.setEdad(38);
Una vez vistos en la prctica el funcionamiento de los objetos, stos se pueden definir como entidades complejas provistas de datos (propiedades, atributos) y comportamiento (mtodos). Posteriormente se ver la relacin entre los objetos y la clase a la que pertenecen (en el ejemplo, Persona). A continuacin se explicar en detalle lo que es una clase.
- 92 -
3.1. Clase.
La programacin orientada a objetos se basa en encapsular datos (atributos) y funciones o comportamientos (mtodos) juntos en estructuras llamadas clases. Las clases responden a la necesidad del programador de construir objetos o tipos de datos que respondan a sus necesidades y se emplean para modelar objetos del mundo real.
Para explicar el concepto de clase se comenzar con un ejemplo sencillo que ayude a entenderlo. Supngase que se quiere preparar un flan. Para ello se necesitarn una serie de ingredientes como azcar, huevo, leche, etc. Todos estos ingredientes se mezclarn y se introducirn en un molde, que es el que se meter en el horno. Una vez finalizado el tiempo de horneo se obtendr el flan. Si se quisiera preparar otro flan igual se hara lo mismo y as sucesivamente. El mismo molde servira para elaborar un nmero infinito de flanes. Pues bien, algo parecido sucede con los objetos y la clase a la que pertenecen. Todos los objetos de una misma clase comparten los mismos atributos (en el ejemplo, ingredientes) y la clase es el molde que permite su creacin. En la clase estarn definidas todas las propiedades y funcionalidad comn a los objetos que pertenezcan a ella. Los objetos, por tanto, heredan las propiedades y tambin el comportamiento de todas las clases a las que pertenezcan.
Una clase se define como una estructura que define atributos e implementa mtodos de cada objeto. La tarea principal de una clase es crear objetos. Las clases se definen mediante la palabra reservada class.
- 93 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. A continuacin se muestra la representacin de la clase Persona del ejemplo del punto anterior.
Como se puede ver en la figura sobre estas lneas, la clase Persona tiene dos atributos (zona verde) y cuatro mtodos (zona roja). Los getters permiten obtener el nombre y la edad del objeto de la clase Persona mientras que los setters permiten modificar el nombre y la edad de dicho objeto.
Existen dos tipos de clases:
o Clases abstractas: son clases que tienen definidos sus mtodos pero no su implementacin. Ningn objeto puede pertenecer directamente a estas clases. Las clases que heredan (la herencia se ver en el captulo 4) de una clase abstracta deben implementar sus mtodos. Las clases abstractas se explican en detalle en el apartado 4.5.3 del captulo 4.
o Clases concretas: los objetos pueden pertenecer directamente a estas clases.
- 94 -
3.2. Constructor y destructor.

Ya se ha comentado que la clase es como una especie de molde que permite crear objetos. Para llevar a cabo la creacin de objetos hace uso de un elemento llamado constructor. El constructor es un mtodo que se declara con el mismo nombre que la clase y en el que se deben especificar los atributos a inicializar. Una clase sin constructor lo nico que puede hacer es generar los objetos, pero vacos (sin inicializar). El compilador MinGW Developer Studio proporciona un constructor por defecto que permite crear los objetos vacos de forma automtica. A continuacin se muestra un ejemplo de un constructor:
Persona(string nombre, int edad); A este constructor se le llama constructor personalizado ya que lo especifica el programador. Cuando no haya creado un constructor personalizado entonces ser el constructor por defecto el que crear los objetos. En caso de que exista ms de un constructor personalizado, stos deben ser claramente diferenciables por sus argumentos (nmero o tipo). A este fenmeno mediante el cual varios mtodos (el constructor tambin es un mtodo) tienen el mismo nombre pero con distintos argumentos y definicin se le llama sobrecarga. Cuando se invoca un mtodo sobrecargado, el compilador analiza los argumentos de la llamada y, en funcin de su tipo, deduce cul de las distintas versiones del mtodo con ese nombre debe recibir el control. Debido a la sobrecarga, en C++ es obligatoria la declaracin de los mtodos y de los tipos de sus argumentos (int, float, string, char, etc.). A continuacin se muestran tres constructores sobrecargados de la clase Persona:
Persona(string nombre); Persona(int edad); Persona(string nombre, int edad); Como se ve en el ejemplo sobre estas lneas, los tres constructores se diferencian entre ellos en el nmero de argumentos salvo los dos primeros que
- 95 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. tienen el mismo nmero. Sin embargo, estos dos se diferencian en el tipo de argumento por lo que el conflicto es inexistente.
Por otra parte, existe un elemento que es invocado por el compilador de forma automtica antes de la destruccin de un objeto. Este elemento recibe el nombre de destructor. Su declaracin dentro de la clase es opcional y no devuelve tipo alguno ni admite parmetros. Se nombra con el nombre de la clase precedido del smbolo ~. A continuacin se muestra el destructor de la clase Persona:
~Persona(){}
3.3. Creacin de objetos.

Aunque el elemento que se encarga de la creacin de objetos, el constructor, ya ha sido explicado no as el proceso de creacin de objetos.
Existen dos formas de crear objetos:
o Automtica (Nombre_Clase Nombre_objeto (argumentos)): El compilador se encarga de incluir el cdigo necesario para crearlo antes de su primer uso y para destruirlo despus de su ltimo uso. Su alcance comienza en su declaracin y termina con el bloque de cdigo en el que se ha declarado (encerrado entre llaves). Si no pertenece a ningn bloque se crea al iniciarse el programa y se destruye inmediatamente antes de finalizar el programa. A continuacin se muestran dos ejemplos de creacin de objetos de forma automtica:
Persona per1(Pedro, 65);
//Utilizando el constructor //Persona(string nombre, int edad); //Utilizando el constructor por //defecto
Persona per1();
- 96 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Dinmica (operadores new y delete): Permite decidir el momento de la creacin y destruccin de los objetos. Usa asignacin dinmica de memoria (variables de tipo puntero). A continuacin se muestran un ejemplo de creacin y destruccin de objetos de forma dinmica:
Persona *per1; //Declaracin de la variable per1 de clase Persona per1 = new Persona(Juana, 27); //Creacin del objeto per1 usando //el constructor Persona(string //nombre, int edad); delete per1; // Destruccin del objeto per1
Dependiendo de la forma elegida a la hora de crear un objeto cambiar la forma de acceder a sus mtodos. Por ello se distinguen dos casos:
o Si el objeto fue creado de forma automtica, entonces el acceso a sus mtodos se har mediante el operador punto (.) tal y como se muestra a continuacin.
Persona per1(Pedro, 65); per1.setEdad(45);
// Creacin automtica //NombreObjeto.mtodo
o Si el objeto fue creado de forma dinmica, entonces el acceso a sus mtodos se har mediante el operador flecha (->) tal y como se muestra a continuacin.
Persona *per1;
// Declaracin del objeto
per1 = new Persona(Juana, 27); // Creacin dinmica per1->setEdad(34); //NombreObjeto->mtodo
- 97 -
3.4. Especificadores de acceso.

Al comienzo de este captulo se deca que la interfaz de un objeto define el conjunto de mtodos accesibles a dicho objeto. Adems, se deca que los atributos forman parte de la zona oculta al usuario y a la que no se tiene acceso. Pues bien, los especificadores de acceso permiten determinar el nivel de acceso de los miembros de una clase y, por tanto, diferenciar entre la zona oculta y la interfaz. Se utilizan pues para determinar el nivel de ocultacin de cada objeto (la ocultacin se explicar en el apartado 4.2 del captulo 4). Los especificadores de acceso permiten poner en prctica un principio bsico de POO como es el encapsulamiento. Segn este principio todo objeto tiene una capacidad de aislamiento (atributos y mtodos) respecto a otros objetos de la misma o de otra clase. En definitiva, que el acceso a los atributos de un objetos se debe hacer por medio de sus mtodos. Este principio se explicar en detalle en el apartado 4.1 del captulo 4. Existen tres tipos de especificadores de acceso: o private: es opcional y se toma por defecto desde el principio de la definicin de la clase hasta que aparece otro especificador de acceso. Los atributos y los mtodos slo son accesibles desde la propia clase. Es el especificador de acceso ms restrictivo. Los atributos son siempre private ya que slo tendr acceso a ellos la propia clase puesto que no forman parte de la interfaz del objeto. o public: los atributos y los mtodos son accesibles por cualquier clase. Es el especificador de acceso menos restrictivo. Los mtodos son siempre public puesto que forman parte de la interfaz del objeto. o protected: los atributos y mtodos son accesibles slo por la clase que los contiene y todas aquellas que hereden de sta (la herencia se explicar en el apartado 4.4 del captulo 4). Se encuentra entre private y public, en un nivel restrictivo intermedio. - 98 -
3.5. Ficheros de cabecera y Espacio de nombres.

A la hora de crear programas en C++ es necesario incluir dos sentencias que permitan posteriormente la utilizacin de instrucciones de las libreras de C++. Estas sentencias son: #include<iostream> y using namespace std;
La instruccin #include<iostream> incluye el contenido del fichero de cabecera de flujo de entrada/salida (input output stream) en el cdigo del programa. C++ dispone de dos jerarquas de clases para las operaciones de entrada/salida: una de bajo nivel, streambuf, que no se va a explicar porque slo es utilizada por programadores expertos, y otra de alto nivel, con las clases: istream, ostream y iostream, que derivan de la clase ios. Estas clases disponen de variables y mtodos para controlar los flujos de entrada y salida. La clase que se emplea normalmente para controlar el flujo de entrada/salida es iostream. A continuacin se muestra la jerarqua de clases de entrada y salida de C++ donde las clases ifstream, ofstream y fstream se utilizan para el manejo de ficheros.
- 99 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. En C++ se distinguen dos tipos de ficheros de cabecera: C y C++. Los de C no hacen uso de espacio de nombres y llevan el prefijo c. Por ejemplo, cstdio, cstdlib o cstring. Los ficheros de encabezado de C++, sin embargo, hacen uso de espacio de nombres (el espacio de nombres estndar std). En ambos casos, no llevan la extensin .h.
Temporalmente, es posible que estn disponibles los ficheros de cabecera antiguos (con la extensin .h), pero no se aconseja su uso. Adems, hay que tener cuidado para no confundir string.h (librera de C), cstring (librera de C adaptada para ser usada en C++) y string (librera de C++).
Las libreras estndar de C++ estn definidas dentro de un espacio de nombres llamado std. Por tanto, si se quiere evitar el tener que emplear el operador de mbito (::) constantemente, hay que aadir la sentencia using namespace std; justo despus de la inclusin (#include) de las libreras. Esta sentencia permite, por tanto, el acceso a todos los miembros definidos en el espacio de nombres std que se emplea en el fichero iostream.
- 100 -
3.6. Ejemplo de aplicacin orientada a objetos mediante MinGW Developer Studio.

Una vez vistos los conceptos bsicos para entender el desarrollo de una aplicacin orientada a objetos en C++ se ver el ejemplo de la clase Persona desarrollado en MinGW Developer Studio. A continuacin se muestra el contenido del fichero Persona.h que contiene la definicin de la clase Persona.
// Declaracin de la Clase Persona
#include<iostream> using namespace std;
class Persona { private: // Atributos string nombre; int edad; public: //Getters string getNombre(void){return nombre;} int getEdad(void){return edad;} //Setters void setNombre(string _nombre){nombre=_nombre;} void setEdad(int _edad){edad=_edad;} //Constructor Persona(string _nombre, int _edad) { nombre=_nombre; edad=_edad; } };
Es preciso comentar que cuando se desarrollan aplicaciones orientadas a objetos es muy habitual declarar las diferentes clases con las que se va a
- 101 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. trabajar en ficheros de cabecera independientes (extensin .h) y luego incluirlas en el programa principal por medio de la directiva #include. A continuacin se muestra el programa principal (fichero programa.cpp) que incluye el fichero Persona.h mostrado anteriormente.
// Programa principal
#include<iostream> #include "Persona.h" // Inclusin del fichero donde se declara // la clase Persona using namespace std;
int main(void) { Persona *p1; p1=new Persona("Pedro", 48); // Creacin dinmica
Persona p2("Ana", 35);
// Creacin automtica
cout<<"Persona 1 - Nombre: "<<p1->getNombre()<<" Edad: " <<p1->getEdad()<<endl; // Informacin del objeto dinmico p1
cout<<"Persona
Nombre:
"<<p2.getNombre()<<"
Edad:
"
<<p2.getEdad()<<endl; // Informacin del objeto automtico p2 }
En el ejemplo que se muestra sobre estas lneas se crean dos objetos de clase Persona y se muestra su informacin. El primer objeto, p1, se crea de forma dinmica mediante el operador new tras haber sido declarado en la lnea anterior. Hay que recordar que el objeto va precedido del operador asterisco (*) en su declaracin. El segundo objeto, p2, es creado de forma automtica por lo que la declaracin y creacin del objeto van en la misma lnea de cdigo. Posteriormente, mediante cout (se explicar en el siguiente apartado) se muestra la informacin de ambos objetos invocando a sus mtodos correspondientes (getNombre para obtener el nombre y getEdad para obtener la
- 102 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. edad). En el caso del objeto p1, creado de forma dinmica, se accede a sus mtodos mediante una flecha segn lo descrito en el apartado 3.3.
Por ltimo, se muestra la salida por pantalla tras la ejecucin del cdigo mostrado anteriormente:
3.7. Operadores de entrada/salida.

En todo programa C++ existen dos elementos que permiten al usuario comunicarse con el programa. Se trata de la salida estndar, cout y de la entrada estndar cin. Estos elementos permiten enviar a la pantalla o leer desde el teclado cualquier variable o constante, incluidos literales. Equivale a las funciones printf y scanf propias del lenguaje de programacin C y situadas en la librera stdio.h.
cout es un objeto de la clase ostream y cin un objeto de la clase istream. Como ambas clases heredan de la clase superior iostream basta con incluir esta ltima clase al comienzo del programa para poder utilizar ambos objetos. El diagrama con la jerarqua de clases para efectuar entrada/salida en C++ se mostr anteriormente en el apartado 3.5. A continuacin se muestra el formato de utilizacin de ambas clases:
- 103 -

#include <iostream> using namespace std; cout << <variable|constante> [<< <variable|constante>...]; cin >> <variable> [>> <variable>...];
Su uso es muy simple tal y como se muestra en el siguiente ejemplo donde se lee un nmero por medio de cin y se muestra en pantalla por medio de cout:
#include <iostream> using namespace std; int main() { int a; cin >> a; cout << "la variable a vale " << a; }
Un mtodo muy til para cout es endl, que har que la siguiente salida se imprima en una nueva lnea.
cout << hola << endl;
Otro mtodo, ste para cin es get(), que sirve para leer un carcter, pero que nos puede servir para detener la ejecucin de un programa. Esto es especialmente til cuando se trabaja con compiladores que crean programas de consola win32 en los que se produce lo siguiente: cuando se ejecutan los programas desde el compilador con el que se est trabajando, al terminar se cierra la ventana automticamente, impidiendo ver los resultados. Usando get() se puede detener la ejecucin del programa hasta que se pulse una tecla. Por otra parte, hay veces, sobre todo despus de una lectura mediante cin, en las que pueden quedar caracteres pendientes de leer. En ese caso hay que usar ms de una lnea cin.get().
- 104 -
3.8. Modificadores.
Las variables que se declaran en los programas desarrollados en lenguaje de programacin C++ tienen el siguiente formato:
[mod_general] [mod_almacenamiento] tipo identificador [=valor] [mod_general] [mod_almacenamiento] tipo identificador [(valor)]
La diferencia entre ambos formatos reside en que la inicializacin de una variable puede realizarse de forma convencional mediante el operador de asignacin = (primer caso) o bien situando el valor entre parntesis (segundo caso). Los modificadores son opcionales y se sitan antes del tipo de la variable a inicializar. Existen dos tipos de modificadores: modificadores generales y modificadores de almacenamiento. o Modificador general: Indica al compilador una variacin en el comportamiento habitual de una variable. Si no aparece el compilador no asume ninguno por defecto. Existen los siguientes tipos: const: Constantes, se marcan como de solo lectura y no pueden modificarse durante el resto de la ejecucin. Una variable definida como const se comporta como una constante (numrica o literal) en todo el programa y slo se le puede asignar un valor inicial. Su ventaja principal frente a la directiva #define es que el compilador realiza una comprobacin de tipos. Ejemplo: const int tamano=1;
volatile: El valor de la variable se puede alterar por medios distintos al propio programa, por ejemplo una llamada del sistema operativo. Se usan en muy raras ocasiones.
- 105 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. mutable: Aplicable a objetos, indica que un atributo puede cambiar su valor pese a ser constante (slo lectura). Se usa raramente. o Modificador de almacenamiento: Indica el tipo de almacenamiento en memoria y el momento en que se crea y se destruye una variable. Existen los siguientes tipos: auto: Automtico, no se usa. Es el modificador por defecto.
register: La variable se almacena en un registro del procesador. Est obsoleto ya que los compiladores modernos optimizan por defecto la forma en que se deben almacenar las variables. Se mantiene por compatibilidad con cdigos ms antiguos.
static: Cuando una variable es local indica al compilador que solo debe construirla una vez y debe hacer su valor perdurable para futuras ejecuciones del mismo bloque de cdigo. Se suele utilizar sobre todo para limitar el acceso a algunas variables globales.
extern: Se utiliza para declarar en el cdigo propio variables globales que se corresponden con variables declaradas en otros mdulos.
- 106 -
3.9. Variable reservada this.

this es una variable reservada de C++ que no necesita ser declarada. Esta variable es un puntero al objeto concreto al que se aplica el mtodo que se est ejecutando. Es una variable predefinida para todos los mtodos u operadores de una clase. Este puntero contiene la direccin del objeto concreto de la clase al que se est aplicando el mtodo o el operador. Se puede decir que this es un alias del objeto correspondiente. Conviene tener en cuenta que cuando un mtodo se aplica a un objeto de su clase (su argumento implcito), accede directamente a los atributos (sin utilizar el operador punto o flecha), pero no tiene forma de referirse al objeto como tal, pues no le ha sido pasado explcitamente como argumento. Este problema se resuelve con la variable reservada this. A continuacin se muestra un ejemplo de empleo de dicha variable en la clase Persona:
- 107 -

class Persona { private: // Atributos string nombre; int edad; public: //Getters string getNombre(void){return nombre;} int getEdad(void){return edad;} //Setters void setNombre(string _nombre){nombre=_nombre;} void setEdad(int _edad){edad=_edad;} // Mtodo que devuelve el ao de nacimiento int devuelveFechaNac(void) { return 2008 this->getEdad(); } //Constructor Persona(string _nombre, int _edad) { nombre=_nombre; edad=_edad; } };
En el ejemplo anterior se puede ver implementado el mtodo devuelveFechaNac que devuelve la fecha de nacimiento de un objeto de clase Persona. Para realizar este clculo se necesita conocer el valor del atributo edad por lo que se invoca el mtodo getEdad gracias a la variable reservada this.
- 108 -
3.10. Mtodos inline.

Los mtodos inline se utilizan para mejorar la velocidad de ejecucin. Un mtodo marcado como inline indica al compilador que debe sustituir cada llamada a dicho mtodo por su cdigo correspondiente. De esta manera se mejora la velocidad de proceso ya que se ahorra las instrucciones de salto y devolucin de valores al programa principal. La principal ventaja de un mtodo inline es que mejora la eficiencia del programa sin afectar a su legibilidad. Los mtodos cuyo cdigo aparece dentro de la declaracin de una clase son por defecto inline. Los mtodos inline se usan cuando la implementacin del mtodo no es muy compleja como, por ejemplo, mtodos que devuelven clculos muy simples. A continuacin se muestra un ejemplo de un mtodo inline que calcula la longitud de una circunferencia a partir de su radio:
inline double circun(double radio) int main(void) { return 2*3.1416*radio; } { double r; cin >> r; cout << La longitud de la circunferencia cuyo radio es << r << es: << } circun(r);
Se debe tener en cuenta que los compiladores analizan el cdigo del mtodo y deciden si usan el mtodo como inline o como mtodo normal. La decisin depende del compilador.
Cuando un mtodo se implementa dentro de la declaracin de la clase, se considera como inline. A continuacin se muestra un ejemplo de esta situacin:
- 109 -

class MiClase { private: // Atributos int i; public: void print() { cout << i << ; } }; // Mtodo inline implcito
3.11. Clases y mtodos friend.

Existen ocasiones en las que dos clases estn muy relacionadas entre s de modo que se quiere que una tenga acceso a la otra y que trabajen conjuntamente con los mismos atributos a travs de los mtodos. Sin embargo, una de las limitaciones que presentan los mtodos es que slo pueden pertenecer a una nica clase. Adems, un mtodo convencional slo puede actuar directamente sobre un nico objeto de la clase (su argumento implcito, que es el objeto con el que ha sido llamado por medio del operador punto (.) o flecha (->), como por ejemplo en per1.setEdad(45)). Para que acte sobre un segundo o un tercer objeto hay que pasrselos como argumentos.
Se puede concluir que a pesar de las grandes ventajas del encapsulamiento (se ver en el apartado 4.1 del captulo 4), en muchas ocasiones es necesario dotar a la programacin orientada a objetos de una mayor flexibilidad. Esto se consigue por medio de los mtodos friend. Un mtodo friend de una clase es un mtodo que no pertenece a la clase, pero que tiene permiso para acceder a sus atributos y a sus mtodos privados por medio de los operadores punto (.) y flecha (->), sin tener que recurrir a los
- 110 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. mtodos pblicos de la clase. Si una clase se declara friend de otra, todos sus mtodos son friend de esta segunda clase. El carcter de friend puede restringirse a mtodos concretos, que pueden pertenecer a alguna clase o pueden ser mtodos generales que no pertenecen a ninguna clase.
Para declarar un mtodo o una clase como friend de otra clase, es necesario hacerlo en la declaracin de la clase que debe autorizar el acceso a sus atributos privados. Esto se puede hacer de forma indiferente en la zona de declaracin de variables o en la zona privada de declaracin de atributos. Un ejemplo de declaracin de una clase friend podra ser el que sigue:
class MiClase { friend class Amiga; private: int atributo; public: int getAtributo(){return atributo;} };
Es muy importante tener en cuenta que esta relacin funciona slo en una direccin, es decir, los mtodos de la clase Amiga pueden acceder a los atributos privados de la clase MiClase a travs de sus mtodos, por ejemplo a la variable entera atributo a travs del mtodo getAtributo(), pero esto no es cierto en sentido inverso: los mtodos de la clase MiClase no pueden acceder a un atributo privado de la clase Amiga a travs de sus mtodos.
Si se quiere que varias clases tengan acceso mutuo a todos los atributos y mtodos, cada una debe declararse como friend en todas las dems, para conseguir una relacin recproca. Se plantea un problema cuando dos clases deben ser declaradas mutuamente friend la una de la otra. Considrense por ejemplo las clases vector y matriz. Las declaraciones podran ser las siguientes:
- 111 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. // declaracin de las clases vector y matriz (mutuamente friend) class matriz; // declaracin anticipada de clase matriz class vector { // declaracin de mtodos de la clase vector ... friend matriz; }; class matriz { // declaracin de mtodos de la clase matriz ... friend vector; };
A primera vista sorprende la segunda lnea de lo que sera el fichero de declaracin de ambas clases. En esta lnea aparece la sentencia class matriz;. Esto es lo que se llama una declaracin anticipada, que es necesaria por el motivo que se explica a continuacin. Sin declaracin anticipada cuando la clase matriz aparece declarada como friend en la clase vector, el compilador an no tiene noticia de dicha clase, cuya declaracin viene despus. Al no saber lo que es matriz, da un error. Si la clase matriz se declara antes que la clase vector, el problema se repite, pues vector se declara como friend en matriz. La nica solucin es esa declaracin anticipada que advierte al compilador que matriz es una clase cuya declaracin se encuentra ms adelante.
- 112 -
Captulo
Paradigmas de programacin
- 113 -
CAPTULO 4. Paradigmas de programacin.

Para explicar la POO (Programacin Orientada a Objetos) es fundamental enumerar las caractersticas o paradigmas propios de este enfoque. En este captulo se explicarn en detalle los cinco paradigmas ms importantes de la POO: el encapsulamiento, la ocultacin, la abstraccin, la herencia y el polimorfismo.
4.1. Encapsulamiento.
En programacin orientada a objetos se denomina encapsulamiento a la ocultacin del estado, es decir, de los datos (atributos) de un objeto de manera que slo se pueden cambiar mediante las operaciones (mtodos) definidas para ese objeto.
Cada objeto est aislado del exterior, es un mdulo natural, y la aplicacin entera se reduce a un agregado o rompecabezas de objetos. El aislamiento protege a los datos asociados a un objeto contra su modificacin por quien no tenga derecho a acceder a ellos, eliminando efectos secundarios e interacciones.
De esta forma el usuario de la clase puede obviar la implementacin de los mtodos y propiedades para concentrarse slo en cmo usarlos. Por otro lado se evita que el usuario pueda cambiar su estado de manera imprevista e incontrolada.
Como se pudo observar en el diagrama del objeto de la clase Persona del captulo 3 (figura), los atributos del objeto se localizan en el centro o ncleo del objeto. Los mtodos rodean y esconden el ncleo del objeto de otros objetos en el programa. Al empaquetamiento de los atributos de un objeto con la proteccin de sus mtodos se le llama encapsulamiento. - 114 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Tpicamente, el encapsulamiento es utilizado para esconder detalles de implementacin a otros objetos. Entonces, los detalles de implementacin pueden cambiar en cualquier momento sin afectar a otras partes del programa.
El encapsulamiento de atributos y mtodos en un componente de software ordenado es una idea simple pero potente que provee dos principales beneficios a los desarrolladores de software: El encapsulamiento consiste en unir en la clase las caractersticas y comportamientos, esto es, los atributos y mtodos. Es tener todo esto en una sola entidad. En los lenguajes estructurados esto era imposible. Es evidente que el encapsulamiento se logra gracias a la abstraccin y la ocultacin que se vern en los prximos apartados. La utilidad del encapsulamiento reside en la facilidad para manejar la complejidad, ya que se tendr a las clases como cajas negras donde slo se conoce el comportamiento pero no los detalles internos, y esto es conveniente porque lo que interesar al usuario ser conocer qu hace la clase pero no ser necesario saber cmo lo hace.
El encapsulamiento da lugar a que las clases se dividan en dos partes:
Interfaz: captura la visin externa de una clase, abarcando la abstraccin del comportamiento comn a los ejemplos de esa clase. La interfaz de un objeto ya se explic al comienzo del captulo 3.
Implementacin: comprende la representacin de la abstraccin, as como los mecanismos que conducen al comportamiento deseado.
La forma habitual de poner en prctica el paradigma de encapsulamiento es mediante los especificadores de acceso explicados en el apartado 3.4 del captulo 3.
- 115 -
4.2. Ocultacin.
El paradigma de ocultacin hace referencia a que los atributos privados de un objeto no pueden ser modificados ni obtenidos a no ser que se haga a travs de los mtodos pblicos pertenecientes a su interfaz.
Como ya se ha comentado anteriormente, los atributos de un objeto no son accesibles de manera directa sino que hay que pasar por los mtodos para acceder a ellos. Esto se debe a que los atributos estn ocultos mientras que los mtodos forman parte de la interfaz del objeto, es decir, la parte visible por el resto de objetos. Precisamente es la interfaz la que materializa la definicin de ocultacin.
Cada objeto est aislado del exterior, es un mdulo natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cmo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificacin por quien no tenga derecho a acceder a ellas, solamente los propios mtodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de manera inesperada, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstraccin. La aplicacin entera se reduce entonces a un agregado o rompecabezas de objetos.
- 116 -
4.3. Abstraccin.
La abstraccin expresa las caractersticas esenciales de un objeto, las cuales distinguen al objeto de los dems. Adems de distinguir entre los objetos provee lmites conceptuales. Entonces se puede decir que el encapsulamiento separa las caractersticas esenciales de las no esenciales dentro de un objeto. Si un objeto tiene ms caractersticas de las necesarias resultar difcil de usar, modificar, construir y comprender.
La abstraccin genera una percepcin de simplicidad dado que minimiza la cantidad de caractersticas que definen a un objeto. A la hora de realizar la abstraccin de un elemento del mundo real se hace lo siguiente: se selecciona el elemento y se toma la parte que interesa, la parte representativa del objeto, omitiendo as algunas caractersticas de dicho elemento. Si el programador toma los atributos que le interesan, entonces se trata de una abstraccin de datos. Si por el contrario toma los mtodos que le interesan, entonces ser una abstraccin funcional.
Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cmo se implementan estas caractersticas. Los procesos, las funciones o los mtodos pueden tambin ser abstrados y cuando lo estn, una variedad de tcnicas son requeridas para ampliar una abstraccin.
Pensar en trminos de objetos es muy parecido a cmo se hara en la vida real. Por ejemplo se va a pensar en un coche para tratar de modelarlo en un esquema de POO. Se podra decir que el coche es el elemento principal que tiene una serie de caractersticas, como podran ser el color, el modelo o la marca. Adems tiene una serie de funcionalidades asociadas, como pueden ser ponerse en marcha, parar o aparcar.
- 117 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Pues en un esquema POO el coche sera el objeto, las caractersticas seran los atributos como el color o el modelo y los mtodos seran las funcionalidades asociadas como ponerse en marcha o parar.
Estos objetos se podrn utilizar en las aplicaciones, por ejemplo en un programa que gestione un taller de coches se utilizarn objetos coche. Las aplicaciones orientadas a objetos utilizan muchos objetos para realizar las acciones que se desean realizar y ellas mismas tambin son objetos. Es decir, el taller de coches ser un objeto que utilizar objetos coche, herramienta, mecnico, recambios, etc.
4.4. Herencia.
La mente humana clasifica los conceptos de acuerdo a dos dimensiones: pertenencia y variedad. Se puede decir que el Seat Ibiza es un tipo de coche (variedad o relacin del tipo es un) y que una rueda es parte de un coche (pertenencia o relacin del tipo tiene un). En C++ se puede resolver el problema de la pertenencia mediante las estructuras, que pueden ser todo lo complejas que se quiera. Pero con la herencia se consigue clasificar los tipos de datos (abstracciones) por variedad, acercando as un paso ms la programacin al modo de razonar humano.
La herencia se define como la capacidad de definir jerarquas mediante la divisin de una clase en subclases. La herencia permite que una clase (y los objetos que pertenecen a ella) herede los mtodos y atributos de su clase base. La herencia permite, por tanto, definir una clase modificando una o ms clases ya existentes. Estas modificaciones consisten habitualmente en aadir nuevos miembros (atributos o mtodos) a la clase que se est definiendo, aunque tambin se pueden redefinir atributos o mtodos ya existentes.
La clase base de la que se parte en este proceso recibe el nombre de superclase o clase padre, y la nueva clase que se obtiene se denomina subclase
- 118 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o clase hija. sta a su vez puede ser superclase en un nuevo proceso de derivacin, iniciando de esta manera una jerarqua de clases. De ordinario las superclases suelen ser ms generales que las subclases. Esto es as porque a las subclases se les suele ir aadiendo caractersticas, en definitiva atributos y mtodos que diferencian, concretan y particularizan.
En algunos casos una clase no tiene otra utilidad que la de ser superclase para otras clases que hereden de ella. A este tipo de superclases, de las que no se declara ningn objeto, se les denomina superclases abstractas y su funcin es la de agrupar miembros comunes de otras clases que heredarn de ellas. Por ejemplo, se puede definir la clase vehculo para despus derivar de ella coche, bicicleta, patinete, etc., pero todos los objetos que se declaren pertenecern a alguna de estas ltimas clases; no habr vehculos que sean slo vehculos. Las caractersticas comunes de estas clases (como un atributo que indique si est parado o en marcha, otro que indique su velocidad, el mtodo de arrancar y el de frenar, etc.), pertenecern a la superclase y las que sean particulares de alguna de ellas pertenecern slo a la subclase (por ejemplo el nmero de platos y piones, que slo tiene sentido para una bicicleta, o el mtodo embragar que slo se aplicar a los vehculos de motor con varias marchas).
Este mecanismo de herencia presenta mltiples ventajas evidentes a primera vista, si bien la ms importante y la que dota a la POO de gran potencia es la posibilidad de reutilizar cdigo sin tener que escribirlo de nuevo. Esto es posible porque todas las subclases pueden utilizar el cdigo de la superclase sin tener que volver a definirlo en cada una de ellas. Adems, la reusabilidad permite desarrollar nuevas clases (clases hija) tomando como referencia clases ya existentes (clases padre). Otra gran ventaja de la herencia es la eliminacin de redundancias ya que en la superclase se definen los mtodos y atributos comunes a las subclases.
Uno de los problemas que aparece con la herencia es el del control del acceso a los datos. Puede un mtodo de una subclase acceder a los atributos
- 119 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. privados de su superclase? En principio una clase no puede acceder a los atributos privados de otra, pero podra ser muy conveniente que una subclase accediera a todos los atributos de su superclase. Para hacer posible esto, existe el especificador de acceso protected. Este especificador es privado para todas aquellas clases que no son subclases, pero pblico para una subclase de la clase en la que se ha definido el atributo como protected.
A la hora de aplicar la herencia existen dos formas:
o por especializacin: la nueva clase especializa el comportamiento de la clase ya existente.
A Especializa Nueva Clase
En el ejemplo de herencia por especializacin de la figura, Nueva Clase hereda de A y A es, por tanto, una especializacin de NC (Nueva Clase). A ser la superclase o clase padre mientras que NC ser la subclase o clase hija. Como NC hereda de A se puede decir que NC es un A y que la subclase (NC) tendr los mismos mtodos y atributos que la superclase (A) as como lo que la subclase NC refinar para generalizar el comportamiento.
- 120 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o por generalizacin: la nueva clase generaliza el concepto de la clase ya existente.
Nueva Clase Generaliza A
En el ejemplo de herencia por generalizacin de la figura, Nueva Clase es una generalizacin de A. NC tendr, por tanto, los mismos mtodos y atributos de A as como aquellos que hayan sido implementados para llevar a cabo dicha generalizacin.
Para entender estos conceptos de forma ms clara se explicar un ejemplo del mundo real. Si se piensa en dos conceptos como son Trabajador y Persona se llega a las siguientes conclusiones:
o Trabajador es un refinamiento de Persona
o Trabajador especializa a Persona
Se puede decir entonces que Trabajador es una Persona. A continuacin se muestra el cdigo de este mismo ejemplo programado en C++ en MinGW Developer Studio.
- 121 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Clase Persona (fichero Persona.h)
// Declaracin de la Superclase Persona #include<iostream> using namespace std;
class Persona { protected: // Atributos string nombre; int edad; public: //Getters string getNombre(void){return nombre;} int getEdad(void){return edad;} //Setters void setNombre(string _nombre){nombre=_nombre;} void setEdad(int _edad){edad=_edad;} //Constructor Persona(string _nombre, int _edad) { nombre=_nombre; edad=_edad; } };
Antes de mostrar la clase Trabajador, que hereda de la clase Persona, es preciso mostrar la sintaxis para llevar a cabo la herencia:
class A {}; class B : public A {};
// Clase padre o superclase // Clase hija o subclase
- 122 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Clase Trabajador (fichero Trabajador.h)
// Declaracin de la Subclase Trabajador #include<iostream> using namespace std;
class Trabajador : public Persona { private: // Atributos long sueldo; string departamento; public: //Getters
// Trabajador subclase de Persona
long getSueldo(void){return sueldo;} string getDepartamento(void){return departamento;} //Setters void setSueldo(long _sueldo){sueldo=_sueldo;} void setDepartamento (string _departamento) {departamento=_departamento;} //Constructor Trabajador(string _nombre, int _edad, long _sueldo, string _departamento) : Persona(_nombre, _edad) { sueldo=_sueldo; departamento=_departamento; } };
A continuacin se muestra el programa principal en el que se crea un objeto de clase Trabajador y se muestra su informacin:
- 123 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Programa principal (fichero programa.cpp)
#include<iostream> // Se incluyen los ficheros donde se definen las clases #include "Persona.h" #include "Trabajador.h"
using namespace std;
int main(void) { Trabajador *t1; t1 = new Trabajador("Antonio", 54, 2500, "Finanzas"); cout<<endl<<"Trabajador 1 - Nombre: "<<t1->getNombre() <<" Edad: "<<t1->getEdad()<<" Sueldo: " <<t1->getSueldo()<<" Departamento: " <<t1->getDepartamento()<<endl; }
Explicacin del ejemplo de herencia Trabajador-Persona
o Persona.h: La superclase Persona es la misma que se mostr en el apartado 3.6 del captulo 3 exceptuando una modificacin que se realiz en el especificador de acceso de los atributos. El especificador pas de ser public a ser protected para permitir a la subclase (Trabajador) acceder a sus atributos. Este especificador es privado para todas aquellas clases que no son subclases de la clase Persona.
o Trabajador.h: La subclase Trabajador hereda de la clase Persona por lo que en su definicin se especifica esta situacin mediante la sentencia class Trabajador : public Persona. La clase Trabajador tendr, por tanto, los mismos mtodos y atributos que la clase Persona, su superclase. Adems, tiene dos atributos adicionales como son el sueldo y el departamento en el que trabaja. Estos atributos son accedidos por medio de los getters y setters que tambin se definen en la clase
- 124 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Trabajador. Por ltimo, el constructor tendr como parmetros sus atributos as como los de la superclase y se invocar el constructor de la superclase mediante una llamada directa por medio de la sentencia Trabajador(string string _nombre, : int _edad, long _sueldo,
_departamento)
Persona(_nombre,
_edad) que
permitir crear un objeto de la clase Trabajador sin necesidad de reescribir el cdigo necesario para definir los atributos de la superclase. El constructor de la clase padre es invocado siempre (de forma directa o indirectamente) antes de la ejecucin del constructor de la subclase. o Programa.cpp: El programa principal necesita conocer la definicin de la clase Persona y de su subclase Trabajador. Es por ello que es necesario incluir mediante la directiva #include los dos ficheros de cabecera donde se definen ambas clases. En el programa se crea un objeto de la clase Trabajador con un nombre, una edad, un sueldo y un departamento en el que trabaja. Hay que recordar que aunque nombre y edad son atributos de la clase Persona, la clase Trabajador hereda de sta por lo que dichos atributos tambin pertenecern a la subclase. Una vez creado el objeto t1 de clase Trabajador se muestra su informacin invocando los mtodos correspondientes.
A continuacin se muestra la salida por pantalla tras la ejecucin del cdigo mostrado anteriormente:
- 125 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Ahora se mostrar un diagrama del ejemplo anterior donde se visualizar de manera clara el funcionamiento de la herencia.
Como se puede observar en la figura, la subclase Trabajador hereda los atributos y mtodos de la superclase Persona. Adems, define dos atributos y sus correspondientes mtodos que refinan y especializan a la clase Persona. Estos atributos y mtodos aparecen subrayados en color rojo en la figura. El constructor de Trabajador tendr por parmetros los atributos heredados de Persona as como los definidos en la propia clase.
- 126 -
4.4.1. Herencia mltiple.

Hasta ahora se ha explicado la herencia simple, donde una clase slo puede heredar de una superclase. Pues bien, la herencia mltiple permite que una clase pueda heredar comportamientos y caractersticas de ms de una superclase.
La herencia mltiple permite a una clase tomar funcionalidades de otras clases, como permitir a una clase llamada Hidroplano heredar de una clase llamada Aeroplano y una clase llamada Barco. La sintaxis necesaria para llevar a cabo la herencia mltiple en C++ se muestra a continuacin:
class Aeroplano {}; class Barco {}; class Hidroplano : public Aeroplano, public Barco {};
En la herencia mltiple aparecen ambigedades, por lo que debe usarse con cuidado ya que pueden presentarse problemas como los siguientes:
o Una misma clase no debe especificarse dos o ms veces como superclase de una dada. Este hecho puede producirse indirectamente como en el caso:
class A {}; class B : public A {}; class C : public A {}; class D : public B, public C {};
- 127 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Una clase no puede heredar un mismo atributo o mtodo de dos superclases.
Cada lenguaje de programacin trata estos problemas de herencia mltiple de forma diferente. En el caso de C++, el lenguaje requiere que el programador establezca de qu clase padre vendr la caracterstica a usar por medio del operador :: tal y como se muestra a continuacin:
Subclase :: Superclase.nombre_Atributo Subclase :: Superclase.nombre_Mtodo
4.5. Polimorfismo.
Se entiende por polimorfismo la capacidad de definir mtodos distintos, que comparten el mismo nombre, pero que se aplican a clases diferentes. Estos mtodos pueden actuar sobre objetos distintos dentro de una jerarqua de clases, sin tener que especificar el tipo exacto de los objetos. Esto se puede entender mejor con el siguiente ejemplo:
Clase Tringulo + Pintar()
Clase Cuadrado + Pintar()
En el ejemplo que se ve en la figura se observa una jerarqua de clases. En los dos niveles de esta jerarqua est contenido un mtodo llamado Pintar(). Este mtodo no tiene por qu ser igual en todas las clases, aunque es habitual
- 128 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. que sea un mtodo que efecte una operacin muy parecida sobre distintos tipos de objetos.
Es importante comprender que el compilador no decide en tiempo de compilacin cul ser el mtodo que se debe utilizar en un momento dado del programa. Esa decisin se toma en tiempo de ejecucin. A este proceso de decisin en tiempo de ejecucin se le denomina vinculacin dinmica, en oposicin a la habitual vinculacin esttica, consistente en decidir en tiempo de compilacin qu mtodo se aplica en cada caso.
A este tipo de mtodos, incluidos en varios niveles de una jerarqua de clases con el mismo nombre pero con distinta definicin se les denomina mtodos virtuales. Hay que insistir en que la definicin del mtodo en cada nivel es distinta.
El polimorfismo hace posible que un usuario pueda aadir nuevas clases a una jerarqua sin modificar o recompilar el cdigo original. Esto quiere decir que si desea aadir una nueva subclase es suficiente con establecer la clase padre, definir sus atributos y mtodos, y compilar esta parte del cdigo, ensamblndolo despus con lo que ya estaba compilado previamente.
Es necesario comentar que los mtodos virtuales son algo menos eficientes que los mtodos normales. A continuacin se explica, sin entrar en gran detalle, el funcionamiento de los mtodos virtuales. Cada clase que utiliza mtodos virtuales tiene un vector de punteros, uno por cada mtodo virtual, llamado v-table. Cada uno de los punteros contenidos en ese vector apunta al mtodo virtual apropiado para esa clase, que ser, habitualmente, el mtodo virtual definido en la propia clase. En el caso de que en esa clase no est definido el mtodo virtual en cuestin, el puntero de v-table apuntar al mtodo virtual de su clase padre ms prxima en la jerarqua, que tenga una definicin propia del mtodo virtual. Esto quiere decir que buscar primero en la propia
- 129 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. clase, luego en la clase anterior en el orden jerrquico y se ir subiendo en ese orden hasta dar con una clase que tenga definido el mtodo buscado.
Cada objeto creado de una clase que tenga un mtodo virtual contiene un puntero oculto a la v-table de su clase. Mediante ese puntero accede a su vtable correspondiente y a travs de esta tabla accede a la definicin adecuada del mtodo virtual. Es este trabajo extra el que hace que los mtodos virtuales sean menos eficientes que los mtodos normales.
Como ejemplo se puede suponer la clase Trabajador y la clase Mecanico. Ambas tienen el mtodo calcularSueldo() pero con la siguiente diferencia: o Trabajador: el sueldo se calcula como el nmero de horas trabajadas multiplicado por 6. o Mecanico: el sueldo se calcula como el nmero de horas trabajadas multiplicado por 20. Adems, se aade un extra de 100 por cada reparacin que realice en el plazo de reparacin establecido.
El cdigo correspondiente a los mtodos explicados sera el siguiente:

// mtodo virtual de la clase Trabajador virtual void calcularSueldo() { //El mtodo getNumhoras() devuelve el nmero de horas trabajadas sueldo=this.getNumhoras()*6; }
// mtodo virtual de la clase Mecanico virtual void calcularSueldo() { //El mtodo getNumhoras() devuelve el nmero de horas trabajadas //El mtodo getNumrep() devuelve el nmero de reparaciones //realizadas dentro del plazo establecido sueldo=this.getNumhoras()*20 + this.getNumrep()*100; }
- 130 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. La idea central del polimorfismo es la de poder llamar a mtodos distintos aunque tengan el mismo nombre, segn la clase a la que pertenece el objeto al que se aplican. Esto es imposible utilizando nombres de objetos: siempre se aplica el mtodo de la clase correspondiente al nombre del objeto y esto se decide en tiempo de compilacin.
Sin embargo, utilizando punteros puede conseguirse el objetivo buscado. Recurdese que un puntero a la clase padre puede contener direcciones de objetos de cualquiera de las subclases. En principio, el tipo de puntero determina tambin el mtodo que es llamado, pero si se utilizan mtodos virtuales es el tipo de objeto al que apunta el puntero lo que determina el mtodo que se llama. Esta es la esencia del polimorfismo.
4.5.1. Implementacin de los mtodos virtuales.

Un mtodo virtual puede ser llamado como un mtodo convencional, es decir, utilizando vinculacin esttica. En este caso no se estn aprovechando las caractersticas de los mtodos virtuales, pero el programa puede funcionar correctamente. A continuacin se presenta un ejemplo de este tipo de implementacin que no es recomendable usar, ya que utilizando un mtodo convencional se ganara en eficiencia:
Clase_A Objeto_1; Clase_A *Puntero_1; float atributo;
// Se definen un objeto de una clase // y un puntero que puede apuntarlo
Puntero_1 = &Objeto_1; atributo = Objeto_1.metodo_1(); //Utilizacin de vinculacin esttica
atributo = Puntero_1->metodo_1();//Con mtodos virtuales. Absurdo
En el ejemplo anterior en las dos asignaciones a la variable atributo, los mtodos que se van a utilizar se determinan en tiempo de compilacin.
- 131 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. A continuacin se presenta un ejemplo de utilizacin correcta de los mtodos virtuales:
Clase_Padre Objeto_Padre; Clase_Hija Objeto_Hijo; Clase_Padre *Puntero_Padre_1; Clase_Padre *Puntero_Padre_2; float atributo;
... // El puntero a la clase padre puede apuntar a un objeto de la clase // padre Puntero_Padre_1 = &Objeto_Padre; // o a un objeto de la clase hija Puntero_Padre_2 = &Objeto_Hijo; ... // Utilizacin correcta de un mtodo virtual atributo = Puntero_Padre_2->metodo_1();
En este nuevo ejemplo se utiliza vinculacin dinmica, ya que el Puntero_Padre_2 puede apuntar a un objeto de la clase padre o a un objeto de cualquiera de las clases hija en el momento de la asignacin a la variable atributo, en la ltima lnea del ejemplo. Por eso, es necesariamente en tiempo de ejecucin cuando el programa decide cul es el metodo_1 concreto que tiene que utilizar.
Ese metodo_1 ser el definido para la clase del Objeto_Hijo si est definido, o la de la clase padre ms prxima en el orden jerrquico que tenga definido ese metodo_1.
- 132 -
4.5.2. Mtodos virtuales puros.

Habitualmente los mtodos virtuales de la clase padre de la jerarqua no se utilizan porque en la mayora de los casos no se declaran objetos de esa clase, y/o porque todas las subclases tienen su propia definicin del mtodo virtual. Sin embargo, incluso en el caso de que el mtodo virtual de la clase padre no vaya a ser utilizado, debe declararse.
De todos modos, si el mtodo no va a ser utilizado es necesario definirlo, y es suficiente con declararlo como mtodo virtual puro. Un mtodo virtual puro se declara as:
Virtual metodo_1()=0;
// Mtodo virtual puro
La nica utilidad de esta declaracin es la de posibilitar la definicin de mtodos virtuales en las subclases. De alguna manera se puede decir que la definicin de un mtodo como virtual puro hace necesaria la definicin de ese mtodo en las subclases, a la vez que imposibilita su utilizacin con objetos de la superclase.
Al definir un mtodo virtual se debe tener en cuenta que:
o No hace falta definir el cdigo de ese mtodo en la superclase.
o No se pueden definir objetos de la superclase, ya que no se puede llamar a los mtodos virtuales puros.
o Sin embargo, es posible definir punteros a la superclase, pues es a travs de ellos como ser posible manejar objetos de las subclases.
- 133 -
4.5.3. Clases abstractas.

Se denomina clase abstracta a aquella que contiene uno o ms mtodos virtuales puros. El nombre se debe a que no puede existir ningn objeto de esa clase. Si una subclase no redefine un mtodo virtual, la subclase la hereda como mtodo virtual puro y se convierte tambin en clase abstracta. Por el contrario, aquellas subclases que redefinen todos los mtodos virtuales puros de sus superclases reciben el nombre de subclases concretas, nomenclatura
nicamente utilizada para diferenciarlas de las mencionadas anteriormente.
Aparentemente puede parecer que carece de sentido definir una clase de la que no va a existir ningn objeto, pero se puede afirmar, sin miedo a equivocarse, que la abstraccin es una herramienta imprescindible para un correcto diseo de la Programacin Orientada a Objetos.
Es evidente que la jerarqua que se presenta en la figura sobre estas lneas no es suficiente, porque un avin y un helicptero, o un patinete y una bicicleta, seran objetos de la misma clase. Pero lo que se pretende ilustrar es la necesidad de una clase Vehculo que englobe las caractersticas comunes de todos ellos (dimensiones, peso, velocidad mxima,) aunque no exista ningn objeto de esa clase, ya que cualquier vehculo en el que se piense, podr definirse como un objeto de una subclase de la primera superclase.
- 134 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Habitualmente las clases superiores de muchas jerarquas de clases son clases abstractas y las clases que heredan de ellas definen sus propios mtodos virtuales, convirtindose as en clases concretas.
4.5.4. Destructores virtuales.

Como norma general, el constructor de la superclase se llama antes que el constructor de la subclase. Con los destructores, sin embargo, sucede al revs: el destructor de la subclase se llama antes que el de la superclase.
Por esa razn, en el caso de que se borre, aplicando delete, un puntero a un objeto de la superclase que apunte a un objeto de una subclase, se llamar al destructor de la superclase, en vez de al destructor de la subclase, que sera lo adecuado. La solucin a este problema consiste en declarar como virtual el destructor de la superclase. Esto hace que automticamente los destructores de las subclases sean tambin virtuales, a pesar de tener nombres distintos.
De este modo, al aplicar delete a un puntero de la superclase que puede apuntar a un puntero de ese tipo o a cualquier objeto de una subclase, se aplica el destructor adecuado en cada caso. Por eso es conveniente declarar un destructor virtual en todas las clases abstractas, ya que aunque no sea necesario para esa clase, s puede serlo para una clase que herede de ella.
Este problema no se presenta con los constructores y por eso no existe ningn tipo de constructor virtual o similar.
- 135 -
PARTE III: Estudio de las libreras grficas del compilador para desarrollar permitir desarrollar grfica interfaces grficas de usuario (GUI)
- 136 -
Captulo
Introduccin
- 137 -
CAPTULO 1. Introduccin.
La interaccin entre las personas y los ordenadores en la actualidad se realiza principalmente a travs de interfaces grficas de usuario (Graphical User Interfaces - GUI), un tipo de interfaz de usuario compuesto por metforas grficas inscritas en una superficie de contacto. Esta superficie contiene adems otros elementos como los iconos, botones, controles, etc. e interfaces humanos (dispositivos de entrada como el ratn o el teclado) necesarios para posibilitar dicha interaccin con los signos-objetos en la interfaz grfica.
El concepto de interfaz de usuario es un concepto amplio que se utiliza para referirse de forma genrica al espacio que media la relacin de un sujeto y un ordenador o sistema interactivo. El interfaz de usuario es esa ventana mgica de un sistema informtico que posibilita a una persona interactuar con l. Cuando se habla de interfaz grfica de usuario, el concepto es an ms especfico en cuanto que supone un tipo especfico de interfaz que usa metforas visuales y signos grficos como paradigma interactivo entre la persona y el ordenador. La interfaz grfica de usuario se define, pues, como un mtodo de interaccin con un ordenador a travs del paradigma de manipulacin directa de imgenes grficas, controles y texto.
En el contexto del proceso de interaccin persona-ordenador, la interfaz grfica de usuario es el artefacto tecnolgico de un sistema interactivo que posibilita, a travs del uso y la representacin del lenguaje visual, una interaccin amigable con un sistema informtico. La interfaz grfica de usuario es un tipo de interfaz de usuario que utiliza un conjunto de imgenes y objetos grficos para representar la informacin y acciones disponibles en la interfaz. Habitualmente las acciones se realizan mediante manipulacin directa para facilitar la interaccin del usuario con el ordenador.
- 138 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Las interfaces grficas de usuario surgen como evolucin de la lnea de comandos de los primeros sistemas operativos y son pieza fundamental en un entorno grfico. Como ejemplo de interfaces grficas de usuario se pueden citar el escritorio o desktop del sistema operativo Windows, el entorno X-Window de Linux o el entorno Finder de Mac OS X. La historia reciente de la informtica est indisolublemente unida a las interfaces grficas, puesto que los sistemas operativos grficos han ocasionado grandes consecuencias en la industria del software y del hardware. Las interfaces grficas surgen de la necesidad de hacer los ordenadores ms accesibles para el uso de los usuarios comunes. La mayora de ordenadores domsticos requeran conocimientos de BASIC (el 95% de ellos mostraban el intrprete BASIC al encenderse) u ofrecan una interfaz de lnea de rdenes (como los sistemas operativos CP/M o los diferentes OS del Apple II), lo que requera conocimientos por encima de la media si se deseaba hacer algo ms que usarlo como consola de videojuegos. Esta limitacin fue salvada gracias al desarrollo de los entornos grficos, que permitieron que las personas pudieran acceder a un ordenador sin tener que pasar por el tortuoso proceso de tener que aprender a manejar un entorno bajo lnea de rdenes.
- 139 -
Captulo
API de Windows (WinAPI)
- 140 -
CAPTULO 2. API de Windows.

A la hora de programar interfaces grficas de usuario (GUI) mediante MinGW Developer Studio se emplea el API (Application Programs Interface) de Windows, tambin conocido como WinAPI.
2.1. Introduccin.
El API de Windows, WinAPI, es un conjunto de interfaces de programacin de aplicaciones (application programming interfaces - API) de Microsoft disponible en los sistemas operativos Microsoft Windows. Todos los programas Windows deben interactuar con el API de Windows sin importar el lenguaje de programacin. La Windows Driver Foundation o API Nativa (Native API), utilizada principalmente por drivers de dispositivo, proporciona acceso de bajo nivel a sistemas Windows.
El API de Windows est formado por ms de 600 funciones en lenguaje de programacin C. Para acceder a ella los compiladores utilizan libreras de objetos, permitiendo acceder al API de manera ms rpida y sencilla. La librera de MinGW Developer Studio que permite dicho acceso es windows.h.
Hasta 1985, los ordenadores empleaban el sistema operativo MS-DOS. Este sistema operativo funcionaba a base de interrupciones de tal modo que cada vez que un programa necesitaba hacer algo, llamaba a una interrupcin, servicio de BIOS o de DOS. Sin embargo, en Agosto de 1985 apareci en el mercado la primera versin de Windows que dispona de interfaz grfica de usuario y con ella se produjo un cambio radical. Este cambio se basa en que en Windows es el propio sistema operativo el que llama al programa por medio de mensajes cada vez que se mueve el ratn, se pulsa una tecla del teclado o se produce lo que se conoce como evento. Cuando esto sucede, el sistema operativo avisa al programa del cambio (evento) por medio de un mensaje y ste
- 141 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. decide si quiere llamar a una interrupcin que lo controle. En caso de llamar a una interrupcin de DOS se har por medio del API de Windows.
En Windows se dispone de un kit de desarrollo software (software development kit - SDK) que proporciona documentacin y herramientas para permitir a los desarrolladores crear software usando el API de Windows y las tecnologas asociadas a Windows.
La funcionalidad que proporciona el API de Windows se puede agrupar en ocho categoras: o Servicios Bsicos (Base Services) o Servicios Avanzados (Advanced Services) o Interfaz de Grficos de Dispositivos (Graphics Device Interface) o User Interface (Interfaz de Usuario) o Librera Comn de Cuadro de Dilogo (Common Dialog Box Library) o Librera Comn de Control (Common Control Library) o Shell de Windows (Windows Shell) o Servicios de Red (Network Services)
La categora en la que se profundizar ser la de Interfaz de Usuario (User Interface) ya que es la que proporciona la funcionalidad para crear y gestionar ventanas y controles bsicos como botones y cajas de texto, recibir eventos del ratn y el teclado, y otra funcionalidad asociada con la parte GUI de Windows. Esta unidad funcional reside en el fichero user.exe en Windows de 16 bits y en el fichero user32.dll en Windows de 32 bits. Desde la primera versin de Windows XP, los controles bsicos residen en el fichero comctl32.dll, junto con los controles bsicos (Common Control Library).
- 142 -
2.2. Caractersticas de la programacin en Windows.

A la hora de explicar la forma en que se programan las interfaces grficas de usuario en Windows usando el API es preciso explicar una serie de caractersticas especiales de la programacin en Windows como son la independencia, los recursos, las ventanas, los eventos y los controles.
2.2.1. Independencia de la mquina.

Los programas Windows son independientes de la mquina en la que se ejecutan (o al menos deberan serlo), el acceso a los dispositivos fsicos se hace a travs de interfaces, y nunca se accede directamente a ellos. Esta es una de las principales ventajas para el programador, que no tiene que preocuparse por el modelo de tarjeta grfica o de impresora que emplea puesto que la aplicacin funcionar con todas, y ser el sistema operativo el que se encargue de que as sea.
2.2.2. Recursos.
Un concepto importante es el de recurso. Desde el punto de vista de Windows, un recurso es todo aquello que puede ser usado por una o varias aplicaciones. Existen recursos fsicos, que son los dispositivos que componen el ordenador, como la memoria, la impresora, el teclado o el ratn y recursos virtuales o lgicos, como los grficos, los iconos o las cadenas de caracteres.
Por ejemplo, si una aplicacin requiere el uso de un puerto serie, primero debe averiguar si est disponible, es decir, si existe y si no lo est usando otra aplicacin; y despus lo reservar para su uso. Esto es necesario porque este tipo de recurso no puede ser compartido.
Lo mismo pasa con la memoria o con la tarjeta de sonido, aunque son casos diferentes. Por ejemplo, la memoria puede ser compartida, pero de una
- 143 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. forma general, cada porcin de memoria no puede compartirse y se trata de un recurso finito. Las tarjetas de sonido, dependiendo del modelo, podrn o no compartirse por varias aplicaciones. Otros recursos como el ratn y el teclado tambin se comparten, pero se asigna su uso automticamente a la aplicacin activa, que normalmente se conoce como la que tiene el "foco", es decir, la que mantiene contacto con el usuario.
Desde el punto de vista del programador de aplicaciones, tambin se consideran como recursos varios componentes como los mens, los iconos, los cuadros de dilogo, las cadenas de caracteres, los mapas de bits, los cursores, etc. En los programas, Windows almacena separados el cdigo y los recursos, dentro del mismo fichero, y estos ltimos pueden ser editados por separado, permitiendo por ejemplo, hacer versiones de los programas en distintos idiomas sin tener acceso a los ficheros fuente de la aplicacin.
2.2.3. Ventanas.
La forma en que se presentan las aplicaciones Windows (al menos las interactivas) ante el usuario, es la ventana. Una ventana es un rea rectangular de la pantalla que se usa de interfaz entre la aplicacin y el usuario.
Cada aplicacin tiene al menos una ventana, la ventana principal, y todas las comunicaciones entre usuario y aplicacin se canalizan a travs de una ventana. Cada ventana comparte el espacio de la pantalla con otras ventanas, incluso de otras aplicaciones, aunque slo una puede estar activa, es decir, slo una puede recibir informacin del usuario.
2.2.4. Eventos.
Los programas en Windows estn orientados a eventos, es decir, normalmente estn esperando a que se produzca un acontecimiento que les incumba, y mientras tanto permanecen dormidos.
- 144 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Un evento puede ser, por ejemplo, el movimiento del ratn, la activacin de un men, la llegada de informacin desde el puerto serie, una pulsacin de una tecla, etc.
Esto se debe a que Windows es un sistema operativo multitarea, y el tiempo del microprocesador ha de repartirse entre todos los programas que se estn ejecutando. Si los programas fueran secuenciales puros, esto no sera posible, ya que hasta que una aplicacin finalizara, el sistema no podra atender al resto.
Ejemplo de programa secuencial:
- 145 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Ejemplo de programa por eventos:
2.2.5. Controles.
Los controles son la forma en que las aplicaciones Windows intercambian datos con el usuario. Normalmente se usan dentro de los cuadros de dilogo, pero en realidad pueden usarse en cualquier ventana. Los ms importantes y conocidos son: o control static: son etiquetas, marcos, iconos o dibujos. o control edit: permiten que el usuario introduzca datos alfanumricos en la aplicacin. o control list box: el usuario puede escoger entre varias opciones de una lista. o control combo box: es una combinacin entre un edit y un list box. o control scroll bar: barras de desplazamiento, para la introduccin de valores entre mrgenes definidos.
- 146 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o control button: realizan acciones o comandos. Del control button derivan otros dos controles muy comunes:
control check box: permite leer variables de dos estados "checked" o "unchecked".
control radio button: se usa en grupos. Dentro de cada grupo slo uno puede ser activado.
2.3. Creacin de proyectos WinAPI en MinGW Developer Studio.

Inicialmente, el rea de trabajo del entorno de desarrollo est vaca. Para crear ahora la estructura de una nueva aplicacin WinAPI, se procede del siguiente modo:
- 147 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. b. A continuacin, se presenta una ventana en la que se puede elegir el tipo de aplicacin que se desea crear. Se selecciona la pestaa Projects y la aplicacin de tipo Win32 Application. Ahora se procede a nombrar el proyecto escribiendo el nombre que se desea en el cuadro Project name. En el cuadro Location se permite especificar la ruta de acceso al directorio, es decir, el directorio donde se crear la carpeta de nombre igual al del proyecto y que contendr todos los ficheros relativos al proyecto (ejecutables, cdigo fuente, etc.). Una vez especificado el nombre del proyecto y la ruta de acceso se confirma el cuadro de dilogo pulsando OK y ya se ha creado un proyecto nuevo. En el directorio especificado en el cuadro Location se habr creado un fichero llamado nombre_del_proyecto.msp/mdsp (MinGWStudio Project Files).
Se selecciona la pestaa Files y el fichero de tipo C/C++ Source File para crear un fichero de lenguaje de programacin C (*.c) que contenga el cdigo fuente. Se nombra el fichero (se debe aadir la extensin .c) en el cuadro File name y se confirma pulsando OK. El campo Location no debe ser modificado ya que por defecto se muestra la ruta de acceso al directorio del proyecto creado anteriormente. Adems, la checkbox Add to project se encuentra activada para aadir el fichero al proyecto que se
- 148 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. haba creado previamente. Por tanto, la ruta de acceso y la checkbox no deben ser modificadas. En el directorio del proyecto se habr creado un fichero llamado nombre_del_fichero.c (C Source File).
- 149 -
2.4. Componentes de una ventana.

En este apartado se vern los elementos que componen una ventana, si bien no todos tienen por qu estar presentes en todas las ventanas.
1) El borde de la ventana: hay varios tipos, dependiendo de que estn o no activas las opciones de cambiar el tamao de la ventana. Se trata de un rea estrecha alrededor de la ventana que permite cambiar su tamao.
2) Barra de ttulo: zona en la parte superior de la ventana que contiene el icono y el ttulo de la ventana. Esta zona tambin se usa para mover la ventana a travs de la pantalla, y mediante doble clic, para cambiar entre el modo maximizado y el tamao normal.
3) Caja de minimizar: pequea rea cuadrada situada en la parte derecha de la barra de ttulo que sirve para disminuir el tamao de la ventana. Antes de la aparicin de Windows 95 la ventana se converta a su forma icnica, pero desde la aparicin de Windows 95 los iconos desaparecieron, la ventana se oculta y slo permanece un botn en la barra de estado. 4) Caja de maximizar: pequea rea cuadrada situada en la parte derecha de la barra de ttulo que sirve para agrandar la ventana para que ocupe toda la pantalla. Cuando la ventana est maximizada, se sustituye por la caja de restaurar.
- 150 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. 5) Caja de cerrar: pequea rea cuadrada situada en la parte derecha de la barra de ttulo que sirve para cerrar la ventana. 6) Caja de control de men: pequea rea cuadrada situada en la parte izquierda de la barra de ttulo que normalmente contiene el icono de la ventana, y sirve para desplegar el men del sistema. Men (o men del sistema): se trata de una ventana especial que contiene las funciones comunes a todas las ventanas, tambin accesibles desde las cajas y el borde, como minimizar, restaurar, maximizar, mover, cambiar tamao y cerrar. Este men se despliega al pulsar sobre la caja de control de men. 7) Barra de men: zona situada debajo de la barra de ttulo que contiene los mens de la aplicacin. 8) Barra de scroll horizontal: barra situada en la parte inferior de la ventana que permite desplazar horizontalmente la vista del rea del cliente. 9) Barra de scroll vertical: barra situada en la parte derecha de la ventana que permite desplazar verticalmente la vista del rea de cliente. 10) rea de cliente: es la zona donde el programador sita los controles y los datos para el usuario. En general es toda la superficie de la ventana que no est ocupada por las zonas anteriormente descritas.
- 151 -
2.5. Notacin hngara.

La notacin hngara es un sistema usado normalmente para crear los nombres de variables, tipos y estructuras cuando se programa en Windows. Es el sistema usado en la programacin del sistema operativo, y tambin por la mayora de los programadores. Fundamentalmente ayudar a interpretar el tipo bsico al que pertenece cada estructura, miembro o tipo definido.
Consiste en prefijos en minsculas que se aaden a los nombres de las variables, y que indican su tipo; en el caso de tipos definidos, las letras del prefijo estarn en mayscula. El resto del nombre indica la funcin que realiza la variable o tipo.
A continuacin se muestra una tabla con el significado de los prefijos ms utilizados en notacin hngara:
Prefijo b c dw f h l lp lpfn lpsz n p pt rgb sz u w Booleano Carcter (un byte)
Significado
Entero largo de 32 bits sin signo (DOBLE WORD) Flags empaquetados en un entero de 16 bits Manipulador de 16 bits (HANDLE) Entero largo de 32 bits Puntero a entero largo de 32 bits Puntero largo a una funcin que devuelve un entero Puntero largo a una cadena terminada con cero Entero de 16 bits Puntero a entero de 16 bits Coordenadas (x, y) empaquetadas en un entero de 32 bits Valor de color RGB empaquetado en un entero de 32 bits Cadena terminada en cero Sin signo (unsigned) Entero corto de 16 bits sin signo (WORD)
- 152 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Por ltimo se muestran una serie de ejemplos de variables creadas con notacin hngara as como ejemplos de tipos definidos por el API de Windows:
o nContador: la variable es un entero que se usar como contador.
o szNombre: una cadena terminada con cero que almacena un nombre.
o bRespuesta: una variable booleana que almacena una respuesta.
Ejemplos de tipos definidos por el API de Windows:
o UINT: entero sin signo. Windows redefine los enteros para asegurar que el tamao en bits es siempre el mismo para todas las variables del API.
o LRESULT: entero largo usado como valor de retorno.
o WPARAM: entero corto de 16 bits usado como parmetro.
o LPARAM: entero largo de 32 bits usado como parmetro.
o LPSTR: puntero largo a una cadena de caracteres. En el API de 32 bits no existen distinciones entre punteros largos y cortos, pero la nomenclatura se conserva por compatibilidad.
o LPCREATESTRUCT: puntero a una estructura CREATESTRUCT, que define los parmetros de inicializacin pasados al procedimiento ventana de una aplicacin.
- 153 -
2.6. Estructura de un programa Windows GUI.

Hay algunas diferencias entre la estructura de un programa C/C++ normal y la correspondiente a un programa Windows GUI. Algunas de estas diferencias se deben a que los programas GUI estn basados en mensajes mientras que otras son sencillamente debidas a que siempre hay un determinado nmero de tareas que hay que realizar.
// Ficheros include #include <windows.h> // Prototipos LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM); // Funcin de entrada int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow) { // Declaracin // Inicializacin // Bucle de mensajes return Message.wParam; } // Definicin de funciones
2.6.1. Cabeceras.
Lo primero que hay que hacer para poder usar las funciones del API de Windows es incluir al menos un fichero de cabecera, pero generalmente no bastar con uno.
La librera windows.h contiene la mayora de los ficheros de cabecera corrientes en aplicaciones GUI, pero se pueden incluir slo los que se necesiten, siempre que se sepa cules son. Por ejemplo, la funcin WinMain est declarada en el fichero de cabecera winbase.h.
- 154 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Generalmente esto resultar incmodo, ya que para cada nueva funcin, mensaje o estructura habr que comprobar, y si es necesario, incluir nuevos ficheros. Por ello se usa directamente windows.h.
2.6.2. Prototipos.
Cada tipo (o clase) de ventana que se use en un programa (normalmente slo ser una), o cuadro de dilogo (puede haber muchos), necesitar un procedimiento propio, que se debe declarar y definir. Siguiendo la estructura de un programa C, esta es la zona normal de declaracin de prototipos.
2.6.3. Funcin de de entrada WinMain.

La funcin de entrada de un programa Windows es WinMain, en lugar de la conocida main. Normalmente, la definicin de esta funcin cambia muy poco de unas aplicaciones a otras. Se divide en tres partes claramente diferenciadas: declaracin, inicializacin y bucle de mensajes.
2.6.3.1. Parmetros de entrada de WinMain.

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow)
La funcin WinMain tiene cuatro parmetros de entrada:
o hInstance: es un manipulador para la instancia del programa que se est ejecutando. Cada vez que se ejecuta una aplicacin, Windows crea una instancia para ella, y le pasa un manipulador de dicha instancia a la aplicacin.
o hPrevInstance: es un manipulador a instancias previas de la misma aplicacin. Como Windows es multitarea, pueden existir varias versiones
- 155 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. de la misma aplicacin ejecutndose, varias instancias. En Windows 3.1, este parmetro serva para saber si la aplicacin ya se estaba ejecutando, y de ese modo se podan compartir los datos comunes a todas las instancias. Pero eso era antes, ya que Win32 usa un segmento distinto para cada instancia y este parmetro es siempre NULL, slo se conserva por motivos de compatibilidad.
o lpszCmdParam: esta cadena contiene los argumentos de entrada del comando de lnea.
o nCmdShow: este parmetro especifica cmo se mostrar la ventana. Se recomienda no usar este parmetro en la funcin ShowWindow la primera vez que sta es llamada. En su lugar debe usarse el valor SW_SHOWDEFAULT.
2.6.3.2. Funcin WinMain tpica.

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow) { HWND hwnd; MSG mensaje; /* Manipulador de ventana */ /* Mensajes recibidos por la aplicacin */
WNDCLASSEX wincl; /*Estructura de datos para la clase de ventana*/
/* Inicializacin: */ /* Estructura de la ventana */ wincl.hInstance = hInstance; wincl.lpszClassName = "NOMBRE_CLASE"; wincl.lpfnWndProc = WindowProcedure; wincl.style = CS_DBLCLKS; wincl.cbSize = sizeof(WNDCLASSEX);
/* Usar icono y puntero por defecto */
- 156 -

wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION); wincl.hCursor = LoadCursor(NULL, IDC_ARROW); wincl.lpszMenuName = NULL; wincl.cbClsExtra = 0; wincl.cbWndExtra = 0; wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND;
/* Registrar la clase de ventana, si falla, salir del programa */ if(!RegisterClassEx(&wincl)) return 0;
hwnd = CreateWindowEx( 0, "NOMBRE_CLASE", "Ventana 1", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 544, 375, HWND_DESKTOP, NULL, hInstance, NULL );
ShowWindow(hwnd, SW_SHOWDEFAULT);
/* Bucle de mensajes: */ while(TRUE == GetMessage(&mensaje, 0, 0, 0)) { TranslateMessage(&mensaje); DispatchMessage(&mensaje); }
return mensaje.wParam; }
- 157 -
2.6.3.3. Declaracin.
En la primera zona se declaran las variables que se necesitan para la funcin WinMain, que como mnimo sern tres:
HWND hwnd: es un manipulador para la ventana principal de la aplicacin. Se sabe pues que la aplicacin necesitar al menos una ventana.
MSG mensaje: es una variable para manipular los mensajes que lleguen a la aplicacin.
WNDCLASSEX wincl: es una estructura que se usar para registrar la clase particular de ventana que se usar en la aplicacin.
2.6.3.4. Inicializacin.
Esta zona se encarga de registrar la clase o clases de ventana, crear la ventana y visualizarla en pantalla.
Para registrar la clase primero hay que rellenar adecuadamente la estructura WNDCLASSEX, que define algunas caractersticas que sern comunes a todas las ventanas de una misma clase como color de fondo, icono, men por defecto, el procedimiento de ventana, etc. Despus hay que llamar a la funcin RegisterClassEx.
A continuacin se crea la ventana usando la funcin CreateWindowEx. Cualquiera de estas dos funciones devuelve un manipulador de ventana que se puede necesitar en otras funciones como, por ejemplo, la funcin ShowWindow.
Lo descrito anteriormente es fundamental pero esto no muestra la ventana en la pantalla. Para que la ventana sea visible hay que llamar a la funcin ShowWindow. La primera vez que se llama a esta funcin, despus de - 158 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. crear la ventana, se puede usar el parmetro nCmdShow de WinMain como parmetro o usar el valor SW_SHOWDEFAULT, opcin sta recomendada por Windows.
2.6.3.5. Bucle de mensajes.

Este es el ncleo de la aplicacin. Tal y como se observa en el cdigo, el programa permanece en este bucle mientras la funcin GetMessage devuelve un valor TRUE.
while(TRUE == GetMessage(&mensaje, 0, 0, 0)) { TranslateMessage(&mensaje); DispatchMessage(&mensaje); }
La funcin TranslateMessage se usa para traducir los mensajes de teclas virtuales a mensajes de carcter.
Los mensajes traducidos se reenvan a la lista de mensajes del proceso, y se recuperarn con las siguientes llamadas a GetMessage.
La funcin DispatchMessage enva el mensaje al procedimiento de ventana, donde ser tratado adecuadamente. El procedimiento de ventana se explicar en el punto 2.7 y una vez explicado se estar en disposicin de crear una interfaz grfica de usuario mediante MinGW Developer Studio.
2.6.4. Definicin de funciones.

En esta zona se definen, entre otras cosas, los procedimientos de ventana, que se encargan de procesar los mensajes que lleguen a cada ventana. Los procedimientos de ventana se explicarn a continuacin.
- 159 -
2.7. El procedimiento de ventana.

Cada ventana tiene una funcin asociada que se conoce como procedimiento de ventana, y es la encargada de procesar adecuadamente todos los mensajes enviados a una determinada clase de ventana. Es la responsable de todo lo relativo al aspecto y al comportamiento de una ventana. Normalmente, estas funciones estn basadas en una estructura "switch" donde cada "case" corresponde a un determinado tipo de mensaje.
2.7.1. Sintaxis.
LRESULT CALLBACK WindowProcedure ( HWND hwnd, // Manipulador de ventana UINT mensaje, // Mensaje WPARAM wParam, // Parmetro palabra, vara LPARAM lParam // Parmetro doble palabra, vara );
hwnd es el manipulador de la ventana a la que est destinado el mensaje.
mensaje es el cdigo del mensaje.
wParam es el parmetro de tipo palabra asociado al mensaje.
lParam es el parmetro de tipo doble palabra asociado al mensaje.
Se puede considerar este prototipo como una plantilla para crear procedimientos de ventana. El nombre de la funcin puede cambiar, pero el valor de retorno y los parmetros deben ser los mismos. El miembro lpfnWndProc de la estructura WNDCLASSEX es un puntero a una funcin de este tipo. Esa funcin es la que se encargar de procesar todos los mensajes para esa clase de ventana. Cuando se registra la clase de ventana, se tiene que asignar a ese miembro el puntero al procedimiento de ventana.
- 160 -
2.7.2. Prototipo de procedimiento de ventana.
LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM);
2.7.3. Implementacin de procedimiento de ventana simple.

/* Esta funcin es llamada por la funcin del API DispatchMessage() */ LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT mensaje, WPARAM wParam, LPARAM lParam) { switch (mensaje) /* manipulador del mensaje */ { case WM_DESTROY: /* enva un mensaje WM_QUIT a la cola de mensajes */ PostQuitMessage(0); break; default: /* para los mensajes de los que no se ocupa el usuario */ return DefWindowProc(hwnd, mensaje, wParam, lParam); } return 0; }
En general, habr tantos procedimientos de ventana como programas diferentes y todos sern distintos, pero tambin tendrn algo en comn: todos ellos procesarn los mensajes que lleguen a una clase de ventana.
En este ejemplo slo se procesa un tipo de mensaje, se trata de WM_DESTROY que es el mensaje que se enva a una ventana cuando se recibe un comando de cerrar, ya sea por men o mediante el icono de aspa en la esquina superior derecha de la ventana.
Este mensaje slo sirve para informar a la aplicacin de que el usuario tiene la intencin de abandonar la aplicacin, y le da una oportunidad de dejar las cosas en su sitio: cerrar ficheros, liberar memoria, guardar variables, etc. Esto lo hace envindole un mensaje WM_QUIT, mediante la funcin PostQuitMessage.
- 161 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. El resto de los mensajes se procesan en el caso "default", y simplemente se cede su tratamiento a la funcin del API que hace el proceso por defecto para cada mensaje, DefWindowProc.
Este es el camino que sigue el mensaje WM_QUIT cuando llega, ya que el proceso por defecto para este mensaje es cerrar la aplicacin.
2.8. Ejemplo GUI mediante MinGW Developer Studio.

Una vez explicados los procedimientos de ventana ya se puede mostrar el primer ejemplo de interfaz grfica de usuario mediante MinGW Developer Studio. El siguiente segmento de cdigo muestra una ventana por pantalla.
#include <windows.h>
/*
Declaracin del procedimiento de ventana
*/
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow) { HWND hwnd; MSG mensaje; /* Manipulador de ventana */ /* Mensajes recibidos por la aplicacin */
WNDCLASSEX wincl; /*Estructura de datos para la clase de ventana*/ /* Inicializacin: */ /* Estructura de la ventana */ wincl.hInstance = hInstance; wincl.lpszClassName = "NOMBRE_CLASE"; wincl.lpfnWndProc = WindowProcedure; wincl.style = CS_DBLCLKS; wincl.cbSize = sizeof(WNDCLASSEX); /* Usar icono y puntero por defecto */ wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
- 162 -

wincl.hCursor = LoadCursor(NULL, IDC_ARROW); wincl.lpszMenuName = NULL; wincl.cbClsExtra = 0; wincl.cbWndExtra = 0; wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND; /* Registrar la clase de ventana, si falla, salir del programa */ if(!RegisterClassEx(&wincl)) return 0; hwnd = CreateWindowEx( 0, "NOMBRE_CLASE", "Ventana 1", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 544, 375, HWND_DESKTOP, NULL, hInstance, NULL ); ShowWindow(hwnd, SW_SHOWDEFAULT); /* Bucle de mensajes: */ while(TRUE == GetMessage(&mensaje, 0, 0, 0)) { TranslateMessage(&mensaje); DispatchMessage(&mensaje); } return mensaje.wParam; } /* Esta funcin es invocada por la funcin DispatchMessage() CALLBACK WindowProcedure (HWND hwnd, UINT */ WPARAM
LRESULT
mensaje,
wParam, LPARAM lParam) { switch (mensaje) { case WM_DESTROY: PostQuitMessage (0); cola de mensajes */ /* Enva el mensaje WM_QUIT a la /* manipulador de mensaje */
- 163 -

break; default: /* Mensajes que no se quieren manejar */
return DefWindowProc (hwnd, mensaje, wParam, lParam); } return 0; }
La salida por pantalla tras ejecutar el cdigo anterior sera la siguiente:
- 164 -
Captulo
Mens y cuadros de dilogo
- 165 -
CAPTULO 3. Mens y cuadros de dilogo.

En el presente captulo se explican dos herramientas fundamentales a la hora de desarrollar interfaces grficas de usuario (GUI). Estas herramientas son los mens y los cuadros de dilogo.
3.1. Mens.
Una vez explicado el esqueleto de una aplicacin grfica, se ver una herramienta fundamental de comunicacin con ella: el men.
Un men es una ventana un tanto especial, del tipo pop-up, que contiene una lista de comandos u opciones entre las cuales el usuario puede elegir. Cuando los mens se usan en una aplicacin, normalmente se agrupan bajo una barra horizontal, que es tambin un men, dividida en varias zonas o tems.
Cada tem de un men, salvo los separadores y aquellos que despliegan nuevos mens, tiene asociado un identificador. El valor de ese identificador se usar por parte de la aplicacin para saber qu opcin activ el usuario y decidir las acciones a tomar en consecuencia.
La forma ms sencilla y frecuente de implementar mens es mediante ficheros de recursos (extensin *.rc). A la hora de trabajar con ficheros de recursos es importante adquirir algunas buenas costumbres como son:
o Usar siempre etiquetas como identificadores de los tems de los mens, y nunca valores numricos literales.
o Crear un fichero de cabecera con las definiciones de los identificadores. Se llamar, por ejemplo, ids.h
- 166 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o Este fichero de cabecera se incluir tanto en el fichero de recursos como en el del cdigo fuente de la aplicacin.
A la hora de elaborar el fichero de recursos existen dos opciones: mediante el editor de recursos del compilador o mediante un editor de texto (por ejemplo, el Bloc de notas). La primera alternativa se explicar en el siguiente captulo mientras que la primera se explicar a continuacin.
La creacin de ficheros de recursos mediante un editor de texto ayudar a entender el funcionamiento y utilidad de estos ficheros antes de explicar su creacin por medio del editor de recursos del compilador. Dicho esto se procede a explicarla.
Supngase que se quiere crear una aplicacin con un men que contenga dos tems: Abrir y Salir. Como ya se ha comentado anteriormente, estos tems tendrn asociado un identificador que debe ser declarado en el fichero de cabecera ids.h. Es por ello que la primera lnea del fichero de recursos debe ser:
#include ids.h
Siendo el fichero de cabecera ids.h el siguiente:
#define ABRIR 1000 #define SALIR 1001
Una vez se ha hecho el include del fichero ids.h se procede a elaborar el fichero de recursos. Dicho fichero debe contener la declaracin del men as como de los tems que lo componen, que en este caso sern dos. El primer tem (ABRIR) tendr el identificador 1000 mientras que el segundo (SALIR) tendr el 1001. Una vez dicho esto se muestra el fichero de recursos ya creado:
- 167 -

Menu MENU BEGIN POPUP "&Men" BEGIN MENUITEM "&Abrir", ABRIR MENUITEM SEPARATOR MENUITEM "&Salir", SALIR END END
El fichero de recursos sobre estas lneas permite crear la estructura del men de forma fcil. El ejemplo crea una barra de men con una columna Men, con dos opciones: Abrir y Salir, y con un separador entre ambas.
La sintaxis es sencilla, se define el men mediante una cadena identificadora, sin comillas, seguida de la palabra MENU. Entre las palabras BEGIN y END se pueden incluir tems, separadores u otras columnas. Para incluir columnas se usa una sentencia del tipo POPUP seguida de la cadena que se mostrar como texto en el men. Cada POPUP se comporta del mismo modo que un MENU.
Los tems se crean usando la palabra MENUITEM seguida de la cadena que se mostrar en el men, una coma, y el comando asignado a ese tem, que ser una macro definida en el fichero ids.h.
Los separadores se crean usando MENUITEM seguido de la palabra SEPARATOR.
Como se puede observar en el ejemplo, las cadenas que se muestran en el men contienen el smbolo & en su interior, por ejemplo &Abrir. Este smbolo indica que la siguiente letra puede usarse para activar la opcin del men desde el teclado, usando la tecla [ALT] ms la letra que sigue al smbolo &. Para indicar dicha situacin, en pantalla se muestra esa letra subrayada, por ejemplo Abrir.
- 168 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. El ltimo paso que se debe realizar es usar el men creado desde el fichero fuente. Para ello se deben realizar los siguientes pasos:
o Incluir el fichero de cabecera ids.h mediante la sentencia #include ids.h.
o Asignar el men creado como men por defecto de la clase. Para ello se realiza la siguiente asignacin en la funcin WinMain:
WNDCLASSEX wincl; ... wincl.lpszMenuName = Menu;
Otra alternativa, ms compleja que la explicada, a la hora de usar un men es la de cargarlo y asignarlo a la ventana por medio de la funcin LoadMenu en la llamada a CreateWindowEx. El cdigo necesario para llevar a cabo esta alternativa se muestra a continuacin:
hwnd = CreateWindowEx( 0, "NOMBRE_CLASE", "Ventana 1", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 544, 375, HWND_DESKTOP, LoadMenu(hInstance, "Menu"), /* Carga y asignacin de men */ NULL, hInstance, NULL );
A continuacin se explicar la funcin MessageBox que se emplear para mostrar cuadros de mensaje una vez pulsada una opcin del men. - 169 -
3.1.1. Funcin MessageBox.

Una vez explicada la forma de crear un men y asignarlo a una ventana se explicar un mecanismo muy simple para informar al usuario de cualquier situacin que se produzca en la aplicacin. Este mecanismo es el cuadro de mensaje (message box), que consiste en una pequea ventana con un mensaje para el usuario y uno o varios botones, segn el tipo de cuadro de mensaje que se use. Para visualizar un cuadro de mensaje simple se usar la funcin MessageBox.
La funcin MessageBox es una funcin perteneciente a la cabecera winuser.h que crea, muestra y ejecuta un cuadro de mensaje. El cuadro de mensaje contiene un mensaje definido por la aplicacin y un ttulo, as como cualquier combinacin de iconos predefinidos y botones. La sintaxis de la funcin es la siguiente:
int MessageBox( HWND hwnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType );
// // // //
manipulador de la ventana propietaria direccin del texto del mensaje direccin del texto del ttulo estilo del cuadro de mensaje
Los parmetros de la funcin tienen el siguiente significado:
o hWnd: identifica a la ventana propietaria del cuadro de mensaje a crear. Si este parmetro es NULL, el cuadro de mensaje no tendr ventana propietaria.
o lpText: apunta a una cadena terminada en cero que contiene el mensaje a mostrar.
- 170 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o lpCaption: apunta a una cadena terminada en cero usada como ttulo para el cuadro de dilogo. Si este parmetro es NULL, se usar el ttulo por defecto de Error.
o uType: especifica el contenido y comportamiento del cuadro de dilogo. A continuacin se muestra una tabla con algunos de los valores ms empleados del parmetro uType:
Valor MB_ABORTRETRYIGNORE
Significado El cuadro de mensaje contiene tres botones: Anular, Reintentar e Omitir. Se mostrar un icono de exclamacin. Se mostrar un icono con una interrogacin. Se mostrar un icono con un signo de stop. El cuadro de mensaje contiene un nico botn de Aceptar. El cuadro de mensaje contiene dos botones: Aceptar y Cancelar. El cuadro de mensaje contiene dos botones: Reintentar y Cancelar. El cuadro de mensaje contiene dos botones: S y No. El cuadro de mensaje contiene tres botones: S, No y Cancelar.
MB_ICONEXCLAMATION
MB_ICONQUESTION
MB_ICONSTOP
MB_OK
MB_OKCANCEL
MB_RETRYCANCEL
MB_YESNO
MB_YESNOCANCEL
- 171 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. A continuacin se mostrar un ejemplo de un pequeo cuadro de mensaje:
MessageBox(hwnd, Fichero guardado OK., Guardar Fichero, MB_OK);
La salida por pantalla sera la siguiente:
Una vez explicada la manera de crear cuadros de mensaje proseguimos con el ejemplo del men. A pesar de que el men ya haba sido creado y asociado a la ventana, sus dos opciones (Abrir y Salir) carecan de comportamiento. Es por ello que ahora se est en disposicin de asignar a cada opcin un cuadro de mensaje que informe acerca del comando del men que se ha pulsado.
Al pulsar una opcin del men se produce una activacin del mismo. Esta activacin se recibe mediante un mensaje WM_COMMAND. Para procesar estos mensajes se utilizar la palabra de menor peso del parmetro wParam del mensaje. Es por ello que dentro del case WM_COMMAND en el procedimiento de ventana se har un switch en funcin del identificador del tem del parmetro wParam. Para extraer dicho identificador se emplea la macro LOWORD. Una vez hecho esto ya slo falta mostrar en cada case correspondiente a cada tem del men un cuadro de mensaje que informe acerca de la opcin pulsada. A continuacin se muestra el cdigo del procedimiento de ventana para procesar los mensajes del men:
- 172 -

LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT mensaje, WPARAM wParam, LPARAM lParam) { switch (mensaje) { case WM_COMMAND: switch(LOWORD(wParam)) { case ABRIR: MessageBox(hwnd, "Mensaje de men", MB_OK); break; case SALIR: MessageBox(hwnd, "Mensaje de men", MB_OK); PostQuitMessage(0); cola de mensajes */ break; } break; case WM_DESTROY: PostQuitMessage(0); de mensajes */ break; default: /* Mensajes que no se quieren manejar */ /* enva un mensaje WM_QUIT a la cola /* enva un mensaje WM_QUIT a la "Se ha pulsado la opcin Salir.", "Se ha pulsado la opcin Abrir.", /* manipulador del mensaje */
return DefWindowProc(hwnd, mensaje, wParam, lParam); } return 0; }
Tambin se puede ver en el cdigo sobre estas lneas que cuando se pulsa la opcin Salir se sale de la aplicacin mediante la funcin PostQuitMessage.
Con este ltimo trozo de cdigo se da por terminada la explicacin del ejemplo de aplicacin de men con cuadros de mensaje. En el siguiente apartado se muestra el cdigo de todos los ficheros del ejemplo as como las salidas por pantalla.
- 173 -
3.1.2. Ejemplo completo de mens y cuadros de mensaje.

En este apartado se muestra el contenido de los ficheros necesarios para desarrollar el ejemplo de mens y cuadros de mensaje explicado anteriormente as como las salidas por pantalla de la aplicacin final. Se mostrarn, pues, los ficheros ids.h, menu.rc y menu.c.
Fichero de identificadores (fichero ids.h)
#define ABRIR 1000 #define SALIR 1001
Fichero de recursos (fichero menu.rc)
#include "ids.h" Menu MENU BEGIN POPUP "&Men" BEGIN MENUITEM "&Abrir", ABRIR MENUITEM SEPARATOR MENUITEM "&Salir", SALIR END END
- 174 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Programa Principal (fichero menu.c)
#include <windows.h> #include "ids.h" /* Declaracin del procedimiento de ventana */ LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM); int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow) { HWND hwnd; /* Manipulador de ventana */ MSG mensaje; /* Mensajes recibidos por la aplicacin */ WNDCLASSEX wincl; /* Estructura de datos para la clase de ventana */
/* Estructura de la ventana */ wincl.hInstance = hInstance; wincl.lpszClassName = "NOMBRE_CLASE"; wincl.lpfnWndProc = WindowProcedure; wincl.style = CS_DBLCLKS; wincl.cbSize = sizeof (WNDCLASSEX); /* Usar icono y puntero por defector */ wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION); wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION); wincl.hCursor = LoadCursor (NULL, IDC_ARROW); wincl.lpszMenuName = "Menu"; /* Con men Menu */ wincl.cbClsExtra = 0; wincl.cbWndExtra = 0; wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND; /* Registrar la clase de ventana, si falla, salir del programa */ if(!RegisterClassEx(&wincl)) return 0; hwnd = CreateWindowEx( 0, "NOMBRE_CLASE", "Ventana 1", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 544, 375, HWND_DESKTOP, //LoadMenu(hInstance, "Menu"), /* Otra alternativa */ NULL, hInstance, NULL ); ShowWindow(hwnd, SW_SHOWDEFAULT);
- 175 -

/* Bucle de mensajes */ while(TRUE == GetMessage(&mensaje, 0, 0, 0)) { TranslateMessage(&mensaje); DispatchMessage(&mensaje); } return mensaje.wParam; } /* Esta funcin es invocada por la funcin DispatchMessage() */ LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT mensaje, WPARAM wParam, LPARAM lParam) { switch (mensaje) /* manipulador del mensaje */ { case WM_COMMAND: switch(LOWORD(wParam)) { case ABRIR: MessageBox(hwnd, "Se ha pulsado la opcin Abrir.", "Mensaje de men", MB_OK); break; case SALIR: MessageBox(hwnd, "Se ha pulsado la opcin Salir.", "Mensaje de men", MB_OK); PostQuitMessage(0); /* enva un mensaje WM_QUIT a la cola de mensajes */ break; } break; case WM_DESTROY: PostQuitMessage(0); /* enva un mensaje WM_QUIT a la cola de mensajes */ break; default: /* Mensajes que no se quieren manejar */ return DefWindowProc(hwnd, mensaje, wParam, lParam); } return 0; }
- 176 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. A continuacin se muestra la salida por pantalla tras la ejecucin del cdigo mostrado as como el comportamiento de la aplicacin al pulsar cada una de las dos opciones del men.
Al pulsar la opcin Abrir del men aparece el siguiente cuadro de mensaje:
Y al pulsar la opcin Salir aparece el siguiente cuadro de mensaje tras el cual se cerrar la aplicacin:
- 177 -
3.2. Cuadros de dilogo.

Los cuadros de dilogo son la forma de ventana ms habitual de comunicacin entre una aplicacin grfica y el usuario. Para facilitar la tarea del usuario a la hora de introducir datos existen varios tipos de controles, cada uno de ellos diseado para un tipo especfico de informacin. Los ms comunes son los static, edit, button, listbox, scroll, combobox, group, checkbutton y radiobutton.
Un cuadro de dilogo es una ventana normal aunque con algunas peculiaridades. Tambin tiene su procedimiento de ventana (que recibir el nombre de procedimiento de dilogo), pero puede devolver un valor a la ventana que lo invoque.
La forma ms sencilla y frecuente de implementar cuadros de dilogo es mediante ficheros de recursos (extensin *.rc). Al igual que en el apartado anterior, se explicar la creacin de dicho fichero mediante un editor de texto ya que ayudar a entender el funcionamiento y la estructura del fichero antes de explicar su creacin por medio del editor de recursos del compilador en el prximo captulo.
A continuacin se muestra el cdigo del fichero de recursos necesario para crear un men con un tem llamado Dilogo y un cuadro de dilogo con un texto (Mensaje de prueba) y un botn de Aceptar:
#include <windows.h> #include "ids.h"
Menu MENU BEGIN POPUP "&Men" BEGIN MENUITEM "&Dilogo", DIALOGO END
- 178 -

END
DialogoPrueba DIALOG 0, 0, 118, 48 STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION CAPTION "Dilogo de prueba" FONT 8, "Helv" BEGIN CONTROL "Mensaje de prueba", TEXTO, "static", SS_LEFT | WS_CHILD | WS_VISIBLE, 8, 9, 84, 8 CONTROL "Aceptar", IDOK, "button", BS_PUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 56, 26, 50, 14 END
Se necesita incluir el fichero windows.h ya que en l se definen muchas constantes, como por ejemplo IDOK que es el identificador que se usa para el botn de Aceptar.
Tambin se necesita el fichero ids.h para definir los identificadores que se usarn en el programa, por ejemplo, el identificador de la opcin del men para abrir el dilogo. A continuacin se muestra el fichero ids.h:
#define TEXTO 1000 #define DIALOGO 1001
Lo primero que se definir es un men para poder comunicarle a la aplicacin que se quiere abrir un cuadro de dilogo. A continuacin est la definicin del dilogo.
La primera lnea define un dilogo llamado DialogoPrueba mediante la palabra DIALOG, as como las coordenadas y dimensiones del dilogo.
En cuanto a los estilos, las constantes para definir los estilos de ventana comienzan con WS_ mientras que los estilos de dilogos comienzan con
- 179 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. DS_. Los estilos que se han definido en el fichero de recursos mediante la palabra STYLE son los siguientes:
o DS_MODALFRAME: indica que se crear un cuadro de dilogo con un marco de dialogbox modal que puede combinarse con una barra de ttulo y un men de sistema. o WS_POPUP: crea una ventana pop-up. o WS_VISIBLE: crea una ventana inicialmente visible. o WS_CAPTION: crea una ventana con una barra de ttulo.
La siguiente lnea del fichero es la de CAPTION y en ella se especifica el texto que aparecer en la barra de ttulo del dilogo. La lnea de FONT sirve para especificar el tamao y el tipo de fuente de caracteres que usar el dilogo.
Despus se encuentra la zona de controles en la que se define un texto esttico y un botn. Un control esttico (static) sirve para mostrar textos o rectngulos, que se pueden usar para informar al usuario de algo, como etiquetas o simplemente como adorno.
El control button sirve para que el usuario se comunique con el dilogo. A continuacin se explica en detalle la definicin del control button.
CONTROL "Aceptar", IDOK, "button", BS_PUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 56, 26, 50, 14
o CONTROL es una palabra clave que indica que se va a definir un control. o A continuacin, en el parmetro text se introduce el texto que se mostrar en su interior. o id es el identificador del control. La aplicacin recibir este identificador junto con el mensaje WM_COMMAND cuando el usuario active el botn. La etiqueta IDOK est definida en el fichero windows.h.
- 180 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o class es la clase de control, en este caso button. o style es el estilo de control que se quiere. En este caso es una combinacin de varios estilos de button y varios de ventana: o BS_PUSHBUTTON: crea un botn corriente que enva un mensaje WM_COMMAND a su ventana padre cuando el usuario selecciona el botn. o BS_CENTER: centra el texto horizontalmente en el rea del botn. o WS_CHILD: crea el control como una ventana hija. o WS_VISIBLE: crea una ventana inicialmente visible. o WS_TABSTOP: define un control que puede recibir el foco del teclado cuando el usuario pulsa la tecla TAB. Presionando la tecla TAB, el usuario mueve el foco del teclado al siguiente control con el estilo WS_TABSTOP. o Coordenada x del control. o Coordenada y del control. o Width: anchura del control. o Height: altura del control.
3.2.1. Procedimiento de dilogo.

Como ya se ha comentado anteriormente, un dilogo es bsicamente una ventana, y al igual que sta, necesita un procedimiento asociado que procese los mensajes que le sean enviados, en este caso, un procedimiento de dilogo. La sintaxis es la siguiente:
BOOL CALLBACK DialogProc( HWND hwndDlg, UINT mensaje, WPARAM wParam, LPARAM lParam ); // Manipulador del cuadro de dilogo // Mensaje // Primer parmetro del mensaje // Segundo parmetro del mensaje
o hwndDlg identifica el cuadro de dilogo y es el manipulador de la ventana a la que est destinado el mensaje.
- 181 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. o mensaje es el cdigo del mensaje. o wParam es el parmetro de tipo palabra asociado al mensaje. o lParam es el parmetro de tipo doble palabra asociado al mensaje.
La diferencia fundamental con el procedimiento de ventana es el tipo de valor de retorno, que en el caso del procedimiento de dilogo es de tipo booleano.
Excepto en la respuesta al mensaje WM_INITDIALOG, el procedimiento de dilogo debe devolver un valor no nulo si procesa el mensaje y cero si no lo hace. Cuando responde a un mensaje WM_INITDIALOG, el procedimiento de dilogo debe devolver cero si llama a la funcin SetFocus para poner el foco a uno de los controles del cuadro de dilogo. En otro caso debe devolver un valor distinto de cero, y el sistema pondr el foco en el primer control del dilogo que pueda recibirlo.
El prototipo del procedimiento de dilogo es el siguiente:
BOOL CALLBACK DialogProc(HWND,UINT, WPARAM, LPARAM);
A la hora de implementar el procedimiento de dilogo para el ejemplo explicado se debe analizar el dilogo creado. ste slo puede proporcionar un comando, as que slo se deber responder a un tipo de mensaje WM_COMMAND y al mensaje WM_INITDIALOG.
Tal y como se ha comentado, el mensaje WM_INITDIALOG debe devolver un valor distinto de cero si no se llama a SetFocus, como es el caso. Este mensaje se usar para inicializar el dilogo antes de que sea visible para el usuario, siempre que haya algo que inicializar, claro.
- 182 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Cuando se procese el mensaje WM_COMMAND, que ser siempre el que procede del nico botn del dilogo, se cerrar el dilogo llamando a la funcin EndDialog y se devolver un valor distinto de cero. En cualquier otro caso de devolver el valor FALSE, ya que no se estar procesando el mensaje.
El procedimiento de dilogo ser el siguiente:
BOOL CALLBACK DlgProc(HWND hDlg, UINT mensaje, WPARAM wParam, LPARAM lParam) { switch (mensaje) { case WM_INITDIALOG: return TRUE; case WM_COMMAND: EndDialog(hDlg, FALSE); return TRUE; } return FALSE; } /* manipulador del mensaje */
Una vez implementado el procedimiento de dilogo ya slo falta crear el cuadro de dilogo. Para ello se usar un comando (opcin) de men, por lo que el dilogo se activar desde el procedimiento de ventana. El cdigo necesario para crear el cuadro de dilogo en el procedimiento de ventana es el siguiente:
- 183 -

LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT mensaje, WPARAM wParam, LPARAM lParam) { static HINSTANCE hInstance;
switch (mensaje) { case WM_CREATE:
/* manipulador del mensaje */
hInstance = ((LPCREATESTRUCT)lParam)->hInstance; return 0; break; case WM_COMMAND: switch(LOWORD(wParam)) { case DIALOGO: DialogBox(hInstance, "DialogoPrueba", hwnd, DlgProc); break; } break; case WM_DESTROY: PostQuitMessage(0); mensajes */ break; default: /* Mensajes que no se quieren manejar */ /* enva un mensaje WM_QUIT a la cola de
En este procedimiento hay una serie de novedades que se explicarn a continuacin.
En primer lugar, se ha declarado una variable esttica hInstance para tener siempre disponible un manipulador de la instancia actual.
Para inicializar este valor se hace uso del mensaje WM_CREATE, que se enva a una ventana cuando es creada, antes de que se visualice por primera vez. Se aprovecha el hecho de que el procedimiento de ventana slo recibe una
- 184 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. vez este mensaje y de que lo hace antes de poder recibir ningn otro mensaje o comando.
El mensaje WM_CREATE tiene como parmetro en lParam un puntero a una estructura CREATESTRUCT que contiene informacin sobre la ventana. Para el ejemplo slo interesar el campo hInstance.
Otra novedad es la llamada a la funcin DialogBox, que es la que crea el cuadro de dilogo. Esta funcin necesita varios parmetros:
o Un manipulador a la instancia de la aplicacin, que se ha obtenido al procesar el mensaje WM_CREATE. o Un identificador de recurso de dilogo. Este es el nombre que se utiliz para nombrar al dilogo (entre comillas) cuando se cre el recurso en el fichero de recursos. o Un manipulador a la ventana a la que pertenece el dilogo. o La direccin del procedimiento de ventana que har el tratamiento del dilogo.
3.2.2. Paso de parmetros a un cuadro de dilogo.

A la hora de crear un dilogo existe otra opcin adems de la ya citada funcin DialogBox que permite enviar un parmetro extra al procedimiento de dilogo. Esta funcin recibe el nombre de DialogBoxParam. El parmetro que se enva al procedimiento de ventana es enviado a travs del parmetro lParam del procedimiento de dilogo, y puede contener un valor entero o, lo que es mucho ms til, un puntero.
Esta funcin tiene los mismos parmetros que DialogBox, ms uno aadido. Este quinto parmetro es el que se usa para recibir valores desde el procedimiento de dilogo.
- 185 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Por ejemplo, supngase que se quiere saber cuntas veces se ha invocado un dilogo. Para ello se llevar la cuenta en el procedimiento de ventana, incrementando esa cuenta cada vez que se reciba un comando u opcin del men para mostrar el dilogo. Adems, se pasar ese valor como parmetro lParam al procedimiento de dilogo. A continuacin se muestra el procedimiento de ventana con los dos dilogos que se mostrarn en la aplicacin: DIALOGO1 (el del apartado anterior) y DIALOGO2 (el que lleva la cuenta del nmero de veces que se ha invocado).
LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT mensaje, WPARAM wParam, LPARAM lParam) { static HINSTANCE hInstance; static int veces;
switch (mensaje) { case WM_CREATE:
hInstance = ((LPCREATESTRUCT)lParam)->hInstance; return 0; break; case WM_COMMAND: switch(LOWORD(wParam)) { case DIALOGO1: DialogBox(hInstance, "DialogoPrueba", hwnd, DlgProc); break; case DIALOGO2: veces++; DialogBoxParam(hInstance, DlgProc2, veces); break; } break; case WM_DESTROY: PostQuitMessage(0); break; default: "DialogoPrueba", hwnd,
- 186 -

El procedimiento de ventana mostrado tomar el valor de la variable veces y lo pasar como parmetro lParam al procedimiento de dilogo. ste ltimo ser el encargado de crear el texto de un control esttico mostrando su valor tal y como se muestra a continuacin:
BOOL CALLBACK DlgProc2(HWND hDlg, UINT mensaje, WPARAM wParam, LPARAM lParam) { char texto[25];
switch (mensaje) { case WM_INITDIALOG:
sprintf(texto, "Veces invocado: %d", lParam); SetWindowText(GetDlgItem(hDlg, TEXTO), texto); return TRUE; case WM_COMMAND: EndDialog(hDlg, FALSE); return TRUE; } return FALSE; }
Para conseguir un texto esttico a partir del parmetro lParam se ha usado la funcin estndar sprintf. Posteriormente se usa ese texto para modificar el control esttico TEXTO. Por otra parte, la funcin SetWindowText se usa para cambiar el ttulo de una ventana, pero en este caso sirve para cambiar el texto del control esttico.
El paso de parmetros a un cuadro de dilogo es de gran utilidad cuando ste se usa para pedir datos al usuario. De este modo se facilita en gran medida - 187 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. el intercambio de datos entre la aplicacin y los procedimientos de dilogo y se evita el uso de variables globales.
Una vez mostrado el procedimiento de dilogo del cuadro de dilogo DIALOGO2 se da por terminada la explicacin del ejemplo de aplicacin de men con cuadros de dilogo. En el siguiente apartado se muestra el cdigo de todos los ficheros del ejemplo as como las salidas por pantalla.
- 188 -
3.2.3. Ejemplo completo de cuadros de dilogo.

En este apartado se muestra el contenido de los ficheros necesarios para desarrollar el ejemplo de cuadros de dilogo explicado anteriormente as como las salidas por pantalla de la aplicacin final. Se mostrarn, pues, los ficheros ids.h, dialogo.rc y dialogo.c.
Fichero de identificadores (fichero ids.h)
#define TEXTO 1000 #define DIALOGO1 1001 #define DIALOGO2 1002
Fichero de recursos (fichero dialogo.rc)
#include <windows.h> #include "ids.h" Menu MENU BEGIN POPUP "&Men" BEGIN MENUITEM "&Dilogo", DIALOGO1 MENUITEM "&Con parmetro", DIALOGO2 END END DialogoPrueba DIALOG 0, 0, 118, 48 STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION CAPTION "Dilogo de prueba" FONT 8, "Helv" BEGIN CONTROL "Mensaje de prueba", TEXTO, "static", SS_LEFT | WS_CHILD | WS_VISIBLE, 8, 9, 84, 8 CONTROL "Aceptar", IDOK, "button", BS_PUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 56, 26, 50, 14 END
- 189 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Programa Principal (fichero dialogo.c)
#include <windows.h> #include "ids.h" /* Declaracin del procedimiento de ventana */ LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM); BOOL CALLBACK DlgProc(HWND, UINT, WPARAM, LPARAM); BOOL CALLBACK DlgProc2(HWND, UINT, WPARAM, LPARAM); int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow) { HWND hwnd; /* Manipulador de ventana */ MSG mensaje; /* Mensajes recibidos por la aplicacin */ WNDCLASSEX wincl; /* Estructura de datos para la clase de ventana */ /* Estructura de la ventana */ wincl.hInstance = hInstance; wincl.lpszClassName = "NOMBRE_CLASE"; wincl.lpfnWndProc = WindowProcedure; wincl.style = CS_DBLCLKS; wincl.cbSize = sizeof(WNDCLASSEX); /* Usar icono y puntero por defector */ wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION); wincl.hCursor = LoadCursor(NULL, IDC_ARROW); wincl.lpszMenuName = "Menu"; wincl.cbClsExtra = 0; wincl.cbWndExtra = 0; wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND; /* Registrar la clase de ventana, si falla, salir del programa */ if(!RegisterClassEx(&wincl)) return 0; hwnd = CreateWindowEx( 0, "NOMBRE_CLASE", "Ventana 1", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 544, 375, HWND_DESKTOP, NULL, hInstance, NULL ); ShowWindow(hwnd, SW_SHOWDEFAULT); /* Bucle de mensajes */ while(TRUE == GetMessage(&mensaje, NULL, 0, 0)) { TranslateMessage(&mensaje);
- 190 -

DispatchMessage(&mensaje); } /* Salir con valor de retorno */ return mensaje.wParam; }
/* Esta funcin es invocada por la funcin DispatchMessage() */ LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT mensaje, WPARAM wParam, LPARAM lParam) { static HINSTANCE hInstance; static int veces; switch (mensaje) /* manipulador del mensaje */ { case WM_CREATE: hInstance = ((LPCREATESTRUCT)lParam)->hInstance; return 0; break; case WM_COMMAND: switch(LOWORD(wParam)) { case DIALOGO1: DialogBox(hInstance, "DialogoPrueba", hwnd, DlgProc); break; case DIALOGO2: veces++; DialogBoxParam(hInstance, "DialogoPrueba", hwnd, DlgProc2, veces); break; } break; case WM_DESTROY: PostQuitMessage(0); /* enva el mensaje WM_QUIT a la cola de mensajes */ break; default: /* Mensajes que no se quieren manejar */ return DefWindowProc(hwnd, mensaje, wParam, lParam); } return 0; } BOOL CALLBACK DlgProc(HWND hDlg, UINT mensaje, WPARAM wParam, LPARAM lParam) { switch (mensaje) /* manipulador del mensaje */ { case WM_INITDIALOG: return TRUE; case WM_COMMAND: EndDialog(hDlg, FALSE); return TRUE; } return FALSE; }
- 191 -

BOOL CALLBACK DlgProc2(HWND hDlg, UINT mensaje, WPARAM wParam, LPARAM lParam) { char texto[25]; switch (mensaje) /* manipulador del mensaje */ { case WM_INITDIALOG: sprintf(texto, "Veces invocado: %d", lParam); SetWindowText(GetDlgItem(hDlg, TEXTO), texto); return TRUE; case WM_COMMAND: EndDialog(hDlg, FALSE); return TRUE; } return FALSE; }
A continuacin se muestra la salida por pantalla tras la ejecucin del cdigo mostrado as como el comportamiento de la aplicacin al pulsar cada una de las dos opciones del men.
- 192 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Al pulsar la opcin Dilogo del men aparece el siguiente cuadro de mensaje:
Y al pulsar la opcin Con parmetro aparece el siguiente cuadro de mensaje que muestra el nmero de veces que se ha invocado:
Si se pulsa ms veces mostrar el nmero total de veces que se ha pulsado:
- 193 -
Captulo
Creacin de recursos mediante el editor de recursos
- 194 -
CAPTULO 4. Creacin de recursos mediante el editor de recursos.

En el presente captulo se explica la creacin de ficheros de recursos (extensin *.rc) mediante el editor de recursos de MinGW Developer Studio. Estos ficheros permiten crear de forma rpida y fcil recursos que se emplean posteriormente en aplicaciones grficas tal y como se vio en el captulo anterior con los mens y los cuadros de dilogo. Es precisamente estos dos tipos de recursos en los que se centrar la explicacin dado que sus correspondientes ficheros de recursos ya se mostraron en el captulo anterior.
A la hora de crear un fichero de recursos (por medio del editor de recursos del compilador) lo primero que se debe hacer es abrir el editor de recursos de MinGW Developer Studio. Para ello se pulsa la opcin Resource Editor del men Tools o bien se pulsan simultneamente las teclas Ctrl y R.
Una vez que se ha abierto el editor de recursos, lo primero que se debe hacer es crear un proyecto nuevo o, en su defecto, abrir un proyecto ya existente. Para ello se pulsan las opciones New Project o Open Project del men File. Los iconos de la barra de herramientas asociados a estas dos opciones son y respectivamente.
Una vez abierto o creado un proyecto se mostrar en la esquina superior derecha de la aplicacin la carpeta del proyecto que contendr los distintos recursos asociados al proyecto. Si el proyecto es nuevo, se mostrar una carpeta vaca con la palabra Untitled (Sin ttulo) ya que el proyecto an no tiene nombre.
A continuacin ya se pueden asociar al proyecto los recursos que se deseen. Para ello, en la opcin Project del men del editor se listan las opciones de recursos que se pueden asociar: desde un men o un dilogo (opciones Add Menu y Add Dialog) hasta recursos ms complejos como un acelerador (opcin
- 195 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Add Accelerator) o un cuadro de versin (opcin Add Versioninfo). Los recursos en los que se centrar la explicacin sern los mens y los cuadros de dilogo.
A la hora de crear un men se debe pulsar la citada opcin Add Menu situada en la opcin Project del editor. Una vez pulsada aparecer un cuadro en el que se podrn especificar una serie de parmetros como el nombre del men, el identificador del men o el identificador de comienzo de los tems. Adems, en este mismo cuadro se deben aadir los tems que se quieran asociar al men. Para cada tem se debe especificar su nombre (Name), el nombre con que aparecer al ejecutar la aplicacin (Caption), as como su identificador. Adems, el cuadro muestra otras opciones como si se quiere que aparezca deshabilitado (Disabled), marcado (Checked), si es de tipo String, Bitmap, etc. A continuacin se muestra la captura de pantalla del cuadro Menu Editor necesario para crear el men del ejemplo de mens del captulo 3.
- 196 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Una vez creado el men y guardado el proyecto se crear un fichero de recursos con extensin *.rc con el siguiente contenido:
#define Menu 1000 #define ABRIR 1000 #define SALIR 1001 Menu MENUEX BEGIN MENUITEM "Abrir",ABRIR MENUITEM "",SEPARATOR MENUITEM "Salir",SALIR END
A partir de este fichero ya se pueden realizar las modificaciones necesarias para adaptarlo a las necesidades del usuario. La primera de estas modificaciones consistira en cortar las primeras lneas del fichero
correspondientes a sentencias include
de identificadores de recursos y
pegarlas en el fichero de identificadores ids.h. El identificador correspondiente al men es opcional por lo que ser eliminado. Una vez creado el fichero ids.h con los identificadores de los tems del men ste podr ser aadido al fichero de recursos mediante el comando Include file del men Project. Una vez pulsado, se mostrar un cuadro llamado Included Files donde aparecern todos los archivos asociados al fichero de recursos. Para asociar un nuevo fichero se pulsa el botn Add y se selecciona la ubicacin del fichero mediante el botn situado a la derecha del nuevo registro de la pestaa Filename. Una vez seleccionado el fichero el cuadro tendr el siguiente aspecto:
- 197 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Finalmente, se pulsa el botn OK y el fichero ids.h ya quedar asociado al proyecto. Este hecho se puede visualizar en la zona de recursos ya que aparecer el icono Include file tal y como se muestra a continuacin:
Otra modificacin que se debe hacer en el fichero de recursos generado es borrar las comillas de texto vaco asociadas al tem SEPARATOR. Recurdese que este tem se emplea para separar los diferentes tems pertenecientes a un men. Por ello, en su declaracin no se debe incluir Caption alguna si bien el editor de recursos le asigna por defecto una cadena vaca.
Por ltimo, si desea dotar al men de comportamiento tipo pop-up se tendr que especificar este hecho manualmente dado que no hay ninguna opcin en el editor que permita especificar esta propiedad. Recurdese que este comportamiento permite agrupar sobre una misma opcin del men varias subopciones. Una vez modificado el fichero para habilitar el comportamiento pop-up y ordenadas las sentencias del mismo tendr el siguiente aspecto:
#include "ids.h"
Menu MENUEX BEGIN POPUP "&Men" BEGIN MENUITEM "Abrir",ABRIR MENUITEM SEPARATOR MENUITEM "Salir",SALIR END END
- 198 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Los nicos aspectos diferentes al fichero mostrado en el ejemplo de mens del apartado 3.1.2 seran la palabra clave MENUEX (mismo
comportamiento que MENU) y la ausencia del smbolo & en los caption de los tems del men. Este smbolo indica que la siguiente letra puede usarse para activar la opcin del men desde el teclado, usando la tecla [ALT] ms la letra que sigue al smbolo &. Para indicar dicha situacin, en pantalla se muestra esa letra subrayada, por ejemplo Abrir. Este smbolo puede ser incluido de forma manual a eleccin del usuario.
Una vez finalizada la creacin del fichero de recursos utilizado en el ejemplo del apartado 3.2.1 se procede a explicar la creacin del fichero empleado en el ejemplo de cuadros de dilogo del apartado 3.2.3.
El proceso de creacin de la parte del fichero de recursos necesaria para crear el men desde el que se invocarn los cuadros de dilogo es igual a la explicada anteriormente en este captulo por lo que se obvia esta explicacin. Una vez creada esta parte, el fichero de recursos tendr el siguiente contenido:
#include "ids.h" Menu MENUEX BEGIN POPUP "&Men" BEGIN MENUITEM "&Dilogo", DIALOGO1 MENUITEM "&Con parmetro", DIALOGO2 END END
A continuacin se aade al proyecto un cuadro de dilogo. Para ello se pulsa la opcin Add Dialog del men Project. Una vez pulsada, aparecer en la zona de edicin del editor un cuadro de dilogo vaco con el ttulo IDD_DLG asignado por defecto. En la parte derecha del editor aparecer una lista de propiedades del cuadro de dilogo que se pueden modificar. En principio, el nombre del cuadro de dilogo (Name), el ttulo (Caption) y el identificador (ID) sern los tres parmetros a modificar as como eliminar los botones de maximizar, minimizar y cerrar poniendo a False la propiedad SysMenu. Sin - 199 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. embargo, se pueden modificar otros muchos como la fuente del ttulo (Font), el estilo (xStyle) o la altura (Height). La forma de modificar estos parmetros es muy sencilla salvo en el caso del estilo. En este caso, cuando se sita el cursor sobre la opcin xStyle y se pulsa aparece un botn de flecha desplegable en la parte derecha del cuadro de texto que contiene un nmero en hexadecimal. Si se pulsa esta flecha desplegable aparece un pequeo cuadro con una secuencia de nmeros en binario tal y como se muestra a continuacin:
Cada dgito del nmero binario ser un estilo diferente cuyo nombre se mostrar bajo los tres botones de flechas. Si se quiere activar el estilo seleccionado, se pulsa el botn hasta que el correspondiente dgito se
encuentre a 1. Para avanzar por los dgitos se emplean las otras dos flechas de direccin. Una vez que los estilos deseados se encuentren a 1 y el resto a cero se pulsa el botn Close.
Una vez que los parmetros del cuadro de dilogo se encuentren definidos ya se puede comenzar a aadir al cuadro los controles que se deseen. Los diferentes controles que se pueden aadir se muestran en la zona izquierda del editor de recursos por medio de iconos. En cualquier caso, si se sita el cursor sobre un icono aparece el nombre del control asociado por lo que la bsqueda de controles resulta fcil e intuitiva. Los controles que se aadirn al cuadro de dilogo sern: un texto esttico (control static) por medio del icono y un botn (control button) por medio del icono .
A la hora de aadir el control de tipo static se pulsa sobre el icono correspondiente y se dibuja sobre el cuadro de dilogo el tamao del control en
- 200 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. la posicin que se desea colocar. Una vez dibujado el control, aparecer en el lado derecho de la pantalla una lista de parmetros similar a la que apareca al aadir el cuadro de dilogo. Los parmetros que se deben modificar son el nombre del control (Name), el texto de la etiqueta (Caption) y el identificador del control (ID). Adems, se pueden modificar otros parmetros como la fuente del texto (Font), la alineacin del texto (Alignment), el borde del control (Border), la altura (Height) o la anchura (Width). Una vez aadido, el aspecto del cuadro de dilogo es el siguiente:
Ahora se procede a aadir el otro control, el botn. Para ello se pulsa el icono correspondiente y se dibuja en el cuadro tal y como se hizo al aadir el control static. Una vez aadido, se deben modificar los parmetros de la lista para cambiar el nombre, el identificador y el texto a mostrar en el botn as como otros parmetros que desee el usuario. Recurdese que el nombre del botn ser IDOK, que es el identificador que se usa para el botn de Aceptar. Por ello, se necesita incluir el fichero windows.h en el que se define dicha constante. Una vez aadido el botn, el cuadro de dilogo tomar su aspecto final:
- 201 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Una vez guardado el proyecto, se generar el fichero con extensin .rc que tendr el siguiente contenido:
#include <windows.h> #include "ids.h"
Menu MENUEX BEGIN POPUP "&Men" BEGIN MENUITEM "&Dilogo",DIALOGO1 MENUITEM "&Con parmetro",DIALOGO2 END END DialogoPrueba DIALOGEX 5,5,146,80 CAPTION "Dilogo de prueba" FONT 8,"Microsoft Sans Serif" STYLE 0x90CF0000 EXSTYLE 0x00000000 BEGIN CONTROL "Mensaje de prueba",TEXTO,"Static", 0x50000001,15,7,116,23,0x00000000 CONTROL "Aceptar",IDOK,"Button",0x50010000,43,43,59,18,0x00000000 END
El fichero generado es muy similar al que se obtuvo en el ejemplo del apartado 3.2.3 con las particularidades propias del editor de recursos de MinGW Developer Studio como el estilo en nmero hexadecimal o el uso de la palabra clave DIALOGEX para crear el dilogo en vez de DIALOG. A pesar de ello, el fichero de recursos generado es perfectamente vlido y funciona del mismo modo que el editado manualmente. Sin embargo, es obvio que el ahorro de tiempo empleando el editor de recursos es mucho mayor que editndolo manualmente siempre y cuando se sepa qu parmetros se han de modificar para obtener la apariencia deseada en los recursos cuando se ejecute la aplicacin grfica final.
- 202 -
PARTE IV: Valoracin y conclusiones
- 203 -
Captulo
Valoracin econmica y planificacin
- 204 -
CAPTULO 1. Valoracin econmica y planificacin. 1.1. Valoracin econmica.

En el presente captulo se procede a realizar una valoracin econmica de los costes asociados al desarrollo del proyecto.
1.1.1. Coste de tecnologa.

Son los costes derivados del equipo hardware necesario para desarrollar el proyecto, as como las licencias necesarias para utilizar las herramientas y los distintos lenguajes de programacin empleados en el proyecto.
Equipo hardware
En el desarrollo del proyecto se precisar, como mnimo, de una estacin de trabajo Intel Centrino Duo a 1,83 Ghz, 1 GB RAM y 100 GB de disco duro sobre un sistema operativo Windows XP Professional.
Elementos software
Los principales elementos software que se necesitarn son los siguientes:
o MinGW Developer Studio: la descarga e instalacin es gratuita por lo que el nico coste asociado al compilador ser el tiempo de descarga e instalacin que, en cualquier caso, no sobrepasar los 10-15 minutos.
o Aplicaciones de ofimtica (MS Word, Adobe Acrobat,): se precisar de una licencia de Microsoft Office 2007 si bien la versin Hogar y Estudiantes 2007 bastar. Dicha versin tiene un coste aproximado de 130 euros. El resto de aplicaciones de ofimtica son
- 205 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. de descarga gratuita (Adobe Acrobat) o vienen incluidas en el sistema operativo (Notepad, Paint,). o Conexin a Internet: se requiere una conexin bsica a Internet as como un explorador de Internet como puede ser el propio del sistema operativo (Microsoft Internet Explorer) o bien cualquiera de descarga gratuita (Mozilla Firefox, Safari,).
El coste total de tecnologa es el siguiente:
DISPOSITIVO Estacin de trabajo Windows XP Professional Microsoft Office Hogar y Estudiantes 2007 ADSL*
COSTE 1.000 250 130 220 1.600
* El precio mensual es de 20 multiplicado por los 11 meses de desarrollo del proyecto.
1.1.2. Coste de implantacin.

Estos costes incluyen los costes de desarrollo y personal. Adems del Jefe de Proyecto (JP) y el Coordinador y Director de Proyecto, que en este caso son la misma persona, se ha dispuesto de un Programador Junior as como de un Analista Junior para llevar a cabo los ejemplos necesarios para explicar los conceptos tericos del proyecto. El coste total de implantacin se muestra en la siguiente tabla:
- 206 -
FUNCIN Analista Junior Programador Junior Jefe de Proyecto Coordinador y Director de Proyecto
N horas 175 145 30 10
Coste / Hora 35 25 55 65
IMPORTE 6.125 3.625 1.650 650 12.050
Total de costes
CONCEPTO Costes de tecnologa Costes de implantacin COSTE 1.600 12.050 13.650
- 207 -
1.2. Planificacin del proyecto.

La planificacin del proyecto se ha dividido en cinco etapas que comenzaron en octubre del 2007 y han finalizado el 5 de septiembre del 2008 con un parntesis de una semana en noviembre y abril, y de un mes en febrero y junio debido a los exmenes.
Las cinco etapas cubiertas por el proyecto son las siguientes:
1. Estudio del compilador (ECO): Anlisis de la herramienta software MinGW Developer Studio.
2. Anlisis del compilador en el mbito de Orientacin a Objetos (AOO): Anlisis de las posibilidades que ofrece el compilador a la hora de llevar a cabo Programacin Orientada a Objetos (POO) mediante el lenguaje de programacin C++.
3. Anlisis de las libreras grficas del compilador para desarrollar interfaces grficas de usuario (GUI) (ALG): Anlisis de las opciones que ofrece el compilador a la hora de desarrollar interfaces grficas de usuario (GUI) empleando el API de Windows (WinAPI). 4. Valoracin econmica (VE): Estimacin de los costes reales del proyecto. 5. Cierre: Finalizacin del proyecto y entrega del documento al Coordinador y Director.
Adems, se realizar una actividad paralela a todas las dems, que consistir en la redaccin del documento del proyecto (Memoria).
- 208 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. Planificacin temporal
- 209 -
Captulo
Conclusiones
- 210 -
CAPTULO 2. Conclusiones.
Este captulo pretende poner de manifiesto el papel fundamental que la herramienta MinGW Developer Studio ha desempeado.
Este proyecto ha sido el punto final en la formacin acadmica del autor. Se ha convertido en un gran reto el superar con xito este proyecto, ya que ha supuesto un esfuerzo personal distribuido en tres fases concretas.
La primera fase, el estudio detallado del compilador, se caracteriz por la escasa informacin de la que se dispuso. Dado que es una herramienta de libre descarga (freeware), la informacin acerca de ella es prcticamente inexistente. Por ello, requiri un amplio aprendizaje de todas las opciones de las que dispone la herramienta as como de su manejo. Resulta sorprendente la multitud de opciones que ofrece el compilador teniendo en cuenta que es una herramienta de libre difusin. Una vez explorada a fondo, hay que resaltar la flexibilidad de la herramienta de cara al usuario as como lo intuitiva que resulta la navegacin por los mens y zonas de la interfaz de la aplicacin. Por ltimo, se puso especial empeo en dotar a la documentacin elaborada de un elevado nivel de detalle dado que en las correspondientes asignaturas de programacin en C que se imparten en primer curso de ingeniera de la escuela se utiliza el compilador y, por tanto, esta documentacin de la herramienta podr ser de ayuda a los estudiantes de las mismas.
La segunda fase, la explicacin de la programacin orientada a objetos (POO) empleando el compilador, exigi repasar conceptos tericos vistos en la asignatura de programacin en JAVA de segundo curso. Adems, se tuvo que llevar a cabo un repaso exhaustivo del lenguaje de programacin C++ aprendido en la correspondiente asignatura de tercer curso. Una vez finalizado este proceso comenz la ardua tarea de relacionar conceptos, aplicarlos a la programacin usando MinGW Developer Studio y, lo ms importante, ampliar dichos conceptos. Result fascinante trabajar con conceptos de gran potencia
- 211 -
Programacin Orientada a Objetos en C mediante MinGW Developer Studio. como la herencia o la abstraccin y poder aplicarlos de forma prctica empleando el compilador. Por ltimo, decir que la POO en s no es difcil, sino que lo difcil es programar bien. Si se programa bien, se podrn aprovechar todas las ventajas de la POO y, entre ellas, la ms importante: la reusabilidad (reutilizacin de cdigo).
La tercera y ltima fase, la programacin grfica empleando MinGW Developer Studio, fue sin duda alguna uno de los mayores retos del proyecto. El aprendizaje de la programacin usando la API de Windows, nunca antes estudiada, as como el empleo del editor de recursos del compilador supusieron un gran esfuerzo personal y una dedicacin intensa. A pesar de ser un tema muy extenso, se explicaron con cierto nivel de detalle los aspectos bsicos de la programacin grfica mediante WinAPI empleando MinGW Developer Studio. Por ltimo, resaltar que el empleo del compilador como herramienta de creacin de aplicaciones grficas as como su editor de recursos como herramienta de creacin de recursos se caracterizan por una gran sencillez y flexibilidad que permiten al usuario programar interfaces grficas de usuario de forma rpida e intuitiva a pesar de lo complejo del lenguaje de programacin usando la API de Windows.
Para finalizar, no se puede cerrar este captulo de conclusiones sin destacar la grata sorpresa que supuso contemplar que el compilador MinGW Developer Studio sirve para algo ms que para crear aplicaciones bsicas en lenguaje de programacin C. Como resultado de lo aprendido en la asignatura de programacin en C de primer curso en la que se empleaba el compilador, existe una opinin generalizada de que el compilador es una herramienta muy sencilla y bsica que permite poco ms que crear pequeas aplicaciones en C. Sin embargo, a raz de lo mostrado en este documento el compilador ofrece una gran variedad de posibilidades que van desde la propia programacin en C hasta la programacin grfica empleando la API de Windows pasando por la programacin orientada a objetos en C++, la creacin de recursos empleando el editor de recursos o la creacin de ficheros de cabecera.
- 212 -
Captulo
Bibliografa
- 213 -
CAPTULO 3. Bibliografa.
[MRAB00] Programacin Elemental en C++. Manual de Referencia Abreviado; Dpto. de Lenguajes y CC. Computacin E.T.S.I. Informtica Universidad de Mlaga; Revisin 1,20.
[PLJU07]
Pedro Lpez Jurez; Programacin III Parte II Tema 2 Introduccin al lenguaje C++/CLI; Junio 2007.
[UBIC00]
Vctor Muoz; Una breve introduccin a C++.
[CPAP00]
Sergio Lujn Mora; C++ paso a paso.
[PPHM07]
Dr. J.B. Hayet; Programacin en C++: polimorfismo; herencia mltiple; Centro de Investigacin en Matemticas; Octubre 2007.
[WACC07] Salvador Pozo Coronado; WinAPI con clase: Aplicaciones con API 32; Marzo 2007.
[IGUA00]
Carlos Marrero Expsito; Interfaz grfica de usuario: Aproximacin semitica y cognitiva.
Direcciones de Internet www.parinyasoft.com www.hermetic.ch/cfunlib/debug.htm www.cppreference.com www.es.wikipedia.org www.msdn.microsoft.com/en-us/library/aa383743.aspx www.winapi.conclase.net
- 214 -

Manual de Mingw

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Manual de Mingw

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSIDAD PONTIFICIA COMILLAS

ESCUELA TCNICA SUPERIOR DE INGENIERA (ICAI)

PROYECTO FIN DE CARRERA

PROGRAMACIN ORIENTADA A OBJETOS MEDIANTE MINGW DEVELOPER STUDIO

AUTOR: JACOBO IGLESIAS JATO MADRID, Septiembre de 2008

Autorizada la entrega del proyecto del alumno:

Jacobo Iglesias Jato

EL DIRECTOR DEL PROYECTO Eduardo Alcalde Lancharro

VB DEL COORDINADOR DE PROYECTOS Eduardo Alcalde Lancharro

Fecha: 12/ 09/ 08

El verdadero progreso es el que pone la tecnologa al alcance de todos.

Henry Ford. (1863-1947)

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

A mis hermanos, por su apoyo incondicional en los buenos y malos momentos.

A Alba, por aguantarme y confiar en m durante todo este tiempo.

A Edu, por su apoyo y confianza durante estos ltimos aos.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

PARTE I: Estudio del compilador

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Entorno de desarrollo de MinGW Developer Studio

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

CAPTULO 1. Entorno de desarrollo de MinGW Developer Studio.

Fecha de creacin 01-042005

Contenido Entorno de desarrollo y compilador. Entorno de desarrollo y compilador. Incluye

adems las libreras wxWidgets 2.6.0 para crear entornos grficos.

Entorno de desarrollo y compilador.

Propiedades del sistema

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Iniciar MinGW Developer Studio

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

CAPTULO 2. Iniciar MinGW Developer Studio.

2.1. Descarga e instalacin de MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

2.2. Iniciar MinGW Developer Studio.

iv. Se elige la opcin MinGW Developer Studio en el men.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

v. Transcurrido el tiempo de carga, se muestra el escritorio de MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Crear una aplicacin en lenguaje de programacin C

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

CAPTULO 3. Crear una aplicacin en lenguaje de programacin C.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

d. El entorno ya est listo para introducir el cdigo en la zona de edicin.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Estructura del entorno de desarrollo de MinGW Developer Studio

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

CAPTULO 4. Estructura del entorno de desarrollo de MinGW Developer Studio.

4.1. Zonas principales.

4.1.1. Zona de workspace.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Build. Rebuild. Build All

o Export Makefile: mismo comportamiento que Project - 20 -

4.1.2. Zona de edicin.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.

Print. Print Preview.

o Print Preview: mismo comportamiento que File

4.1.3. Zona de salida.

Programacin Orientada a Objetos en C mediante MinGW Developer Studio.