Enciclopedia Del Lenguaje C__ ( - Ceballos Sierra, Fco. Javier(Au

Enciclopedia del lenguaje C++ 2ª edición

Enciclopedia del lenguaje C++ 2ª edición Fco. Javier Ceballos Sierra Profesor titular de la Escuela Politécnica Superior Universidad de Alcalá

  (QFLFORSHGLDGHOOHQJXDMH&HGLFLyQ ‹)FR-DYLHU&HEDOORV6LHUUD ‹'HODHGLFLyQ5$0$  0$5&$6&20(5&,$/(6/DVPDUFDVGHORVSURGXFWRVFLWDGRVHQHOFRQWHQLGRGHHVWHOLEUR VHDQRQRPDUFDVUHJLVWUDGDV SHUWHQHFHQDVXVUHVSHFWLYRVSURSLHWDULRV5$0$QRHVWi DVRFLDGDDQLQJ~QSURGXFWRRIDEULFDQWHPHQFLRDGRHQODREUDORVGDWRV\ORVHMHPSORV XWLOL]DGRVVRQILFWLFLRVVDOYRTXHVHLQGLTXHORFRQWUDULR  5$0$HVXQDPDUFDFRPHUFLDOUHJLVWUDGD  6HKDSXHVWRHOPi[LPRHPSHxRHQRIUHFHUDOOHFWRUXQDLQIRUPDFLyQFRPSOHWD\SUHFLVD 6LQHPEDUJR5$0$(GLWRULDOQRDVXPHQLQJXQDUHVSRQVDELOLGDGGHULYDGDGHVXXVR QLWDPSRFRSRUFXDOTXLHUYLRODFLyQGHSDWHQWHVQLRWURVGHUHFKRVGHWHUFHUDVSDUWHVTXHSXGLHUDQ RFXUULU(VWDSXEOLFDFLyQWLHQHSRUREMHWRSURSRUFLRQDUXQRVFRQRFLPLHQWRVSUHFLVRV\DFUHGLWDGRV VREUHHOWHPDWUDWDGR6XYHQWDQRVXSRQHSDUDHOHGLWRUQLQJXQDIRUPDGHDVLVWHQFLDOHJDO DGPLQLVWUDWLYDQLGHQLQJ~QRWURWLSR(QFDVRGHSUHFLVDUVHDVHVRUtDOHJDOXRWUDIRUPDGHD\XGD H[SHUWDGHEHQEXVFDUVHORVVHUYLFLRVGHXQSURIHVLRQDOFRPSHWHQWH  5HVHUYDGRVWRGRVORVGHUHFKRVGHSXEOLFDFLyQHQFXDOTXLHULGLRPD  6HJ~QORGLVSXHVWRHQHO&yGLJR3HQDOYLJHQWHQLQJXQDSDUWHGHHVWHOLEURSXHGHVHU UHSURGXFLGDJUDEDGDHQVLVWHPDGHDOPDFHQDPLHQWRRWUDQVPLWLGDHQIRUPDDOJXQDQL SRUFXDOTXLHUSURFHGLPLHQWR\DVHDHOHFWUyQLFRPHFiQLFRUHSURJUiILFRPDJQpWLFRR FXDOTXLHURWURVLQDXWRUL]DFLyQSUHYLD\SRUHVFULWRGH5$0$VXFRQWHQLGRHVWiSURWHJLGR SRUOD/H\YLJHQWHTXHHVWDEOHFHSHQDVGHSULVLyQ\RPXOWDVDTXLHQHVLQWHQFLRQDGDPHQWH UHSURGXMHUHQRSODJLDUHQHQWRGRRHQSDUWHXQDREUDOLWHUDULDDUWtVWLFDRFLHQWtILFD  (GLWDGRSRU 5$0$(GLWRULDO &-DUDPD$3ROtJRQRLQGXVWULDO,JDUVD 3$5$&8(//26'(/-$5$0$0DGULG 7HOpIRQR 7HOHID[ &RUUHRHOHFWUyQLFRHGLWRULDO#UDPDFRP ,QWHUQHWHERRNVUDPDFRPZZZUDPDHV\ZZZUDPDFRP ,6%1 'HSyVLWR/HJDO0 $XWRHGLFLyQ)FR-DYLHU&HEDOORV )LOPDFLyQHLPSUHVLyQ&ORVDV2UFR\HQ6/ ,PSUHVRHQ(VSDxD 3ULPHUDLPSUHVLyQ$EULO

 

La diferencia sólo se marca cuando te sales del camino ya marcado por otros. Dedico esta obra a María del Carmen, mi esposa, y a mis hijos Francisco y Javier.

RESUMEN DEL CONTENIDO PARTE 1. PROGRAMACIÓN BÁSICA .................................

1

CAPÍTULO 1. INTRODUCCIÓN A C++ ...............................................................

3

CAPÍTULO 2. ELEMENTOS DEL LENGUAJE C++ ...........................................

25

CAPÍTULO 3. ESTRUCTURA DE UN PROGRAMA ..........................................

59

CAPÍTULO 4. ENTRADA Y SALIDA ESTÁNDAR ............................................

97

CAPÍTULO 5. SENTENCIAS DE CONTROL ....................................................... 127 CAPÍTULO 6. TIPOS ESTRUCTURADOS DE DATOS ...................................... 165 CAPÍTULO 7. PUNTEROS, REFERENCIAS Y GESTIÓN DE LA MEMORIA . 225 CAPÍTULO 8. MÁS SOBRE FUNCIONES ........................................................... 281

PARTE 2. MECANISMOS DE ABSTRACCIÓN................... 333 CAPÍTULO 9. CLASES .......................................................................................... 335 CAPÍTULO 10. OPERADORES SOBRECARGADOS ......................................... 421 CAPÍTULO 11. CLASES DERIVADAS ................................................................ 483 CAPÍTULO 12. PLANTILLAS ............................................................................... 579 CAPÍTULO 13. EXCEPCIONES ............................................................................ 623

VIII

ENCICLOPEDIA DEL LENGUAJE C++

CAPÍTULO 14. FLUJOS ......................................................................................... 661

PARTE 3. DISEÑO Y PROGRAMACIÓN ............................. 707 CAPÍTULO 15. ESTRUCTURAS DINÁMICAS ................................................... 709 CAPÍTULO 16. ALGORITMOS ............................................................................. 797

PARTE 4. APÉNDICES ........................................................... 813 A. NOVEDADES EN C++0x .................................................................................. 815 B. LA BIBLIOTECA ESTÁNDAR DE C++........................................................... 833 C. LA BIBLIOTECA DE C ..................................................................................... 837 D. ENTORNOS DE DESARROLLO ...................................................................... 863 E. INSTALACIÓN DEL PAQUETE DE DESARROLLO ..................................... 879 F. CÓDIGOS DE CARACTERES ........................................................................... 883

CONTENIDO PRÓLOGO.........................................................................................................

XXI

PARTE 1. PROGRAMACIÓN BÁSICA ................................

1

CAPÍTULO 1. INTRODUCCIÓN A C++............................................................

3

¿POR QUÉ APRENDER C++? .......................................................................... REALIZACIÓN DE UN PROGRAMA EN C++ ............................................... Cómo crear un programa ................................................................................ ¿Qué hace este programa?......................................................................... Guardar el programa escrito en el disco.................................................... Compilar y ejecutar el programa ............................................................... Biblioteca estándar de C++ ....................................................................... Depurar un programa ................................................................................ EJERCICIO ......................................................................................................... DECLARACIÓN DE UNA VARIABLE ........................................................... ASIGNAR VALORES ........................................................................................ AÑADIR COMENTARIOS ............................................................................... EXPRESIONES ARITMÉTICAS ...................................................................... EXPRESIONES CONDICIONALES ................................................................. ESCRIBIR NUESTRAS PROPIAS FUNCIONES............................................. EJERCICIOS PROPUESTOS.............................................................................

4 5 6 7 8 8 8 10 11 12 15 16 18 19 22 23

CAPÍTULO 2. ELEMENTOS DEL LENGUAJE C++ ......................................

25

PRESENTACIÓN DE LA SINTAXIS DE C++ ................................................. CARACTERES DE C++ ....................................................................................

25 26

X

ENCICLOPEDIA DEL LENGUAJE C++

Letras, dígitos y carácter de subrayado .......................................................... Espacios en blanco ......................................................................................... Caracteres especiales y signos de puntuación ................................................ Secuencias de escape...................................................................................... TIPOS DE DATOS ............................................................................................. Tipos primitivos ............................................................................................. Tipos derivados .............................................................................................. Enumeraciones .......................................................................................... Clases ........................................................................................................ SINÓNIMOS DE UN TIPO ................................................................................ LITERALES ....................................................................................................... Literales enteros ............................................................................................. Literales reales ............................................................................................... Literales de un solo carácter ........................................................................... Literales de cadenas de caracteres .................................................................. IDENTIFICADORES ......................................................................................... PALABRAS CLAVE .......................................................................................... DECLARACIÓN DE CONSTANTES SIMBÓLICAS ...................................... ¿Por qué utilizar constantes? .......................................................................... DECLARACIÓN DE UNA VARIABLE ........................................................... Iniciación de una variable .............................................................................. OPERADORES................................................................................................... Operadores aritméticos................................................................................... Operadores de relación................................................................................... Operadores lógicos ......................................................................................... Operadores unitarios ...................................................................................... Operadores a nivel de bits .............................................................................. Operadores de asignación .............................................................................. Operador condicional ..................................................................................... Otros operadores ............................................................................................ Operador global y de resolución de ámbito (::) ........................................ Operador sizeof ......................................................................................... Operador coma .......................................................................................... Operador dirección-de .............................................................................. Operador de indirección ............................................................................ Operador referencia a ................................................................................ PRIORIDAD Y ORDEN DE EVALUACIÓN ................................................... CONVERSIÓN ENTRE TIPOS DE DATOS..................................................... EJERCICIOS PROPUESTOS.............................................................................

26 26 27 27 28 28 29 30 32 33 33 34 35 35 36 36 36 37 38 38 39 39 39 40 41 42 43 43 46 47 47 48 48 49 49 50 52 53 56

CONTENIDO

XI

CAPÍTULO 3. ESTRUCTURA DE UN PROGRAMA ......................................

59

PARADIGMAS DE PROGRAMACIÓN ........................................................... ESTRUCTURA DE UN PROGRAMA C++ ...................................................... Directrices para el preprocesador ................................................................... Inclusión incondicional ............................................................................. Definición de un identificador .................................................................. Inclusión condicional ................................................................................ Definiciones y declaraciones.......................................................................... Sentencia simple ............................................................................................ Sentencia compuesta o bloque ....................................................................... Funciones ....................................................................................................... Declaración de una función ...................................................................... Definición de una función ......................................................................... Llamada a una función .............................................................................. Función main.................................................................................................. PASANDO ARGUMENTOS A LAS FUNCIONES.......................................... PROGRAMA C++ FORMADO POR VARIOS MÓDULOS ............................ ÁMBITO DE UN NOMBRE .............................................................................. Nombres globales y locales ............................................................................ CLASES DE ALMACENAMIENTO DE UNA VARIABLE............................ Calificación de variables globales .................................................................. Calificación de variables locales .................................................................... ESPACIOS DE NOMBRES ............................................................................... Directriz using ................................................................................................ EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

59 60 63 64 64 65 65 66 66 67 67 70 72 72 73 78 81 81 83 83 85 87 89 91 92

CAPÍTULO 4. ENTRADA Y SALIDA ESTÁNDAR .........................................

97

ENTRADA Y SALIDA ...................................................................................... Flujos de salida............................................................................................... Flujos de entrada ............................................................................................ ESTADO DE UN FLUJO ................................................................................... DESCARTAR CARACTERES DEL FLUJO DE ENTRADA .......................... ENTRADA/SALIDA CON FORMATO ............................................................ ENTRADA DE CARACTERES......................................................................... CARÁCTER FIN DE FICHERO ........................................................................ CARÁCTER \n ................................................................................................... ENTRADA DE CADENAS DE CARACTERES .............................................. EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

98 99 101 104 106 107 112 113 115 117 117 122

XII

ENCICLOPEDIA DEL LENGUAJE C++

CAPÍTULO 5. SENTENCIAS DE CONTROL ................................................... 127 SENTENCIA if ................................................................................................... ANIDAMIENTO DE SENTENCIAS if ............................................................. ESTRUCTURA else if ........................................................................................ SENTENCIA switch ........................................................................................... SENTENCIA while ............................................................................................. Bucles anidados.............................................................................................. SENTENCIA do ... while .................................................................................... SENTENCIA for ................................................................................................. SENTENCIA break ............................................................................................. SENTENCIA continue ........................................................................................ SENTENCIA goto .............................................................................................. SENTENCIAS try ... catch.................................................................................. EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

127 129 132 134 137 140 142 145 149 150 150 152 153 157

CAPÍTULO 6. TIPOS ESTRUCTURADOS DE DATOS .................................. 165 INTRODUCCIÓN A LAS MATRICES ............................................................. MATRICES NUMÉRICAS UNIDIMENSIONALES ........................................ Definir una matriz .......................................................................................... Acceder a los elementos de una matriz .......................................................... Iniciar una matriz ........................................................................................... Trabajar con matrices unidimensionales ........................................................ Tipo y tamaño de una matriz .......................................................................... Vector ............................................................................................................. Acceso a los elementos ............................................................................. Iteradores................................................................................................... Tamaño ..................................................................................................... Eliminar elementos ................................................................................... Buscar elementos ...................................................................................... Insertar elementos ..................................................................................... Ejemplo ..................................................................................................... Matrices asociativas ....................................................................................... Map ................................................................................................................ CADENAS DE CARACTERES ......................................................................... Leer y escribir una cadena de caracteres ........................................................ String .............................................................................................................. Constructores ............................................................................................ Iteradores................................................................................................... Acceso a un carácter .................................................................................

166 167 167 168 169 170 172 172 173 174 175 175 175 175 176 178 180 183 184 185 185 186 186

CONTENIDO

XIII

Asignación ................................................................................................ Conversiones a cadenas estilo C ............................................................... Comparaciones .......................................................................................... Inserción.................................................................................................... Concatenación ........................................................................................... Búsqueda ................................................................................................... Reemplazar ............................................................................................... Subcadenas................................................................................................ Tamaño ..................................................................................................... Operaciones de E/S ................................................................................... MATRICES MULTIDIMENSIONALES ........................................................... Matrices numéricas multidimensionales ........................................................ Matrices de cadenas de caracteres .................................................................. Matrices de objetos string .............................................................................. SENTENCIA for_each ........................................................................................ ESTRUCTURAS ................................................................................................ Definir una estructura..................................................................................... Matrices de estructuras ................................................................................... UNIONES ........................................................................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

186 187 187 188 189 189 189 189 190 190 191 191 197 198 201 201 202 206 208 210 218

CAPÍTULO 7. PUNTEROS, REFERENCIAS Y GESTIÓN DE LA MEMORIA . 225 CREACIÓN DE PUNTEROS ............................................................................ Operadores ..................................................................................................... Importancia del tipo del objeto al que se apunta ............................................ OPERACIONES CON PUNTEROS .................................................................. Operación de asignación ................................................................................ Operaciones aritméticas ................................................................................. Comparación de punteros............................................................................... Punteros genéricos ......................................................................................... Puntero nulo ................................................................................................... Punteros y objetos constantes ........................................................................ REFERENCIAS .................................................................................................. Paso de parámetros por referencia ................................................................. PUNTEROS Y MATRICES ............................................................................... Punteros a cadenas de caracteres.................................................................... MATRICES DE PUNTEROS ............................................................................. Punteros a punteros ........................................................................................ Matriz de punteros a cadenas de caracteres ................................................... ASIGNACIÓN DINÁMICA DE MEMORIA ....................................................

225 227 228 228 229 229 231 231 232 232 233 233 235 239 241 243 246 248

XIV

ENCICLOPEDIA DEL LENGUAJE C++

Operadores para asignación dinámica de memoria ........................................ new ............................................................................................................ delete ......................................................................................................... Reasignar un bloque de memoria ................................................................... MATRICES DINÁMICAS ................................................................................. PUNTEROS A ESTRUCTURAS ....................................................................... PUNTEROS COMO PARÁMETROS EN FUNCIONES .................................. DECLARACIONES COMPLEJAS .................................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

249 249 251 252 254 258 260 264 265 272

CAPÍTULO 8. MÁS SOBRE FUNCIONES ........................................................ 281 PASAR UNA MATRIZ COMO ARGUMENTO A UNA FUNCIÓN .............. Matrices automáticas ...................................................................................... Matrices dinámicas y contenedores ............................................................... PASAR UN PUNTERO COMO ARGUMENTO A UNA FUNCIÓN .............. PASAR UNA ESTRUCTURA A UNA FUNCIÓN ........................................... DATOS RETORNADOS POR UNA FUNCIÓN ............................................... Retornar una copia de los datos ..................................................................... Retornar un puntero al bloque de datos.......................................................... Retornar la dirección de una variable declarada static ................................... Retornar una referencia .................................................................................. ARGUMENTOS EN LA LÍNEA DE ÓRDENES .............................................. REDIRECCIÓN DE LA ENTRADA Y DE LA SALIDA ................................. FUNCIONES RECURSIVAS............................................................................. PARÁMETROS POR OMISIÓN EN UNA FUNCIÓN..................................... FUNCIONES EN LÍNEA ................................................................................... MACROS ............................................................................................................ FUNCIONES SOBRECARGADAS ................................................................... Ambigüedades ................................................................................................ OPERADORES SOBRECARGADOS ............................................................... PUNTEROS A FUNCIONES ............................................................................. EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

281 282 284 286 290 293 293 295 297 299 301 303 305 307 309 310 311 313 314 315 320 325

PARTE 2. MECANISMOS DE ABSTRACCIÓN................... 333 CAPÍTULO 9. CLASES ........................................................................................ 335 DEFINICIÓN DE UNA CLASE ........................................................................ 335

CONTENIDO

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 ........................................................... 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 LOS MIEMBROS DE UNA CLASE ........................................ EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

XV 337 338 339 340 341 341 341 345 348 350 351 352 354 356 358 362 363 364 365 366 375 375 377 378 380 382 384 386 387 397 400 404 419

CAPÍTULO 10. OPERADORES SOBRECARGADOS ..................................... 421 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.............................................................................................

421 428 430 430 432 434

XVI

ENCICLOPEDIA DEL LENGUAJE C++

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 ......................... 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.............................................................................

436 436 437 440 442 442 444 444 446 447 451 451 453 454 456 458 458 461 463 480

CAPÍTULO 11. CLASES DERIVADAS .............................................................. 483 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 ...................................................................................

484 488 489 490 491 496 498 500 503 506 506 514 516 517 519 520 522 526 528

CONTENIDO

Destructores virtuales ..................................................................................... INFORMACIÓN DE TIPOS DURANTE LA EJECUCIÓN ............................. Operador dynamic_cast.................................................................................. Operador typeid.............................................................................................. POLIMORFISMO............................................................................................... CLASES ABSTRACTAS ................................................................................... HERENCIA MÚLTIPLE .................................................................................... Clases base virtuales ...................................................................................... Redefinición de métodos de bases virtuales ................................................... Conversiones entre clases .............................................................................. EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

XVII 530 532 532 535 535 550 552 556 560 562 563 575

CAPÍTULO 12. PLANTILLAS ............................................................................ 579 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.............................................................................

580 582 586 588 590 590 591 593 594 599 599 605 608 611 620

CAPÍTULO 13. EXCEPCIONES ......................................................................... 623 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 .......................................................................

625 628 629 629 631 632 633 633 634

XVIII

ENCICLOPEDIA DEL LENGUAJE C++

Excepciones no esperadas .............................................................................. FLUJO DE EJECUCIÓN .................................................................................... CUÁNDO UTILIZAR EXCEPCIONES Y CUÁNDO NO ................................ ADQUISICIÓN DE RECURSOS ....................................................................... Punteros inteligentes ...................................................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

635 637 642 643 649 653 659

CAPÍTULO 14. FLUJOS....................................................................................... 661 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 UTILIZANDO REGISTROS ....................................................................... ESCRIBIR DATOS EN LA IMPRESORA ........................................................ ABRIENDO FICHEROS PARA ACCESO SECUENCIAL .............................. Un ejemplo de acceso secuencial ................................................................... ACCESO ALEATORIO A FICHEROS EN EL DISCO .................................... EJERCICIOS PROPUESTOS.............................................................................

663 664 666 670 670 671 673 675 678 679 681 683 685 687 687 688 698 703

PARTE 3. DISEÑO Y PROGRAMACIÓN ............................. 707 CAPÍTULO 15. ESTRUCTURAS DINÁMICAS ................................................ 709 LISTAS LINEALES ........................................................................................... Listas lineales simplemente enlazadas ........................................................... Operaciones básicas ....................................................................................... Inserción de un elemento al comienzo de la lista ...................................... Buscar en una lista un elemento con un valor x ........................................ Inserción de un elemento en general ......................................................... Borrar un elemento de la lista ................................................................... Recorrer una lista ......................................................................................

710 710 713 714 715 716 717 718

CONTENIDO

XIX

Borrar todos los elementos de una lista .................................................... UNA CLASE PARA LISTAS LINEALES ........................................................ Clase genérica para listas lineales .................................................................. Consistencia de la aplicación ......................................................................... LISTAS CIRCULARES ..................................................................................... Clase CListaCircularSE........................................................................... PILAS.................................................................................................................. COLAS ................................................................................................................ EJEMPLO ........................................................................................................... LISTA DOBLEMENTE ENLAZADA ............................................................... Lista circular doblemente enlazada ................................................................ Clase CListaCircularDE ..................................................................... Ejemplo ..................................................................................................... ÁRBOLES........................................................................................................... Árboles binarios ............................................................................................. Formas de recorrer un árbol binario ............................................................... ÁRBOLES BINARIOS DE BÚSQUEDA .......................................................... Clase CArbolBinB .................................................................................. Buscar un nodo en el árbol ............................................................................. Insertar un nodo en el árbol............................................................................ Borrar un nodo del árbol ................................................................................ Utilización de la clase CArbolBinB ........................................................ ÁRBOLES BINARIOS PERFECTAMENTE EQUILIBRADOS ...................... Clase CArbolBinE ................................................................................... Utilización de la clase CArbolBinE ........................................................ CLASES RELACIONADAS DE LA BIBLIOTECA C++................................. Plantilla list .................................................................................................... EJERCICIOS PROPUESTOS.............................................................................

718 719 722 731 733 734 739 741 743 746 746 747 754 756 757 759 761 762 766 767 768 771 774 775 783 786 786 789

CAPÍTULO 16. ALGORITMOS .......................................................................... 797 ORDENACIÓN DE DATOS .............................................................................. Método de la burbuja ..................................................................................... Método de inserción ....................................................................................... Método quicksort ........................................................................................... Comparación de los métodos expuestos......................................................... BÚSQUEDA DE DATOS .................................................................................. Búsqueda secuencial ...................................................................................... Búsqueda binaria ............................................................................................ Búsqueda de cadenas ..................................................................................... CLASES RELACIONADAS DE LA BIBLIOTECA C++................................. Modo de empleo de los algoritmos ................................................................

797 798 801 802 804 805 805 805 806 810 811

XX

ENCICLOPEDIA DEL LENGUAJE C++

EJERCICIOS PROPUESTOS............................................................................. 812

PARTE 4. APÉNDICES ........................................................... 813 NOVEDADES DE C++0x ...................................................................................... 815 LA BIBLIOTECA ESTÁNDAR DE C++ ............................................................ 833 LA BIBLIOTECA DE C ........................................................................................ 837 ENTORNOS DE DESARROLLO ........................................................................ 863 INSTALACIÓN DEL PAQUETE DE DESARROLLO ..................................... 879 CÓDIGOS DE CARACTERES ............................................................................ 883 ÍNDICE .................................................................................................................. 889

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. No obstante, é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. Pero 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. 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 basa-

XXII

ENCICLOPEDIA DEL LENGUAJE C++

do en el lenguaje C, estandarizado (ISO/IEC – 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 él 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. ¿Por qué C++? Porque posee características superiores a otros lenguajes. Las más importantes son: x

Programación orientada a objetos. Esta característica permite al programador diseñar aplicaciones pensando más bien en la comunicación entre objetos que en una secuencia estructurada de código. Además, permite la reutilización del código de una forma más lógica y productiva.

x

Portabilidad. Prácticamente se puede compilar el mismo código C++ en la casi totalidad de ordenadores y sistemas operativos sin apenas hacer cambios. Por eso C++ es uno de los lenguajes más utilizados y portados a diferentes plataformas.

x

Brevedad. El código escrito en C++ es muy corto en comparación con otros lenguajes, debido a la facilidad con la que se pueden anidar expresiones y a la gran cantidad de operadores.

x

Programación modular. El cuerpo de una aplicación en C++ puede construirse a partir de varios ficheros fuente que serán compilados separadamente para después ser enlazados todos juntos. Esto supone un ahorro de tiempo durante el diseño, ya que cada vez que se realice una modificación en uno de ellos no es necesario recompilar la aplicación completa, sino sólo el fichero que se modificó.

x

Compatibilidad con C. Cualquier código escrito en C puede fácilmente ser incluido en un programa C++ sin apenas cambios.

x

Velocidad. El código resultante de una compilación en C++ es muy eficiente debido a su dualidad como lenguaje de alto y bajo nivel y al reducido tamaño del lenguaje mismo.

PRÓLOGO

XXIII

El libro, en su totalidad, está dedicado al aprendizaje del lenguaje C++, de la programación orientada a objetos y al desarrollo de aplicaciones. Esta materia puede agruparse en los siguientes apartados: x x x

Programación básica Mecanismos de abstracción Diseño y programación

La primera parte está pensada para que en poco tiempo pueda convertirse en programador de aplicaciones C++. Y para esto, ¿qué necesita? Pues simplemente leer ordenadamente los capítulos del libro, resolviendo cada uno de los ejemplos que en ellos se detallan. La segunda parte abarca en profundidad la programación orientada a objetos. En la primera parte el autor ha tratado de desarrollar aplicaciones sencillas, para introducirle más bien en el lenguaje y en el manejo de la biblioteca de clases de C++, que en el diseño de clases de objetos. No obstante, después de su estudio sí debe haber quedado claro que un programa orientado a objetos sólo se compone de objetos. Es hora pues de entrar con detalle en la programación orientada a objetos, segunda parte, la cual tiene un elemento básico: la clase. Pero si el autor finalizara el libro con las dos partes anteriores, privaría al lector de saber que C++ aún proporciona mucho más. Por eso la tercera parte continúa con otros capítulos dedicados a la implementación de estructuras dinámicas, al diseño de algoritmos y a la programación con hilos. Todo ello se ha documentado con abundantes problemas resueltos. Cuando complete todas las partes, todavía no sabrá todo lo que es posible hacer con C++, pero sí habrá dado un paso importante. Esta obra fue escrita utilizando un compilador GCC para Win32 (un compilador C++ de la colección de compiladores GNU) que se adjunta en el CD-ROM que acompaña al libro. Se trata de un compilador de libre distribución que cumple la norma ISO/IEC, del cual existen versiones para prácticamente todos los sistemas operativos. 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 breve serán la totalidad de las existentes. Por ejemplo, el autor probó la casi totalidad de los desarrollos bajo el paquete Microsoft Visual Studio .NET, y también sobre la plataforma Linux, para conseguir un código lo más portable posible.

;;,9(1&,&/23(',$'(//(1*8$-(&

6REUHORVHMHPSORVGHOOLEUR /DLPDJHQGHO&'GHHVWHOLEURFRQODVDSOLFDFLRQHVGHVDUUROODGDV\HOVRIWZDUH SDUDUHSURGXFLUODVSXHGHGHVFDUJDUODGHVGH KWWSVZZZWHFQROLEURHVILFKHURVGHVFDUJDV]LS /DGHVFDUJDFRQVLVWHHQXQILFKHUR=,3FRQXQDFRQWUDVHxDddd-dd-dddd-ddd-d TXHVHFRUUHVSRQGHFRQHO,6%1GHHVWHOLEURWHFOHHORVGtJLWRV\ORVJXLRQHV 

$JUDGHFLPLHQWRV (QODSUHSDUDFLyQGHHVWHOLEURTXLHURHQHVSHFLDOH[SUHVDUPLDJUDGHFLPLHQWRD 0DQXHO3HLQDGR*DOOHJRSURIHVRUGHOD8QLYHUVLGDGGH$OFDOiFRQXQDDPSOLD H[SHULHQFLD HQ GHVDUUROORV FRQ & SRUTXH UHYLVy OD SULPHUDHGLFLyQGHHVWHOL EUR\DÏVFDU*DUFtD3REODFLyQ(OHQD&DPSR0RQWDOYR6HEDVWLiQ6iQFKH] 3ULHWR,QPDFXODGD5RGUtJXH]6DQWLDJR\0'RORUHV5RGUtJXH]0RUHQRTXH EDViQGRVH HQ VX H[SHULHQFLD GRFHQWH PH KLFLHURQ GLYHUVDV VXJHUHQFLDV VREUH ORV WHPDVWUDWDGRV7RGRVHOORVVRQSURIHVRUHVGH8QLYHUVLGDGFRQXQDDPSOLDH[SH ULHQFLDVREUHODPDWHULDTXHWUDWDHOOLEUR )LQDOPHQWH QR TXLHUR ROYLGDUPH GHO UHVWR GH PLV FRPSDxHURV DXQTXH QR FLWH VXV QRPEUHV SRUTXH WRGRV HOORV GH IRUPD GLUHFWD R LQGLUHFWD PH D\XGDURQ FRQODFUtWLFDFRQVWUXFWLYDTXHKLFLHURQVREUHRWUDVSXEOLFDFLRQHVDQWHULRUHVDpVWD \WDPSRFRGHPLVDOXPQRVTXHFRQVXLQWHUpVSRUDSUHQGHUPHKDFHQUHIOH[LRQDU VREUHODIRUPDPiVDGHFXDGDGHWUDQVPLWLUHVWRVFRQRFLPLHQWRVDWRGRVHOORVOHV HVWR\IUDQFDPHQWHDJUDGHFLGR )UDQFLVFR-DYLHU&HEDOORV6LHUUD http://www.fjceballos.es/





PARTE

________________________ _________________________________ __________________________________________

Programación básica x

Introducción a C++

x

Elementos del lenguaje

x

Estructura de un programa

x

Entrada y salida estándar

x

Sentencias de control

x

Tipos estructurados de datos

x

Punteros, referencias y gestión de la memoria

x

Más sobre funciones

CAPÍTULO 1 ¤ F.J.Ceballos/RA-MA

INTRODUCCIÓN A C++ Un programa no es nada más que una serie de instrucciones dadas al ordenador en un lenguaje entendido por él, para decirle exactamente lo que queremos que haga. Si el ordenador no entiende alguna instrucción, lo comunicará generalmente mediante mensajes visualizados en la pantalla. Un programa tiene que escribirse en un lenguaje entendible por el ordenador. Desde el punto de vista físico, un ordenador es una máquina electrónica. Los elementos físicos (memoria, unidad central de proceso, etc.) de que dispone el ordenador para representar las instrucciones y los datos son de tipo binario; esto es, cada elemento puede diferenciar dos estados (dos niveles de voltaje). Cada estado se denomina genéricamente bit y se simboliza por 0 ó 1. Por lo tanto, para representar y manipular información numérica, alfabética y alfanumérica se emplean cadenas de bits. Según esto, se denomina byte a la cantidad de información empleada por un ordenador para representar un carácter; generalmente un byte es una cadena de ocho bits. Esto hace pensar que escribir un programa utilizando ceros y unos (lenguaje máquina) llevaría mucho tiempo y con muchas posibilidades de cometer errores. Por este motivo, se desarrollaron los lenguajes de programación. Para traducir un programa escrito en un determinado lenguaje de programación a lenguaje máquina (código binario), se utiliza un programa llamado compilador que ejecutamos mediante el propio ordenador. Este programa tomará como datos nuestro programa escrito en un lenguaje de alto nivel, por ejemplo en C++, y dará como resultado el mismo programa pero escrito en lenguaje máquina, lenguaje que entiende el ordenador. Programa escrito en un lenguaje de alto nivel

Compilador

Programa escrito en lenguaje máquina

4

ENCICLOPEDIA DEL LENGUAJE C++

¿POR QUÉ APRENDER C++? Una de las ventajas de C++ es su independencia de la plataforma en lo que a código fuente se refiere. Otra característica importante de C++ es que es un lenguaje que soporta diversos estilos de programación (por ejemplo, la programación genérica y la programación orientada a objetos –POO– de la cual empezaremos a hablar en este mismo capítulo). Todos los estilos se basan en una verificación fuerte de tipos y permiten alcanzar un alto nivel de abstracción. C++ está organizado de tal forma que el aprendizaje del mismo puede hacerse gradualmente obteniendo beneficios prácticos a largo de este camino. Esto es importante, porque podemos ir produciendo proporcionalmente a lo aprendido. C++ está fundamentado en C lo que garantiza que los millones de líneas de código C existentes puedan beneficiarse de C++ sin necesidad de reescribirlas. Evidentemente, no es necesario aprender C para aprender C++, lo comprobará con este libro. No obstante, si conoce C, podrá comprobar que C++ es más seguro, más expresivo y reduce la necesidad de tener que centrarse en ideas de bajo nivel. C++ se utiliza ampliamente en docencia e investigación porque es claro, realista y eficiente. También es lo suficientemente flexible como para realizar los proyectos más exigentes. Y también es lo suficientemente comercial como para ser incorporado en el desarrollo empresarial. Existen varias implementaciones de C++, de distribución gratuita; por ejemplo, GCC. Las siglas GCC significan GNU Compiler Collection (colección de compiladores GNU; antes significaban GNU C Compiler: compilador C GNU). Como su nombre indica es una colección de compiladores y admite diversos lenguajes: C, C++, Objetive C, Fortran, Java, etc. Existen versiones para prácticamente todos los sistemas operativos y pueden conseguirse en gcc.gnu.org. GNU (se trata de un acrónimo recursivo para “Gnu No es Unix”) es un proyecto que comenzó en 1984 para desarrollar un sistema operativo tipo Unix que fuera libre; lo que hoy en día conocemos como Linux es un sistema operativo GNU, aunque sería más preciso llamarlo GNU/Linux. Pues bien, dentro de este proyecto se desarrolló GCC, cuyo compilador C++ se ajusta al estándar ISO/IEC. La mayor parte del software libre está protegido por la licencia pública GNU denominada GPL (GNU Public License).

CAPÍTULO 1: INTRODUCCIÓN A C++

5

REALIZACIÓN DE UN PROGRAMA EN C++ En este apartado se van a exponer los pasos a seguir en la realización de un programa, por medio de un ejemplo. La siguiente figura muestra de forma esquemática lo que un usuario de C++ necesita y debe hacer para desarrollar un programa. Entorno de desarrollo de C++ 1. Editar el programa 2. Compilarlo 3. Ejecutarlo 4. Depurarlo

Evidentemente, para poder escribir programas se necesita un entorno de desarrollo C++. En Internet puede encontrar varios con licencia pública GNU que se distribuyen gratuitamente. Por ejemplo, el compilador C++ de GCC se puede obtener en la dirección de Internet: http://gcc.gnu.org

Así mismo, el CD-ROM que acompaña al libro incluye MinGW, una versión nativa de Win32 de GCC (para Windows 2000/XP/Vista). Linux también incluye una implementación GCC. Para instalar la implementación MinGW de GCC incluida en el CD en una plataforma Windows, descargue el fichero MinGW-x.x.x.exe, o bien utilice la versión suministrada en el CD del libro y ejecútelo. Después, siga los pasos especificados por el programa de instalación. Puede ver más detalles sobre la instalación en los apéndices del libro. Una vez finalizada la instalación, suponiendo que la realizó en la carpeta C++, se puede observar el siguiente contenido:

6

ENCICLOPEDIA DEL LENGUAJE C++

x

La carpeta bin contiene las herramientas de desarrollo. Esto es, los programas para compilar (gcc permite compilar un programa C, g++ permite compilar un programa C++, etc.), depurar (gdb), y otras utilidades.

x

La carpeta include contiene los ficheros de cabecera de C.

x

La carpeta doc contiene información de ayuda acerca de la implementación MinGW.

x

La carpeta lib contiene bibliotecas de clases, de funciones y ficheros de soporte requeridos por las herramientas de desarrollo.

x

La carpeta mingw32 contiene otras carpetas bin y lib con otros ficheros adicionales.

Sólo falta un editor de código fuente C++. Es suficiente con un editor de texto sin formato. No obstante, todo el trabajo de edición, compilación, ejecución y depuración se hará mucho más fácil si se utiliza un entorno de desarrollo con interfaz gráfica de usuario que integre las herramientas mencionadas, en lugar de tener que utilizar la interfaz de línea de órdenes del entorno de desarrollo C++ instalado, como veremos a continuación. Entornos de desarrollo integrados para C++ hay varios: Microsoft Visual Studio, CodeBlocks, Eclipse, NetBeans, etc. Concretamente en el CD se proporciona CodeBlocks: un entorno integrado, con licencia pública GNU, y que se ajusta a las necesidades de las aplicaciones que serán expuestas en este libro. Para más detalle véase en los apéndices Instalación del paquete de desarrollo.

Cómo crear un programa Empecemos con la creación de un programa sencillo: el clásico ejemplo de mostrar un mensaje de saludo. Este sencillo programa lo realizaremos utilizando el entorno de desarrollo integrado CodeBlocks. No obstante, una vez editado el fichero fuente C++, podría también compilarlo y ejecutarlo desde la línea de órdenes, aspecto que puede ver con detalle en el apéndice Entornos de desarrollo del libro. Empecemos por editar el fichero fuente C++ correspondiente al programa. Primeramente pondremos en marcha el EDI, en nuestro caso CodeBlocks. Después, creamos un nuevo proyecto, por ejemplo HolaMundo, con un fichero main.cpp (el nombre del fichero puede ser cualquiera, pero la extensión debe ser

CAPÍTULO 1: INTRODUCCIÓN A C++

7

.cpp) y lo editamos como muestra la figura siguiente (para más detalles, véase el apéndice Entornos de desarrollo del libro):

¿Qué hace este programa? Comentamos brevemente cada línea de este programa. No apurarse si algunos de los términos no quedan muy claros ya que todos ellos se verán con detalle en capítulos posteriores. La primera línea incluye el fichero de cabecera iostream que contiene las declaraciones necesarias para que se puedan ejecutar las sentencias de entrada o salida (E/S) que aparecen en el programa; en nuestro caso para cout. Esto significa que, como regla general, antes de invocar a algún elemento de la biblioteca de C++ este tiene que estar declarado. Las palabras reservadas de C++ que empiezan con el símbolo # reciben el nombre de directrices del compilador y son procesadas por el preprocesador de C++ cuando se invoca al compilador, pero antes de iniciarse la compilación. Las siguientes líneas encerradas entre /* y */ son simplemente un comentario. Los comentarios no son tenidos en cuenta por el compilador, pero ayudan a entender un programa cuando se lee. A continuación se escribe la función principal main. Todo programa escrito en C++ tiene una función main. Observe que una función se distingue por el modificador () que aparece después de su nombre y que el cuerpo de la misma empieza con el carácter { y finaliza con el carácter }. Las llaves, {}, delimitan el bloque de código que define las acciones que tiene que ejecutar dicha función.

8

ENCICLOPEDIA DEL LENGUAJE C++

Cuando se ejecuta un programa, C++ espera que haya una función main. Esta función define el punto de entrada y de salida normal del programa. El objeto std::cout de la biblioteca C++ escribe en la salida estándar (la pantalla) las expresiones que aparecen a continuación de los operadores > r; "; cin >> t;

Conocidos los datos, realizamos los cálculos. Nos piden los intereses producidos y el capital acumulado. Los intereses producidos los obtenemos aplicando directamente la fórmula. El capital acumulado es el capital inicial más los intereses producidos. intereses = c * r * t / (360 * 100); capital = c + intereses;

x

Finalmente, escribimos el resultado. cout