Ceballos: Programación orientada a objetos con C++ 4Ed

Programación orientada a objetos con C++ 4ª edición Fco. Javier Ceballos Sierra Profesor titular de la Escuela Politécnica Superior Universidad de Alcalá

http://www.fjceballos.es

Programación orientada a objetos con C++, 4ª edición. © Fco. Javier Ceballos Sierra © De la edición: RA-MA 2007 MARCAS COMERCIALES: Las marcas de los productos citados en el contenido de este libro (sean o no marcas registradas) pertenecen a sus respectivos propietarios. RA-MA no está asociada a ningún producto o fabricante mencioado en la obra, los datos y los ejemplos utilizados son ficticios salvo que se indique lo contrario. RA-MA es una marca comercial registrada. Se ha puesto el máximo empeño en ofrecer al lector una información completa y precisa. Sin embargo, RA-MA Editorial no asume ninguna responsabilidad derivada de su uso, ni tampoco por cualquier violación de patentes ni otros derechos de terceras partes que pudieran ocurrir. Esta publicación tiene por objeto proporcionar unos conocimientos precisos y acreditados sobre el tema tratado. Su venta no supone para el editor ninguna forma de asistencia legal, administrativa ni de ningún otro tipo. En caso de precisarse asesoría legal u otra forma de ayuda experta, deben buscarse los servicios de un profesional competente. Reservados todos los derechos de publicación en cualquier idioma. Según lo dispuesto en el Código Penal vigente ninguna parte de este libro puede ser reproducida, grabada en sistema de almacenamiento o transmitida en forma alguna ni por cualquier procedimiento, ya sea electrónico, mecánico, reprográfico, magnético o cualquier otro, sin autorización previa y por escrito de RA-MA; su contenido está protegido por la Ley vigente que establece penas de prisión y/o multas a quienes intencionadamente, reprodujeren o plagiaren, en todo o en parte, una obra literaria, artística o científica. Editado por: RA-MA Editorial C/ Jarama, 3A, Polígono industrial Igarsa 28860 PARACUELLOS DEL JARAMA, Madrid Teléfono: 91 658 42 80 Telefax: 91 662 81 39 Correo electrónico: [email protected] Internet: www.ra-ma.es y www.ra-ma.com ISBN: 978-84-7897-761-1 Depósito Legal: M-6895-2007 Autoedición: Fco. Javier Ceballos Filmación e impresión: Albadalejo, S.L. Impreso en España Primera impresión: Marzo 2007

CONTENIDO PRÓLOGO............................................................................................................. XV CAPÍTULO 1. PROGRAMACIÓN ORIENTADA A OBJETOS.....................

1

PENSAR EN OBJETOS .................................................................................... Clases y objetos ............................................................................................. Mensajes y métodos ...................................................................................... DISEÑO DE UNA CLASE DE OBJETOS........................................................ CONSTRUCTORES .......................................................................................... HERENCIA........................................................................................................ EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

2 2 3 4 12 14 21 25

CAPÍTULO 2. QUÉ APORTA C++ ....................................................................

27

HISTORIA DEL LENGUAJE C++ ................................................................... RESUMEN DE LA BIBLIOTECA DE C++ ..................................................... Entrada/salida ................................................................................................ Cadenas ......................................................................................................... Contenedores ................................................................................................. Iteradores ....................................................................................................... Algoritmos..................................................................................................... Números ........................................................................................................ Diagnósticos .................................................................................................. Utilidades generales....................................................................................... Localización .................................................................................................. Soporte del lenguaje ......................................................................................

27 29 29 30 30 30 30 31 31 31 31 31

VIII

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

C++ PARA PROGRAMADORES DE C ........................................................... Funciones ...................................................................................................... Palabras reservadas nuevas............................................................................ Comentarios................................................................................................... Operadores C++ ............................................................................................ Prioridad y orden de evaluación .................................................................... Conversión explícita del tipo de una expresión ............................................. Conversión del tipo void * ............................................................................ Tipos de datos predefinidos........................................................................... Tipos de datos definidos por el usuario ......................................................... Identificadores y estructuras.......................................................................... Ámbito de una estructura............................................................................... Declaración de constantes ............................................................................. Calificador volatile ........................................................................................ Flexibilidad en las declaraciones ................................................................... Declaración en una sentencia ........................................................................ El operador de resolución del ámbito (::) ...................................................... Especificaciones de enlace ............................................................................ PARÁMETROS POR OMISIÓN EN UNA FUNCIÓN .................................... FUNCIONES EN LÍNEA .................................................................................. MACROS ........................................................................................................... FUNCIONES SOBRECARGADAS .................................................................. Ambigüedades ............................................................................................... OPERADORES SOBRECARGADOS .............................................................. REFERENCIAS ................................................................................................. PASO DE PARÁMETROS POR REFERENCIA.............................................. REFERENCIA COMO VALOR RETORNADO............................................... TIPO BOOL ....................................................................................................... CLASES ............................................................................................................. PLANTILLAS.................................................................................................... ESPACIOS DE NOMBRES............................................................................... Directriz using ............................................................................................... ENTRADA Y SALIDA...................................................................................... Flujos de salida.............................................................................................. Flujos de entrada ........................................................................................... Estado de un flujo.......................................................................................... Limpiar el búfer asociado con un flujo.......................................................... Entrada/salida con formato............................................................................ Entrada de caracteres..................................................................................... Entrada de cadenas de caracteres................................................................... CONTENEDORES ............................................................................................ Vector ............................................................................................................ Acceso a los elementos.............................................................................

32 32 33 33 34 35 35 37 38 38 39 40 40 42 42 43 44 44 47 48 49 50 52 53 54 56 58 60 60 60 60 61 62 64 66 67 69 70 75 76 77 77 78

CONTENIDO

Iteradores.................................................................................................. Tamaño..................................................................................................... Eliminar elementos................................................................................... Buscar elementos...................................................................................... Insertar elementos..................................................................................... Comparaciones ......................................................................................... Map................................................................................................................ String ............................................................................................................. Constructores............................................................................................ Iteradores.................................................................................................. Acceso a un carácter................................................................................. Asignación................................................................................................ Conversiones a cadenas estilo C............................................................... Comparaciones ......................................................................................... Inserción................................................................................................... Concatenación .......................................................................................... Búsqueda .................................................................................................. Reemplazar............................................................................................... Subcadenas ............................................................................................... Tamaño..................................................................................................... Operaciones de E/S .................................................................................. EXCEPCIONES ................................................................................................. LOS OPERADORES new Y delete.................................................................... Operador new ................................................................................................ Memoria insuficiente..................................................................................... Función set_new_handler......................................................................... Operador delete ............................................................................................. Lagunas de memoria...................................................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

IX

79 79 79 80 80 80 81 82 82 83 83 83 84 84 85 85 86 86 86 87 87 88 90 90 93 93 95 96 97 99

CAPÍTULO 3. CLASES........................................................................................ 101 DEFINICIÓN DE UNA CLASE........................................................................ Atributos........................................................................................................ Métodos de una clase..................................................................................... Control de acceso a los miembros de la clase................................................ Acceso público ......................................................................................... Acceso privado......................................................................................... Acceso protegido...................................................................................... Clases en ficheros de cabecera ...................................................................... IMPLEMENTACIÓN DE UNA CLASE...........................................................

101 103 104 105 107 107 107 107 111

X

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

MÉTODOS SOBRECARGADOS ..................................................................... PARÁMETROS CON VALORES POR OMISIÓN .......................................... IMPLEMENTACIÓN DE UNA APLICACIÓN ............................................... EL PUNTERO IMPLÍCITO this ........................................................................ MÉTODOS Y OBJETOS CONSTANTES ........................................................ INICIACIÓN DE UN OBJETO ......................................................................... Constructor .................................................................................................... Asignación de objetos.................................................................................... Constructor copia .......................................................................................... DESTRUCCIÓN DE OBJETOS ........................................................................ Destructor ...................................................................................................... PUNTEROS COMO ATRIBUTOS DE UNA CLASE...................................... MIEMBROS STATIC DE UNA CLASE .......................................................... Atributos static .............................................................................................. Acceder a los atributos static ......................................................................... Métodos static................................................................................................ ATRIBUTOS QUE SON OBJETOS.................................................................. CLASES INTERNAS......................................................................................... INTEGRIDAD DE LOS DATOS ...................................................................... DEVOLVER UN PUNTERO O UNA REFERENCIA...................................... MATRICES DE OBJETOS................................................................................ FUNCIONES AMIGAS DE UNA CLASE........................................................ PUNTEROS A MIEMBROS DE UNA CLASE ................................................ EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

114 116 117 118 120 122 124 128 129 130 131 132 141 141 143 144 146 148 150 152 153 163 166 170 192

CAPÍTULO 4. OPERADORES SOBRECARGADOS....................................... 195 SOBRECARGAR UN OPERADOR.................................................................. UNA CLASE PARA NÚMEROS RACIONALES............................................ SOBRECARGA DE OPERADORES BINARIOS ............................................ Sobrecarga de operadores de asignación ....................................................... Sobrecarga de operadores aritméticos ........................................................... Aritmética mixta............................................................................................ Sobrecarga de operadores de relación ........................................................... Métodos adicionales ...................................................................................... Sobrecarga del operador de inserción............................................................ Sobrecarga del operador de extracción.......................................................... SOBRECARGA DE OPERADORES UNARIOS ............................................. Incremento y decremento .............................................................................. Operadores unarios/binarios .......................................................................... CONVERSIÓN DE TIPOS DEFINIDOS POR EL USUARIO .........................

195 202 204 204 207 208 210 210 211 214 216 217 218 219

CONTENIDO

Conversión mediante constructores ............................................................... Operadores de conversión ............................................................................. Ambigüedades ............................................................................................... ASIGNACIÓN ................................................................................................... INDEXACIÓN ................................................................................................... LLAMADA A FUNCIÓN.................................................................................. DESREFERENCIA ............................................................................................ SOBRECARGA DE LOS OPERADORES new y delete .................................. Sobrecarga del operador new ........................................................................ Sobrecarga del operador delete...................................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

XI

220 221 225 225 227 228 230 232 232 235 237 254

CAPÍTULO 5. CLASES DERIVADAS ............................................................... 257 CLASES DERIVADAS Y HERENCIA ............................................................ DEFINIR UNA CLASE DERIVADA ............................................................... Control de acceso a la clase base................................................................... Control de acceso a los miembros de las clases............................................. Qué miembros hereda una clase derivada...................................................... ATRIBUTOS CON EL MISMO NOMBRE ...................................................... REDEFINIR MÉTODOS DE LA CLASE BASE.............................................. CONSTRUCTORES DE CLASES DERIVADAS ............................................ COPIA DE OBJETOS........................................................................................ DESTRUCTORES DE CLASES DERIVADAS ............................................... JERARQUÍA DE CLASES................................................................................ FUNCIONES AMIGAS ..................................................................................... PUNTEROS Y REFERENCIAS........................................................................ Conversiones implícitas................................................................................. Restricciones ............................................................................................ Conversiones explícitas ................................................................................. MÉTODOS VIRTUALES.................................................................................. Cómo son implementados los métodos virtuales........................................... Constructores virtuales .................................................................................. Destructores virtuales .................................................................................... INFORMACIÓN DE TIPOS DURANTE LA EJECUCIÓN............................. Operador dynamic_cast ................................................................................. Operador typeid............................................................................................. POLIMORFISMO .............................................................................................. CLASES ABSTRACTAS .................................................................................. HERENCIA MÚLTIPLE ................................................................................... Clases base virtuales......................................................................................

258 262 263 264 265 270 272 274 277 280 280 289 290 291 293 294 296 300 302 305 306 306 309 310 325 327 330

XII

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

Redefinición de métodos de bases virtuales .................................................. Conversiones entre clases.............................................................................. EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

334 336 337 350

CAPÍTULO 6. PLANTILLAS.............................................................................. 353 DEFINICIÓN DE UNA PLANTILLA............................................................... FUNCIONES GENÉRICAS .............................................................................. Especialización de plantillas de función........................................................ Sobrecarga de plantillas de función............................................................... ORGANIZACIÓN DEL CÓDIGO DE LAS PLANTILLAS............................. Fichero único................................................................................................. Fichero de declaraciones y fichero de definiciones ....................................... Fichero único combinación de otros.............................................................. CLASES GENÉRICAS...................................................................................... Declaración previa de una clase genérica ...................................................... Especialización de plantillas de clase ............................................................ Derivación de plantillas ................................................................................. Otras características de las plantillas ............................................................. EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

354 356 360 362 364 364 365 367 368 373 373 379 382 385 394

CAPÍTULO 7. EXCEPCIONES .......................................................................... 397 EXCEPCIONES DE C++................................................................................... MANEJAR EXCEPCIONES ............................................................................. Lanzar una excepción .................................................................................... Capturar una excepción ................................................................................. Excepciones derivadas................................................................................... Capturar cualquier excepción ........................................................................ Relanzar una excepción ................................................................................. CREAR EXCEPCIONES................................................................................... Especificación de excepciones ...................................................................... Excepciones no esperadas ............................................................................. FLUJO DE EJECUCIÓN ................................................................................... CUÁNDO UTILIZAR EXCEPCIONES Y CUÁNDO NO ............................... ADQUISICIÓN DE RECURSOS ...................................................................... Punteros automáticos..................................................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

399 402 403 403 405 406 407 407 408 409 411 416 417 422 426 432

CONTENIDO

XIII

CAPÍTULO 8. FLUJOS ........................................................................................ 435 VISIÓN GENERAL DE LOS FLUJOS DE E/S ................................................ BÚFERES .......................................................................................................... VISIÓN GENERAL DE UN FICHERO ............................................................ DESCRIPCIÓN DE LOS BÚFERES Y FLUJOS.............................................. Clase streambuf ............................................................................................. Clase filebuf .................................................................................................. Clase ostream ................................................................................................ Clase istream ................................................................................................. Clase iostream ............................................................................................... Clase ofstream ............................................................................................... Clase ifstream ................................................................................................ Clase fstream ................................................................................................. E/S CARÁCTER A CARÁCTER ...................................................................... E/S DE CADENAS DE CARACTERES ........................................................... ENTRADA/SALIDA CON FORMATO............................................................ E/S UTILIZANDO REGISTROS ...................................................................... ABRIENDO FICHEROS PARA ACCESO SECUENCIAL ............................. Un ejemplo de acceso secuencial .................................................................. ESCRIBIR DATOS EN LA IMPRESORA........................................................ ACCESO ALEATORIO A FICHEROS EN EL DISCO.................................... CADENAS DE CARACTERES ........................................................................ Un ejemplo con flujos de cadena................................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

437 438 440 444 444 445 447 449 452 453 454 455 457 460 462 463 464 465 475 476 481 483 487 505

CAPÍTULO 9. HILOS........................................................................................... 507 CONCEPTO DE PROCESO.............................................................................. HILOS ................................................................................................................ Estados de un hilo.......................................................................................... Cuándo se debe crear un hilo......................................................................... BIBLIOTECAS C/C++ PARA PROGRAMAR CON HILOS........................... Biblioteca estándar POSIX Threads .............................................................. CREACIÓN Y DESTRUCCIÓN DE HILOS .................................................... Espera activa y pasiva ................................................................................... Pasar argumentos a un hilo............................................................................ Finalizar un hilo............................................................................................. Cancelación ................................................................................................... SINCRONIZACIÓN DE HILOS ....................................................................... Secciones críticas...........................................................................................

507 512 514 515 515 516 519 523 524 526 528 529 530

XIV

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

Exclusión mutua ....................................................................................... Mutex reentrante ...................................................................................... Semáforos...................................................................................................... Problema del productor-consumidor con semáforos ................................ Variables de condición .................................................................................. Problema del productor-consumidor ........................................................ PLANIFICACIÓN DE HILOS........................................................................... INTERBLOQUEO ............................................................................................. OBJETOS QUE SON HILOS ............................................................................ EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

534 538 539 541 544 548 551 553 554 558 565

APÉNDICES A. LA BIBLIOTECA DE C .................................................................................. 567 B. ENTORNOS DE DESARROLLO ................................................................... 593 C. INSTALACIÓN DEL PAQUETE DE DESARROLLO................................ 607 D. CÓDIGOS DE CARACTERES....................................................................... 611 ÍNDICE................................................................................................................... 617

PRÓLOGO Un programa tradicional se compone de procedimientos y de datos. Un programa orientado a objetos consiste solamente en objetos, entendiendo por objeto una entidad que tiene unos atributos particulares, los datos, y unas formas de operar sobre ellos, los métodos o procedimientos. La programación orientada a objetos es una de las técnicas más modernas que trata de disminuir el coste del software, aumentando la eficiencia en la programación y reduciendo el tiempo necesario para el desarrollo de una aplicación. Con la programación orientada a objetos, los programas tienen menos líneas de código, menos sentencias de bifurcación y módulos que son más comprensibles porque reflejan de una forma clara la relación existente entre cada concepto a desarrollar y cada objeto que interviene en dicho desarrollo. Donde la programación orientada a objetos toma verdadera ventaja es en la compartición y reutilización del código. Sin embargo, no debe pensarse que la programación orientada a objetos resuelve todos los problemas de una forma sencilla y rápida. Para conseguir buenos resultados, es preciso dedicar un tiempo significativamente superior al análisis y al diseño. Pero, éste no es un tiempo perdido, ya que simplificará enormemente la realización de aplicaciones futuras. Según lo expuesto, las ventajas de la programación orientada a objetos son sustanciales. No obstante, también presenta inconvenientes; por ejemplo, la ejecución de un programa no gana en velocidad y obliga al usuario a aprenderse una amplia biblioteca de clases antes de empezar a manipular un lenguaje orientado a objetos.

XVI

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

Existen varios lenguajes que permiten escribir un programa orientado a objetos y entre ellos se encuentra C++. Se trata de un lenguaje de programación basado en el lenguaje C, estandarizado (ISO/IEC 14882:1998 – International Organization for Standardization/International Electrotechnical Commission) y ampliamente difundido. Gracias a esta estandarización y a la biblioteca estándar, C++ se ha convertido en un lenguaje potente, eficiente y seguro, características que han hecho de C++ un lenguaje universal de propósito general ampliamente utilizado, tanto en el ámbito profesional como en el educativo, y competitivo frente a otros lenguajes como C# de Microsoft o Java de Sun Microsystems. Evidentemente, algunas nuevas características que se han incorporado a C# o a Java no están soportadas en la actualidad, como es el caso de la recolección de basura; no obstante, existen excelentes recolectores de basura de C++, tanto comerciales como gratuitos, que resuelven este problema. Otro futuro desarrollo previsto es la ampliación de la biblioteca estándar para desarrollar aplicaciones con interfaz gráfica de usuario. El libro, en su totalidad, está dedicado al aprendizaje de la programación orientada a objetos y al desarrollo de aplicaciones. Por lo tanto, se supone que si usted ha elegido este libro es porque ya posee conocimientos del lenguaje C/C++. Si no fuera así, quizás debiera empezar por leerse C/C++ - Curso de programación, o bien elegir uno que incluya ambas partes, lenguaje C/C++ y programación orientada a objetos, como sucede con la Enciclopedia de C++, ambos escritos también por mi. Todos los temas tratados en el libro se han documentado con abundantes problemas resueltos. Esta cuarta edición fue escrita utilizando indistintamente los compiladores que subyacen bajo los entornos de desarrollo Dev-C++ y Microsoft Visual C++ 2005 Express (véanse los apéndices B y C). En el primer caso se trata de un compilador GCC para Win32 (un compilador de C/C++ de la colección de compiladores GNU) de libre distribución que cumple la norma ISO/IEC 14882, del cual existen versiones para prácticamente todos los sistemas operativos. En el segundo caso se trata del compilador de C/C++ de Microsoft que también cumple el estándar. Ambos entornos de desarrollo se pueden obtener de forma gratuita en Internet. Por lo tanto, los ejemplos de este libro están escritos en C++ puro, tal y como se define en el estándar C++, lo que garantizará que se ejecuten en cualquier implementación que se ajuste a este estándar, que en la actualidad, casi con absoluta seguridad, serán la totalidad de las existentes. Por ejemplo, el autor probó la mayoría de los desarrollos bajo los EDI Dev-C++ y Microsoft Visual C++ 2005 Express, y también sobre la plataforma Linux, para conseguir un código lo más portable posible.

PRÓLOGO

XVII

Agradecimientos En la preparación de esta cuarta edición quiero, en especial, expresar mi agradecimiento a mi colega Manuel Peinado Gallego, con una amplia experiencia en desarrollos con C++, porque revisó la tercera edición de este libro y por sus aportaciones a esta nueva edición; a Óscar García Población y Elena Campo Montalvo, que revisaron el capítulo sobre hilos y aportaron ideas y sugerencias que me ayudaron a realizar un mejor desarrollo; a Sebastián Sánchez Prieto, autor de varios libros sobre sistemas operativos, porque, además de supervisar el capítulo sobre hilos, siempre estuvo dispuesto a resolver las preguntas que le planteé; a Inmaculada Rodríguez Santiago y Mª Dolores Rodríguez Moreno, que puntualizaron sobre las modificaciones que debía hacer a la segunda edición para llegar a una tercera. Todos ellos son o fueron profesores de la Universidad de Alcalá, con una amplia experiencia sobre la materia que trata el libro. Finalmente, no quiero olvidarme del resto de mis compañeros, aunque no cite sus nombres, porque todos ellos, de forma directa o indirecta, me ayudaron con la crítica constructiva que hicieron sobre las ediciones anteriores, y tampoco de mis alumnos que con su interés por aprender me hacen reflexionar sobre la forma más adecuada de transmitir estos conocimientos; a todos ellos les estoy francamente agradecido. Francisco Javier Ceballos Sierra http://www.fjceballos.es/

APÉNDICE A © F.J.Ceballos/RA-MA

LA BIBLIOTECA DE C La biblioteca de C puede ser utilizada también desde un programa C++. Por ejemplo, con frecuencia algunos programadores prefieren utilizar las funciones de E/S de C, que se encuentran en stdio.h (cstdio en la biblioteca de C++ estándar), por ser más familiares. En este caso, con la llamada a sync_with_stdio(false) de la clase ios_base antes de la primera operación de E/S puede desactivar la sincronización de las funciones iostream con las funciones cstdio, que por omisión está activada. Esta función retorna el modo de sincronización (true o false) previo. bool sync_with_stdio(bool sync = true);

Cuando la sincronización está desactivada (sync = false), las operaciones de E/S con cin, cout, cerr y clog se realizan utilizando un búfer de tipo filebuf y las operaciones con stdin, stdout, y stderr se realizan utilizando un búfer de tipo stdiobuf; esto es, los flujos iostream y los flujos cstdio operan independiente, lo cual puede mejorar la ejecución pero sin garantizar la sincronización. En cambio, cuando hay sincronización (sync = true), todos los flujos utilizan el mismo búfer, que es stdiobuf. El siguiente ejemplo le permitirá comprobar la sincronización en operaciones de E/S: // Comprobar si sync_with_stdio(true) trabaja #include #include using namespace std; int main() { /* 1. ¿Qué se escribe en test.txt cuando se invoca a sync_with_stdio con el argumento true? 2. ¿Y con el argumento false?

568

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

3. ¿Y cuando no se invoca a sync_with_stdio? (caso por omisión) */ ios_base::sync_with_stdio(); // Vincular stdout con el fichero test.txt freopen ("test.txt", "w", stdout); for (int i = 0; i < 2; i++) { printf("1"); cout Nuevo > Proyecto. 3. Seleccione el tipo de proyecto Win32 y la plantilla Aplicación de consola Win32. Escriba el nombre del proyecto en la caja Nombre y en la caja Ubicación seleccione el directorio donde desea crear este proyecto. Pulse el botón Aceptar. Se visualiza la siguiente ventana:

4. En esta ventana seleccione Biblioteca estática, no seleccione Encabezado precompilado y haga clic en el botón Finalizar. 5. Ahora tenemos un proyecto vacío. Ejecute la orden Proyecto > Agregar elemento existente y añada el fichero o los ficheros que contengan las funciones que desea incluir en su biblioteca así como los ficheros de cabecera necesarios para poder compilar el código escrito en cada una de las funciones. 6. Finalmente, ejecute la orden Generar > Generar... para compilar el proyecto y generar el fichero .lib.

APÉNDICE C © F.J.Ceballos/RA-MA

INSTALACIÓN DEL PAQUETE DE DESARROLLO En el apéndice B hemos visto cómo escribir y ejecutar una aplicación C++ desde dos entornos de desarrollo diferentes: Dev-C++, que incluye un compilador C/C++ de GCC (GNU Compiler Collection), y Microsoft Visual C++, que incluye el compilador Microsoft C/C++. También hemos visto que podemos hacerlo de dos formas diferentes: editando, compilando y depurando desde el entorno de desarrollo, o bien desde la línea de órdenes. Veamos a continuación cómo instalar estos compiladores.

INSTALACIÓN DE Dev-C++ Dev-C++ es un entorno de desarrollo que utiliza MinGW como compilador. MinGW (Minimalist GNU for Win32) es un paquete que proporciona una versión nativa de Win32 de GCC (gcc, g++, g77, etc.), el depurador gdb, make, win32api, y otras utilidades. Se puede realizar una instalación personalizada instalando por una parte la implementación GCC, y por otra el entorno de desarrollo integrado (EDI) Dev-C++, o bien se puede instalar una versión de Dev-C++ que ya incluye GCC; ésta es la opción recomendada. Para realizar la instalación de Dev-C++ con GCC, ejecute el fichero devcpp4.9.9.2_setup.exe localizado en la carpeta EDI del CD-ROM (o puede descargar la última versión desde mi Web: http://www.fjceballos.es > Utilidades) y siga los pasos indicados por el asistente. A continuación abra el EDI y desde el menú Herramientas puede, si lo cree necesario, configurar las opciones del compilador, del entorno y del editor.

608

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

INSTALACIÓN DE Microsoft C/C++ Visual Studio 2005 proporciona una variedad de herramientas tanto para desarrolladores individuales como para equipos de desarrollo. Puede obtener más información de la dirección: http://www.microsoft.com/spanish/msdn/vs2005/default.mspx

Visual Studio se distribuye en varias ediciones. De menos profesionales a más profesionales estas son las siguientes: • • • •

Ediciones Visual Studio 2005 Express. Visual Studio 2005 Standard Edition. Visual Studio 2005 Professional Edition. Visual Studio 2005 Team System.

Visual Studio 2005 Express es la nueva línea de productos que expanden Visual Studio ofreciendo herramientas ligeras y sencillas de aprender y de usar para aficionados, entusiastas y aprendices que quieren crear sitios Web y aplicaciones para Windows. • • • • • •

Visual Web Developer 2005 Express Edition. Visual Basic 2005 Express Edition. Visual C# 2005 Express Edition. Visual C++ 2005 Express Edition. SQL Server 2005 Express Edition. y Visual J# 2005 Express Edition.

Para instalar Visual C++ 2005 Express tiene que hacerlo desde la dirección de Internet suministrada en la carpeta EDI del CD-ROM (o puede hacerlo desde mi Web: http://www.fjceballos.es > Utilidades). Desde esta dirección se descargará un fichero que, una vez ejecutado, iniciará el asistente de instalación. Este asistente le ofrecerá instalar el EDI gráfico, unos 70 MB, y otras funciones adicionales; por ejemplo, MSDN 2005, unos 320 MB, que contiene información adicional del producto para todas las ediciones Express. Esta información también está disponible en Internet en la Web de Microsoft, por lo que para una instalación rápida se recomienda no descargarla. Conclusión, es suficiente con instalar el EDI gráfico.

APÉNDICE C: INSTALACIÓN DEL PAQUETE DE DESARROLLO

609

INSTALACIÓN DE LA BIBLIOTECA POSIX Threads Para trabajar con hilos POSIX, capítulo 9, tiene que instalar la biblioteca POSIX Threads. Para ello, suponiendo que el compilador instalado es GCC, siga los pasos siguientes: 1. Descomprima el fichero pthreads-w32-2-8-0-release.exe localizado en la carpeta Pthreads-win32 del CD-ROM, en una carpeta temporal, por ejemplo en c:\pthread. 2. Copie los ficheros c:\pthread\include\*.h en la carpeta include de su instalación. 3. Copie las bibliotecas c:\pthread\lib\*.a en la carpeta lib de su instalación. 4. Copie las bibliotecas de igual nombre que las anteriores y extensión .dll, pero sin prefijo lib, en la carpeta system32 de Windows o en la carpeta bin de su instalación. Esta biblioteca también está disponible para el compilador C/C++ de Microsoft (compilador que utiliza Microsoft Visual C++: MSVC++). Para instalarla siga los pasos indicados a continuación: 1. Descomprima el fichero pthreads-w32-2-8-0-release.exe localizado en la carpeta Pthreads-win32 del CD-ROM, en una carpeta temporal, por ejemplo en c:\pthread. 2. Copie los ficheros c:\pthread\include\*.h en la carpeta include de su instalación. 3. Copie las bibliotecas c:\pthread\lib\*.lib en la carpeta lib de su instalación. 4. Copie las bibliotecas de igual nombre que las anteriores y extensión .dll, en la carpeta system32 de Windows.

Compilar una aplicación multihilo Para compilar una aplicación multihilo desde la línea de órdenes, tiene que añadir la biblioteca que proporciona el soporte multihilo. Desde una consola con MinGW proceda así: path=%path%;c:\Dev-Cpp\bin g++ -o miapp.exe miapp.cpp [otros .cpp] —l pthreadGCE2

610

PROGRAMACIÓN ORIENTADA A OBJETOS CON C++

Desde el EDI Dev-C++ tiene que especificar en las opciones del proyecto la biblioteca de hilos que desea utilizar: libpthreadGC2.a o libpthreadGCE2.a. Para ello, diríjase a la barra de menús y ejecute: Proyecto - Opciones del proyecto - Parámetros - Añadir biblioteca

Desde una consola con Visual C++ proceda así: C:\Archivos de programa\Microsoft Visual Studio 8\VC\bin\vcvars32.bat cl /EHsc miapp.cpp [otros .cpp] /link pthreadVSE2.lib

Desde el EDI Visual C++ tiene que especificar en las opciones del proyecto la biblioteca de hilos que desea utilizar: pthreadVC2.lib, pthreadVCE2.lib o pthreadVSE2.lib. Para ello, haga clic con el botón derecho del ratón sobre el nombre del proyecto y seleccione: Propiedades - Opciones del proyecto — Propiedades de configuración — Vinculador — Línea de comandos

y escriba en la ventana Opciones adicionales, por ejemplo: pthreadVSE2.lib. Finalmente, para compilar una aplicación multihilo desde la línea de órdenes en una plataforma LINUX, tiene que añadir la biblioteca pthread: g++ -o miapp.exe miapp.cpp [otros .cpp] —l pthread