Pensar en C
Pensar en C
Pensar en C
i i
Bruce Eckel
12 de enero de 2012
Puede encontrar la versin actualizada de este libro e informacin adicional sobre el proyecto de traduccin en http://arco.esi.uclm.es/~david.villa/pensarC++.html
i i i
i i
II
i i i
i i
ndice general
1. Introduccin 1.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2. Captulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3.1. Soluciones de los ejercicios . . . . . . . . . . . . . . . . . . . . . 1.4. Cdigo fuente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5. Compiladores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6. Estndares del lenguaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7. Seminarios, CD-ROMs y consultora . . . . . . . . . . . . . . . . . . . . 1.8. Errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.9. Sobre la portada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.10. Agradecimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 2 3 4 4 4 5 5 6 6 6
9
13
2. Tratamiento de excepciones
2.1. Tratamiento tradicional de errores . . . . . . . . . . . . . . . . . . . . . 13 2.2. Lanzar una excepcin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.3. Capturar una excepcin . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.3.1. El bloque try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.3.2. Manejadores de excepcin . . . . . . . . . . . . . . . . . . . . . . 16 2.3.3. 2.4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.4.1. Capturar cualquier excepcin . . . . . . . . . . . . . . . . . . . . 17 2.4.2. Relanzar una excepcin . . . . . . . . . . . . . . . . . . . . . . . 18 2.4.3. Excepciones no capturadas . . . . . . . . . . . . . . . . . . . . . 18 2.5. Limpieza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.5.1. Gestin de recursos . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.5.2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
III
i i i
i i
ndice general 2.5.3. auto_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.5.4. Bloques try a nivel de funcin . . . . . . . . . . . . . . . . . . . 22 2.6. Excepciones estndar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.7. Especicaciones de excepciones . . . . . . . . . . . . . . . . . . . . . . . 24 2.7.1. Mejores especicaciones de excepciones? . . . . . . . . . . . . 25 2.7.2. Especicacin de excepciones y herencia . . . . . . . . . . . . . 26 2.7.3. Cundo no usar especicaciones de excepcin . . . . . . . . . . 26 2.8. Seguridad de la excepcin . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.9. Programar con excepciones . . . . . . . . . . . . . . . . . . . . . . . . . 28 2.9.1. Cundo evitar las excepciones . . . . . . . . . . . . . . . . . . . 28 2.9.2. Usos tpicos de excepciones . . . . . . . . . . . . . . . . . . . . . 28 2.10. Sobrecarga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 2.11. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.12. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3. Programacin defensiva 3.2. Un framework de pruebas unitarias sencillo 3.2.1. 31 . . . . . . . . . . . . . . . 35
3.2.2. El Framework TestSuite . . . . . . . . . . . . . . . . . . . . . . . 39 3.2.3. Suites de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 3.2.4. El cdigo del framework de prueba . . . . . . . . . . . . . . . . 43 3.3. Tcnicas de depuracin . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 3.3.1. Macros de seguimiento . . . . . . . . . . . . . . . . . . . . . . . 48 3.3.2. Fichero de rastro . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 3.3.3. Encontrar agujeros en memoria . . . . . . . . . . . . . . . . . . 50 3.4. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 3.5. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
II
57
61
4.1. Qu es un string? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 4.2. Operaciones con cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 4.2.1. Aadiendo, insertando y concatenando cadenas . . . . . . . . . 63 4.2.2. Reemplazar caracteres en cadenas . . . . . . . . . . . . . . . . . 65 4.2.3. Concatenacin usando operadores no-miembro sobrecargados 68 4.3. Buscar en cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
IV
i i i
i i
ndice general 4.3.1. Busqueda inversa . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 4.3.2. Encontrar el primero/ltimo de un conjunto de caracteres . . . 74 4.3.3. Borrar caracteres de cadenas . . . . . . . . . . . . . . . . . . . . 76 4.3.4. Comparar cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . 78 4.3.5. Cadenas y rasgos de caracteres . . . . . . . . . . . . . . . . . . . 82 4.4. Una aplicacin con cadenas . . . . . . . . . . . . . . . . . . . . . . . . . 86 4.5. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 4.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 5. Iostreams 95
5.1. Por que iostream? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 5.2. Iostreams al rescate . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.2.1. Insertadores y extractores . . . . . . . . . . . . . . . . . . . . . . 99 5.2.2. Uso comn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 5.2.3. Entrada orientada a lneas . . . . . . . . . . . . . . . . . . . . . . 104 5.2.3.1. 5.2.3.2. Versiones sobrecargadas de get() . . . . . . . . . . . 105 Leyendo bytes sin formato . . . . . . . . . . . . . . . 105
5.3. Manejo errores de stream . . . . . . . . . . . . . . . . . . . . . . . . . . 105 5.3.1. Estados del stream . . . . . . . . . . . . . . . . . . . . . . . . . 105 5.3.2. Streams y excepciones . . . . . . . . . . . . . . . . . . . . . . . . 107 5.4. Iostreams de chero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 5.4.1. Un ejemplo de procesado de chero. . . . . . . . . . . . . . . . . 108 5.4.2. Modos de apertura . . . . . . . . . . . . . . . . . . . . . . . . . . 109 5.5. Almacenamiento de iostream . . . . . . . . . . . . . . . . . . . . . . . 110 5.6. Buscar en iostreams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 5.7. Iostreams de string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 5.7.1. Streams de cadena de entrada . . . . . . . . . . . . . . . . . . . . 115 5.7.2. Streams de cadena de salida . . . . . . . . . . . . . . . . . . . . . 117 5.8. Formateo de stream de salida . . . . . . . . . . . . . . . . . . . . . . . . 119 5.8.1. Banderas de formateo . . . . . . . . . . . . . . . . . . . . . . . . 120 5.8.2. Campos de formateo . . . . . . . . . . . . . . . . . . . . . . . . . 121 5.8.3. Anchura, relleno y precisin . . . . . . . . . . . . . . . . . . . . 122 5.8.4. Un ejemplo exhaustivo . . . . . . . . . . . . . . . . . . . . . . . . 123 5.9. Manipuladores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 5.9.1. Manipuladores con argumentos . . . . . . . . . . . . . . . . . . 127 5.9.2. 5.9.3. 5.10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
V
i i i
i i
ndice general 5.10.1. 5.10.2. 5.10.3. 5.11. 5.11.1. 5.11.2. 5.12. 5.13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 6.1.4.1. 6.1.4.2. 6.1.5. 6.1.6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
6.2.
6.3.
6.4.
6.5.
6.6.
VI
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
i i i
i i
ndice general 6.6.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 6.6.1.1. 6.6.1.2. 6.6.1.3. 6.6.2. 6.7. 6.7.1. 6.7.2. 6.7.3. 6.7.4. 6.8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 187
7. Algoritmos genricos
7.1. Un primer vistazo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 7.1.1. Predicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 7.1.2. Iteradores de ujo . . . . . . . . . . . . . . . . . . . . . . . . . . 192 7.1.3. Complejidad algortmica . . . . . . . . . . . . . . . . . . . . . . 194 7.2. Objetos-funcin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 7.2.1. Clasicacin de objetos-funcin . . . . . . . . . . . . . . . . . . 195 7.2.2. Creacin automtica de objetos-funcin . . . . . . . . . . . . . . 195 7.2.3. Objetos-funcin adaptables . . . . . . . . . . . . . . . . . . . . . 196 7.2.4. Ms ejemplos de objetos-funcin . . . . . . . . . . . . . . . . . . 196 7.2.5. Adaptadores de puntero a funcin . . . . . . . . . . . . . . . . . 199 7.2.6. Escribir sus propios adaptadores de objeto-funcin . . . . . . . 202 7.3. Un catlogo de algoritmos STL . . . . . . . . . . . . . . . . . . . . . . . 205 7.3.1. Herramientas de soporte para la creacin de ejemplos . . . . . . 205 7.3.1.1. 7.3.2.1. 7.3.3.1. 7.3.4.1. 7.3.5.1. 7.3.6.1. Reordenacin estable vs. inestable . . . . . . . . . . . . 205 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 7.3.2. Relleno y generacin . . . . . . . . . . . . . . . . . . . . . . . . . 206 7.3.3. Conteo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 7.3.4. Manipulacin de secuencias . . . . . . . . . . . . . . . . . . . . . 208 7.3.5. Bsqueda y reemplazo . . . . . . . . . . . . . . . . . . . . . . . . 209 7.3.6. Comparacin de rangos . . . . . . . . . . . . . . . . . . . . . . . 211 7.3.7. Eliminacin de elementos . . . . . . . . . . . . . . . . . . . . . . 212
VII
i i i
i i
ndice general 7.3.7.1. 7.3.8.1. 7.3.8.2. 7.3.8.3. 7.3.8.4. 7.3.8.5. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 Ordenacin . . . . . . . . . . . . . . . . . . . . . . . . . 213 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 Mezcla de rangos ordenados . . . . . . . . . . . . . . . 214 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
7.3.9. Operaciones sobre el montculo . . . . . . . . . . . . . . . . . . . 215 7.3.10. Aplicando una operacin a cada elemento de un rango . . . . . 215 7.3.10.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . 215 7.3.11. Algoritmos numricos . . . . . . . . . . . . . . . . . . . . . . . . 219 7.3.11.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 7.3.12. Utilidades generales . . . . . . . . . . . . . . . . . . . . . . . . . 220 7.4. Creando sus propios algoritmos tipo STL . . . . . . . . . . . . . . . . . 220 7.5. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 7.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
III
Temas especiales
223
227
8. Herencia mltiple
8.1. Perspectiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 8.2. Herencia de interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 8.3. Herencia de implementacin . . . . . . . . . . . . . . . . . . . . . . . . 231 8.4. Subobjetos duplicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 8.5. Clases base virtuales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 8.6. Cuestin sobre bsqueda de nombres . . . . . . . . . . . . . . . . . . . 240 8.7. Evitar la MI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 8.8. Extender una interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 8.9. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 8.10. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 9. Patrones de Diseo 247
9.1. El Concepto de Patrn . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 9.1.1. La composicin es preferible a la herencia . . . . . . . . . . . . . 248 9.2. Clasicacin de los patrones . . . . . . . . . . . . . . . . . . . . . . . . . 248 9.2.1. Caractersticas, modismos patrones . . . . . . . . . . . . . . . . 249 9.3. Simplicacin de modismos . . . . . . . . . . . . . . . . . . . . . . . . 249 9.3.1.
VIII
Mensajero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
i i i
i i
ndice general 9.3.2. Parmetro de Recoleccin . . . . . . . . . . . . . . . . . . . . . . 251 9.4. Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 9.4.1. Variantes del Singleton . . . . . . . . . . . . . . . . . . . . . . . 253 9.5. Comando: elegir la operacin . . . . . . . . . . . . . . . . . . . . . . . . 256 9.5.1. Desacoplar la gestin de eventos con Comando . . . . . . . . . 258 9.6. Desacoplamiento de objetos . . . . . . . . . . . . . . . . . . . . . . . . . 261 9.6.1. Proxy: FIXME: hablando en nombre de otro objeto . . . . . . . . 261 9.6.2. Estado: cambiar el comportamiento del objeto . . . . . . . . . . 262 9.7. Adaptador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 9.8. Template Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 9.9. Estrategia: elegir el algoritno en tiempo de ejecucin . . . . . . . . . . . 267 9.10. Cadena de Responsabilidad: intentar una secuencia de estrategias . . . 268 9.11. Factoras: encapsular la creacin de objetos . . . . . . . . . . . . . . . . 270 9.11.1. Factoras polimrcas . . . . . . . . . . . . . . . . . . . . . . . . 272 9.11.2. Factoras abstractas . . . . . . . . . . . . . . . . . . . . . . . . . . 275 9.11.3. Constructores virtuales . . . . . . . . . . . . . . . . . . . . . . . 277 9.12. Builder: creacin de objetos complejos . . . . . . . . . . . . . . . . . . . 279 9.13. Observador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 9.13.1. El ejemplo de observador . . . . . . . . . . . . . . . . . . . . . . 286 9.14. Despachado mltiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 9.14.1. Despachado mltiple con Visitor . . . . . . . . . . . . . . . . . . 291 9.15. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 9.16. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 10. Concurrencia 295
10.1. Motivacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 10.2. Concurrencia en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 10.2.1. Instalacin de ZThreads . . . . . . . . . . . . . . . . . . . . . . . 297 10.2.2. Denicin de tareas . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.3. Utilizacin de los hilos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 10.3.1. Creacin de interfaces de usuarios interactivas . . . . . . . . . . 301 10.3.2. Simplicacin con Ejecutores . . . . . . . . . . . . . . . . . . . . 303 10.3.3. Ceder el paso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306 10.3.4. Dormido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 10.3.5. Prioridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 10.4. Comparicin de recursos limitados . . . . . . . . . . . . . . . . . . . . . 310 10.4.1. Aseguramiento de la existencia de objetos . . . . . . . . . . . . 310 10.4.2. Acceso no apropiado a recursos . . . . . . . . . . . . . . . . . . 313
IX
i i i
i i
ndice general 10.4.3. Control de acceso . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 10.4.4. Cdigo simplicado mediante guardas . . . . . . . . . . . . . . 317 10.4.5. Almacenamiento local al hilo . . . . . . . . . . . . . . . . . . . . 320 10.5. Finalizacin de tareas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 10.5.1. Prevencin de coliciones en iostream . . . . . . . . . . . . . . . 322 10.5.2. El jardn ornamental . . . . . . . . . . . . . . . . . . . . . . . . . 323 10.5.2.1. Operaciones atmicas . . . . . . . . . . . . . . . . . . . 326 10.5.3. FIXME:Teminacin al bloquear . . . . . . . . . . . . . . . . . . . 326 10.5.4. Interrupcin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 10.6. Cooperacin entre hilos . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 10.6.1. Wait y signal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 10.6.2. Relacin de productor/consumidor . . . . . . . . . . . . . . . . 332 10.6.3. Resolucin de problemas de hilos mediante colas . . . . . . . . 335 10.6.4. Broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 10.7. Bloqueo letal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 10.8. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346 10.9. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
i i i
i i
ndice de guras
8. Herencia mltiple 8.1. 8.2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
XI
i i i
i i
i i i
i i
1: Introduccin
En el volumen 1 de este libro, aprendi los fundamentos de C y C++. En este volumen, veremos caractersticas ms avanzadas, con miras hacia tcnicas e ideas para realizar programas robustos en C++. Asumimos que est familiarizado con el material presentado en el Volumen 1.
1.1. Objetivos
Nuestros objetivos en este libros son: 1. Presentar el material como un sencillo paso cada vez, de este modo el lector puede asimilar cada concepto antes de seguir adelante. 2. Ensear tcnicas de "programacin prctica" que puede usar en la base del da a da. 3. Darle lo que pensamos que es importante para que entienda el lenguaje, ms bien que todo lo que sabemos. Creemos que hay una "jerarqua de importancia de la informacin", y hay algunos hechos que el 95 % de los programadores nunca necesitarn conocer, sino que slo confundira a la gente y aade complejidad a su percepcin del lenguaje. Tomando un ejemplo de C, si memoriza la tabla de prioridad de operadores (nosotros nunca lo hicimos) puede escribir cdigo ingenioso. Pero si debe pensarlo, confundir al lector/mantenedor de ese cdigo. De modo que olvide las precedencias y use parntesis cuando las cosas no estn claras. 4. Mantngase sucientemente centrado en cada seccin de modo que el tiempo de lectura -y el tiempo entre ejercicios- sea pequeo. Esto no slo hace mantener las mentes de los lectores ms activas e involucradas durante un seminario prctico sino que da al lector un mayor sentido de xito. Hemos procurado no usar ninguna versin de un vendedor particular de C++. Hemos probado el cdigo sobre todas las implementaciones que pudimos (descriptas posteriormente en esta introduccin), y cuando una implementacin no funciona en absoluto porque no cumple el Estndar C++, lo hemos sealado en el ejemplo(ver las marcas en el cdigo fuente) para excluirlo del proceso de construccin. 6. Automatizar la compilacin y las pruebas del cdigo en el libro. Hemos descubierto que el cdigo que no est compilado y probado probablemente no funcione correctamente, de este modo en este volumen hemos provisto a los ejemplos con cdigo de pruebas. Adems, el cdigo que puede descargar desde http://www.MindView.net ha sido extrado directamente del texto del libro usando programas que automticamente crean makeles para compilar y ejecutar las pruebas. De esta forma sabemos que el cdigo en el libro es correcto.
1 i i i i
i i
Captulo 1. Introduccin
1.2. Captulos
Aqu est una breve descripcin de los captulos que contiene este libro: Parte 1: Construccin de sistemas estables 1. Manejar excepciones. Manejar errores ha sido siempre un problema en programacin. Incluso si obedientemente devuelve informacin del error o pone una bandera, la funcin que llama puede simplemente ignorarlo. Manejar excepciones es una cualidad primordial en C++ que soluciona este problema permitindole "lanzar" un objeto fuera de su funcin cuando ocurre un error crtico. Tire diferentes tipos de objetos para diferentes errores, y la funcin que llama "coge" estos objetos en rutinas separadas de gestin de errores. Si lanza una excepcin, no puede ser ignorada, de modo que puede garantizar que algo ocurrir en respuesta a su error. La decisin de usar excepciones afecta al diseo del cdigo positivamente, de modo fundamental. 2. Programacin defensiva. Muchos problemas de software pueden ser prevenidos. Programar de forma defensiva es realizar cuidadosamente cdigo de tal modo que los bugs son encontrados y arreglados pronto antes que puedan daar en el campo. Usar aserciones es la nica y ms importante forma para validar su cdigo durante el desarrollo, dejando al mismo tiempo seguimiento ejecutable de la documentacin en su cdigo que muestra sus pensamientos mientras escribe el cdigo en primer lugar. Pruebe rigurosamente su cdigo antes de darlo a otros. Un marco de trabajo de pruebas unitario automatizado es una herramienta indispensable para el xito, en el desarrollo diario de software. Parte 2: La biblioteca estndar de C++ 3. Cadenas en profundidad. La actividad ms comn de programacin es el procesamiento de texto. La clase string de C++ libera al programador de los temas de gestin de memoria, mientras al mismo tiempo proporciona una fuente de recursos para el procesamiento de texto. C++ tambin facilita el uso de una gran variedad de caracteres y locales para las aplicaciones de internacionalizacin. 4. Iostreams. Una de las bibliotecas original de C++-la que proporciona la facilidad bsica de I/O-es llamada iostreams. Iostreams est destinado a reemplazar stdio.h de C con una biblioteca I/O que es ms fcil de usar, ms exible, y extensibleque puede adaptarla para trabajar con sus nuevas clases. Este captulo le ensea cmo hacer el mejor uso de la biblioteca actual I/O, chero I/O, y formateo en memoria. 5. Plantillas en profundidad. La distintiva cualidad del "C++ moderno" es el extenso poder de las plantillas. Las plantillas hacen algo ms que slo crear contenedores genricos. Sostienen el desarrollo de bibliotecas robustas, genricas y de alto rendimiento.Hay mucho por saber sobre plantillas-constituyen, como fue, un sublenguaje dentro del lenguaje C++, y da al programador un grado impresionante de control sobre el proceso de compilacin. No es una exageracin decir que las plantillas han revolucionado la programacin de C++. 6. Algoritmos genricos. Los algoritmos son el corazn de la informtica, y C++, por medio de la facilidad de las plantillas, facilita un impresionante entorno de poder, eciencia, y facilidad de uso de algoritmos genricos. Los algoritmos estndar son tambin personalizables a travs de objetos de funcin. Este captulo examina cada algoritmo de la biblioteca. (Captulos 6 y 7 abarcan esa parte de la biblioteca Estndar de C++ comnmente conocida como Biblioteca de Plantilla Estndar, o STL.) 7. Contenedores genricos e Iteradores. C++ proporciona todas las estructuras comunes de datos de modo de tipado fuerte. Nunca necesita preocuparse sobre qu tiene tal contenedor. La homogenidad de sus objetos est garantizada. Separar la 2 i i i i
i i 1.3. Ejercicios #FIXME traversing de un contenedor del propio contenedor, otra realizacin de plantillas, se hace posible por medio de los iteradores. Este ingenioso arreglo permite una aplicacin exible de algoritmos a contenedores usando el ms sencillo de los diseos. Parte 3: Temas especiales 8. Identicacin de tipo en tiempo de ejecucin. La identicacin de tipo en tiempo de ejecucin (RTTI) encuentra el tipo exacto de un objeto cuando slo tiene un puntero o referencia al tipo base. Normalmente, tendr que ignorar a propsito el tipo exacto de un objeto y permitir al mecanismo de funcin virtual implementar el comportamiento correcto para ese tipo. Pero ocasionalmente (como las herramientas de escritura de software tales como los depuradores) es til para conocer el tipo exacto de un objeto-con su informacin, puede realizar con frecuencia una operacin en casos especiales de forma ms eciente. Este captulo explica para qu es RTTT y como usarlo. 9. Herencia mltiple. Parece sencillo al principio: Una nueva clase hereda de ms de una clase existente. Sin embargo, puede terminar con copias ambiguas y mltiples de objetos de la clase base. Ese problema est resuelto con clases bases virtuales, pero la mayor cuestin continua: Cundo usarla? La herencia mltiple es slo imprescindible cuando necesite manipular un objeto por medio de ms de un clase base comn. Este captulo explica la sintaxis para la herencia mltiple y muestra enfoques alternativos- en particular, como las plantillas solucionan un problema tpico. Usar herencia mltiple para reparar un interfaz de clase "daada" demuestra un uso valioso de esta cualidad. 10. Patrones de diseo. El ms revolucionario avance en programacin desde los objetos es la introduccin de los patrones de diseo. Un patrn de diseo es una codicacin independiente del lenguaje de una solucin a un problema de programacin comn, expresado de tal modo que puede aplicarse a muchos contextos. Los patrones tales como Singleton, Factory Method, y Visitor ahora tienen lugar en discusiones diarias alrededor del teclado. Este captulo muestra como implementar y usar algunos de los patrones de diseo ms usados en C++. 11. Programacin concurrente. La gente ha llegado a esperar interfaces de usuario sensibles que (parece que) procesan mltiples tareas simultneamente. Los sistemas operativos modernos permiten a los procesos tener mltiples hilos que comparten el espacio de direccin del proceso. La programacin multihilo requiere una perspectiva diferente, sin embargo, y viene con su propio conjunto de dicultades. Este captulo utiliza un biblioteca disponible gratuitamente (la biblioteca ZThread por Eric Crahen de IBM) para mostrar como gestionar ecazmente aplicaciones multihilo en C++.
1.3. Ejercicios
Hemos descubierto que los ejercicios sencillos son excepcionalmente tiles durante un seminario para completar la comprensin de un estudiante. Encontrar una coleccin al nal de cada captulo. Estos son bastante sencillos, de modo que puedan ser acabados en una suma de tiempo razonable en una situacin de clase mientras el profesor observa, asegurndose que todos los estudiantes estn absorbiendo el material. Algunos ejercicios son un poco ms exigentes para mantener entretenidos a los estudiantes avanzados. Estn todos diseados para ser resueltos en un tiempo corto y slo estn all para probar y renar su conocimiento ms bien que presentar retos mayores (presumible3 i i i i
i i
1.5. Compiladores
Su compilador podra no soportar todas las cualidades discutidas en este libro, especialmente si no tiene la versin ms nueva de su compilador. Implementar un lenguaje como C++ es un tarea Herclea, y puede suponer que las cualidades aparecen por partes en lugar de todas juntas. Pero si intenta uno de los ejemplos del libro y obtiene muchos errores del compilador, no es necesariamente un error en el cdigo o en el compilador-puede que sencillamente no est implementado todava en su compilador concreto. Empleamos un nmero de compiladores para probar el cdigo de este libro, en un intento para asegurar que nuestro cdigo cumple el Estndar C++ y funcionar con todos los compiladores posibles. Desafortunadamente, no todos los compiladores cumplen el Estndar C++, y de este modo tenemos un modo de excluir ciertos cheros de la construccin con esos compiladores. Estas exclusiones se reejadas automticamente en los makeles creados para el paquete de cdigo para este libro que puede descargar desde www.MindView.net. Puede ver las etiquetas de exclusin incrustadas en los comentarios al inicio de cada listado, de este modo sabr si exigir a un compilador concreto que funcione con ese cdigo (en pocos casos, el compilador realmente compilar el cdigo pero el comportamiento de ejecucin es errneo, y excluimos esos tambin). Aqu estn las etiquetas y los compiladores que se excluyen de la construccin. {-dmc} El Compilador de Mars Digital de Walter Bright para Windows, descargable gratuitamente en www.DigitalMars.com. Este compilador es muy tolerante y as no ver casi ninguna de estas etiquetas en todo el libro. {-g++} La versin libre Gnu C++ 3.3.1, que viene preinstalada en la mayora de los paquetes Linux y Macintosh OSX. Tambin es parte de Cygwin para Windows (ver abajo). Est disponible para la mayora de las plataformas en gcc.gnu.org. {-msc} Microsoft Version 7 con Visual C++ .NET (viene slo con Visual Studio .NET; no descargable gratuitamente).
4 i i i i
i i
1.6. Estndares del lenguaje {-bor} Borland C++ Version 6 (no la versin gratuita; ste est ms actualizado). {-edg} Edison Design Group (EDG) C++. Este es el compilador de referencia para la conformidad con los estndares. Esta etiqueta existe a causa de los temas de biblioteca, y porque estbamos usando un copia gratis de la interfaz EDG con una implementacin de la biblioteca gratuita de Dinkumware, Ltd. No aparecieron errores de compilacin a causa slo del compilador. {-mwcc} Metrowerks Code Warrior para Macintosh OS X. Fjese que OS X viene con Gnu C++ preinstalado, tambin. Si descarga y desempaqueta el paquete de cdigo de este libro de www.MindView.net, encontrar los makeles para construir el cdigo para los compiladores de ms arriba. Usabamos GNU-make disponible gratuitamente, que viene con Linux, Cygwin (una consola gratis de Unix que corre encima de Windows; ver www.Cygwin.com), o puede instalar en su plataforma, ver www.gnu.org/software/make. (Otros makes pueden o no funcionar con estos cheros, pero no estn soportados.) Una vez que instale make, si teclea make en la lnea de comando obtendr instrucciones de cmo construir el cdigo del libro para los compiladores de ms arriba. Fjese que la colocacin de estas etiquetas en los cheros en este libro indica el estado de la versin concreta del compilador en el momento que lo probamos. Es posible y probable que el vendedor del compilador haya mejorado el compilador desde la publicacin de este libro. Es posible tambin que mientras que realizamos el libro con tantos compiladores, hayamos descongurado un compilador en concreto que en otro caso habra compilado el cdigo correctamente. Por consiguiente, debera probar el cdigo usted mismo con su compilador, y comprobar tambin el cdigo descargado de www.MindView.net para ver que es actual.
i i
1.8. Errores
No importa cuantos trucos usen los escritores para detectar errores, algunos siempre pasan desapercibidos y stos a menudo destacan para un nuevo lector. Si descubre algo que cree ser un error, por favor use el sistema de respuesta incorporado en la versin electrnica de este libro, que encontrar en http://www.MindView.net. Su ayuda se valora.
1.10. Agradecimientos
El volumen 2 de este libro se descuid a mitad de estar acabado durante mucho tiempo mientras Bruce se distraa con otras cosas, en particular con Java, Patrones de Diseo y especialmente con Python (ver www.Python.org). Si Chuck no hubiera estado dispuesto (tontamente, l reexiona algunas veces) a acabar la otra mitad y llevar las cosas al da, este libro casi seguramente no habra existido. No hay mucha gente a quien Bruce habra conado tranquilamente este libro. La acin de Chuck por la precisin, la correccin y la explicacin clara es lo que ha hecho que este libro sea tan bueno como es. Jamie King trabaj como persona de prcticas bajo la direccin de Chuck durante la nalizacin de este libro. El fue una parte esencial en asegurarse que el libro se nalizaba, no slo proporcionando contestacin a Chuck, sino especialmente por su interrogatorio implacable y siendo puntilloso con cada eleccin que l no comprenda por completo. Si sus preguntas son respondidas por este libro, es probablemente porque Jamie las pregunt primero. Jamie tambin mejor unos cuantos programas de ejemplo y cre muchos de los ejercicios al nal de cada captulo. Scott Baker, otro trabajador en prcticas de Chuck patrocinado por MindView, Inc., ayud con los ejercicios del captulo 3. Eric Crahen de IBM fue decisivo en la nalizacin del captulo 11 (Concurrencia). Cuando estbamos buscando un paquete de hilos, buscamos uno que fuese intuitivo y fcil de usar, mientras fuese sucientemente robusto para hacer el trabajo. Con Eric conseguimos esto y posteriormente- l estuvo sumamente cooperativo y ha usado nuestras contestaciones para mejorar su biblioteca, mientras nosotros tambin nos hemos beneciado de su conocimiento. Estamos agradecidos a Pete Becker por ser nuestro editor tcnico. Pocas personas son tan elocuentes y exigentes como Pete, ni mencionar como experto en C++ y desarrollo de software en general. Tambin dar gracias a Bjorn Karlsson por su corts y oportuna asistencia tcnica revisando el manuscrito entero con escaso aviso. Walter Bright hizo esfuerzos Hercleos para asegurarse que su compilador Digital Mars C++ compilara los ejemplos de este libro. Puso disponible el compilador 6 i i i i
i i
1.10. Agradecimientos mediante descarga gratuita en http://www.DigitalMars.com. Gracias, Walter! Las ideas y conocimientos de este libro provienen tambin de muchas otras fuentes: amigos como Andrea Provaglio, Dan Saks, Scott Meyers, Charles Petzold, y Michael Wilk; los pioneros del lenguaje como Bjarne Stroustrup, Andrew Koening, y Rob Murray; los miembros del Comit de Estndares de C++ como Nathan Myers (quien fue especialmente servicial y generoso con sus perspicacias), Herb Sutter, PJ Plauger, Kevlin Henney, David Abrahams, Tom Plum, Reg Charney, Tom Penello, Sam Druker, Uwe Steinmueller, John Spicer, Steve Adamczyk, y Daveed Vandevoorde; la gente que ha hablado en el apartado de C++ de la Conferencia de Desarrollo de Software (que Bruce cre y desarroll, y en la que habl Chuck); Compaeros de Chuck como Michael Seaver, Huston Franklin, David Wagstaff, y muchos estudiantes en seminarios, quienes realizaron las preguntas que necesitamos escuchar para hacer el material ms claro. El diseo del libro, la eleccin de la fuente, el diseo de la portada, y la foto de la portada ha sido realizada por el amigo de Bruce Daniel Will-Harris, clebre autor y desiador, que sola jugar con cartas temporales en el primer ciclo de secundaria mientras esperaba la invencin de los ordenadores y la publicacin asistida por ordenador. Sin embargo, presentamos las pginas listas para imprimir nosotros mismos, por lo tanto los errores de composicin tipogrca son nuestros. Se ha usado Microsoft Word XP para escribir el libro y crear la versin lista para imprimir. El cuerpo del texto est en Verdana y los ttulos est en Verdana. El tipo de letra del cdigo es Courier New. Deseamos tambin dar las gracias a los mltiples profesionales en el Edison Design Group y Dinkumware, Ltd., por darnos copias gratis de su compilador y biblioteca (respectivamente). Sin su experta asistencia, dada gentilmente, algunos de los ejemplos de este libro no podran haber sido probados- Tambin queremos agradecer a Howard Hinnant y a la gente de Metrowerks por la copia de su compilador, y a Sandy Smith y la gente de SlickEdit por facilitar a Chuck un entorno de edicin durante muchos aos. Greg Comeau tambin facilit un copia de su exitoso compilador basado en EDG, Comeau C++. Gracias especialmente a todos nuestros profesores, y a todos nuestros estudiantes (que son tambin nuestros profesores). Evan Cofsky ([email protected]) facilit todo tipo de asistencia en el servidor tambin con el desarrollo de programas en su ahora lenguaje favorito, Python. Sharlynn Cobaugh y Paula Steuer fueron ayudantes decisivos, evitando que Bruce fuese sumergido en una avalancha de proyectos. La pareja de Bruce Dawn McGee aport una inspiracin muy valiosa y un gran entusiasmo durante este proyecto. El elenco de amigos que han ayudado, pero no limitado a ellos: Mark Western, Gen Kiyooka, Kraig Brockschmidt, Zack Urlocker, Andrew Binstock, Neil Rubenking, Steve Sinofsky, JD Hildebrandt, Brian McElhinney, Brinkley Barr, Bill Gates en el Midnight Engineering Magazine, Larry Constantine y Lucy Lockwood, Tom Keffer, Greg Perry, Dan Putterman, Christi Westphal, Gene Wang, Dave Mayer, David Intersimone, Claire Sawyers, los italianos (Andrea Provaglio, Laura Fallai, Marco Cantu, Corrado, Ilsa and Christina Giustozzi), Chris y Laura Strand, The Almquists, Brad Jerbic, John Kruth y Marilyn Cvitanic, Holly Payne (s, el famoso novelista!), Mark Mabry, The Robbins Families, The Moelter Families (y the McMillans), The Wilks, Dave Stoner, Laurie Adams, The Cranstons, Larry Fogg, Mike y Karen Sequeira, Gary Entsminger y Allison Brody, Chester Andersen, Joe Lordi, Dave y Brenda Bartlett, The Rentschlers, The Sudeks, Lynn y Todd, y sus familias. Y por supuesto, mam y pap, Sandy, James y Natalie, Kim y Jared, Isaac, y Abbi. 7 i i i i
i i
i i i
i i
Parte I
9 i i i i
i i
i i i
i i
Los ingenieros de software gastan tanto tiempo en validar cdigo como el que tardan en crearlo. La calidad es, o debera ser, el objetivo de todo programador, y se puede recorrer un largo camino hacia ese objetivo eliminando problemas antes de que aparezcan. Adems, los sistemas software deberan ser lo sucientemente robustos como para comportarse razonablemente en presencia de problemas imprevistos.
Las excepciones se introdujeron en C++ para facilitar una gestin de errores sosticada sin trocear el cdigo con una innumerable cantidad de lgica de error. El Captulo 1 explica cmo el uso apropiado de las excepciones puede hacer software FIXME:well-behaved, y tambin introduce los principios de diseo que subyacen al cdigo seguro. En el Captulo 2 cubrimos las pruebas unitarias y las tcnicas de depuracin que prevn maximizar la calidad del cdigo antes de ser entregado. El uso de aserciones para expresar y reforzar las invariantes de un programa es una seal inequvoca de un ingeniero de software experimentado. Tambin introducimos un entorno simple para dar soporte a las pruebas unitarias.
11 i i i i
i i
i i i
i i
2: Tratamiento de excepciones
Mejorar la recuperacin de errores es una de las maneras ms potentes de incrementar la robustez de su cdigo. Una de las principales caractersticas de C++ es el tratamiento o manejo de excepciones, el cual es una manera mejor de pensar acerca de los errores y su tratamiento. Con el tratamiento de excepciones: 1. El cdigo de manejo de errores no resulta tan tedioso de escribir y no se entremezcla con su cdigo normal. Usted escribe el cdigo que desea que se ejecute, y ms tarde, en una seccin aparte, el cdigo que se encarga de los problemas. Si realiza varias llamadas a la misma funcin, el manejo de errores de esa funcin se har una sola vez, en un solo lugar. 2. Los errores no pueden ser ignorados. Si una funcin necesita enviar un mensaje de error al invocador de esa funcin, sta lanza un objeto que representa a ese error fuera de la funcin. Si el invocador no captura el error y lo trata, ste pasa al siguiente mbito abarcador, y as hasta que el error es capturado o el programa termina al no existir un manejador adecuado para ese tipo de excepcin.
i i
Captulo 2. Tratamiento de excepciones biblioteca que genere seales entienda e instale el mecanismo de manejo de seales adecuado. En proyectos grandes los nmeros de las seales de las diferentes bibliotecas puede llegar a entrar en conicto. Cuando se consideran los esquemas de tratamiento de errores para C++, hay un problema adicional que es crtico: Las tcnicas de C de seales y setjmp( )/longjmp( ) no llaman a los destructores, por lo que los objetos no se limpian adecuadamente. (De hecho, si longjmp( ) salta ms all del nal de un mbito donde los destructores deben ser llamados, el comportamiento del programa es indenido.) Esto hace casi imposible recuperarse efectivamente de una condicin excepcional, puesto que siempre se estn dejando objetos detrs sin limpiar y a los que ya no se tiene acceso. El siguiente ejemplo lo demuestra con setjmp/longjmp:
//: C01:Nonlocal.cpp // setjmp() & longjmp(). #include <iostream> #include <csetjmp> using namespace std; class Rainbow { public: Rainbow() { cout << "Rainbow()" << endl; } ~Rainbow() { cout << "~Rainbow()" << endl; } }; jmp_buf kansas; void oz() { Rainbow rb; for(int i = 0; i < 3; i++) cout << "theres no place like home" << endl; longjmp(kansas, 47); } int main() { if(setjmp(kansas) == 0) { cout << "tornado, witch, munchkins..." << endl; oz(); } else { cout << "Auntie Em! " << "I had the strangest dream..." << endl; } } ///:~
El problema con C++ es que longjmp( ) no respeta los objetos; en particular no llama a los destructores cuando salta fuera de un mbito.[1] Puesto que las llamadas a los destructores son esenciales, esta propuesta no es vlida para C++. De hecho, el estndar de C++ aclara que saltar a un mbito con goto (pasando por alto las llamadas a los constructores), o saltar fuera de un mbito con longjmp( ) donde un objeto en la pila posee un destructor, constituye un comportamiento indenido. 14 i i i i
i i
MyError es una clase normal, que en este caso acepta un char* como argumento del constructor. Usted puede usar cualquier tipo para lanzar (incluyendo los tipos predenidos), pero normalmente crear clases especial para lanzar excepciones. La palabra clave throw hace que suceda una serie de cosas relativamente mgicas. En primer lugar se crea una copia del objeto que se est lanzando y se devuelve desde la funcin que contiene la expresin throw, aun cuando ese tipo de objeto no es lo que normalmente la funcin est diseada para devolver. Un modo simplicado de pensar acerca del tratamiento de excepciones es como un mecanismo alternativo de retorno (aunque llegar a tener problemas si lleva esta analoga demasiado lejos). Tambin es posible salir de mbitos normales lanzando una excepcin. En cualquier caso se devuelve un valor y se sale de la funcin o mbito. Adems es posible lanzar tantos tipos de objetos diferentes como se quiera. Tpicamente, para cada categora de error se lanzar un tipo diferente. La idea es almacenar la informacin en el objeto y en el nombre de la clase con el n de quien est en el contexto invocador pueda averiguar lo que hacer con esa excepcin.
15 i i i i
i i
//: C01:Nonlocal2.cpp // Illustrates exceptions. #include <iostream> using namespace std; class Rainbow { public: Rainbow() { cout << "Rainbow()" << endl; } ~Rainbow() { cout << "~Rainbow()" << endl; } }; void oz() { Rainbow rb; for(int i = 0; i < 3; i++) cout << "theres no place like home" << endl; throw 47; } int main() { try { cout << "tornado, witch, munchkins..." << endl; oz(); } catch(int) { cout << "Auntie Em! I had the strangest dream..." << endl; } } ///:~
2.3.3.
2.4.
//: C01:Autoexcp.cpp // No matching conversions. #include <iostream> using namespace std;
16 i i i i
i i 2.4.
class Except1 {}; class Except2 { public: Except2(const Except1&) {} }; void f() { throw Except1(); } int main() { try { f(); } catch(Except2&) cout << "inside } catch(Except1&) cout << "inside } } ///:~
//: C01:Basexcpt.cpp // Exception hierarchies. #include <iostream> using namespace std; class X { public: class Trouble {}; class Small : public Trouble {}; class Big : public Trouble {}; void f() { throw Big(); } }; int main() { X x; try { x.f(); } catch(X::Trouble&) { cout << "caught Trouble" << endl; // Hidden by previous handler: } catch(X::Small&) { cout << "caught Small Trouble" << endl; } catch(X::Big&) { cout << "caught Big Trouble" << endl; } } ///:~
17 i i i i
i i
2.5. Limpieza
//: C01:Cleanup.cpp // Exceptions clean up complete objects only. #include <iostream> using namespace std; class Trace { static int counter;
18 i i i i
i i 2.5. Limpieza
int objid; public: Trace() { objid = counter++; cout << "constructing Trace #" << objid << endl; if(objid == 3) throw 3; } ~Trace() { cout << "destructing Trace #" << objid << endl; } }; int Trace::counter = 0; int main() { try { Trace n1; // Throws exception: Trace array[5]; Trace n2; // Wont get here. } catch(int i) { cout << "caught " << i << endl; } } ///:~
constructing Trace #0 constructing Trace #1 constructing Trace #2 constructing Trace #3 destructing Trace #2 destructing Trace #1 destructing Trace #0 caught 3
19 i i i i
i i
2.5.2.
//: C01:Wrapped.cpp // Safe, atomic pointers. #include <iostream> #include <cstddef> using namespace std; // Simplified. Yours may have other arguments. template<class T, int sz = 1> class PWrap { T* ptr; public: class RangeError {}; // Exception class PWrap() { ptr = new T[sz]; cout << "PWrap constructor" << endl; } ~PWrap() { delete[] ptr; cout << "PWrap destructor" << endl;
20 i i i i
i i 2.5. Limpieza
} T& operator[](int i) throw(RangeError) { if(i >= 0 && i < sz) return ptr[i]; throw RangeError(); } }; class Cat { public: Cat() { cout << "Cat()" << endl; } ~Cat() { cout << "~Cat()" << endl; } void g() {} }; class Dog { public: void* operator new[](size_t) { cout << "Allocating a Dog" << endl; throw 47; } void operator delete[](void* p) { cout << "Deallocating a Dog" << endl; ::operator delete[](p); } }; class UseResources { PWrap<Cat, 3> cats; PWrap<Dog> dog; public: UseResources() { cout << "UseResources()" << endl; } ~UseResources() { cout << "~UseResources()" << endl; } void f() { cats[1].g(); } }; int main() { try { UseResources ur; } catch(int) { cout << "inside handler" << endl; } catch(...) { cout << "inside catch(...)" << endl; } } ///:~
Cat() Cat() Cat() PWrap constructor allocating a Dog ~Cat() ~Cat() ~Cat() PWrap destructor inside handler
21 i i i i
i i
2.5.3. auto_ptr
//: C01:Auto_ptr.cpp // Illustrates the RAII nature of auto_ptr. #include <memory> #include <iostream> #include <cstddef> using namespace std; class TraceHeap { int i; public: static void* operator new(size_t siz) { void* p = ::operator new(siz); cout << "Allocating TraceHeap object on the heap " << "at address " << p << endl; return p; } static void operator delete(void* p) { cout << "Deleting TraceHeap object at address " << p << endl; ::operator delete(p); } TraceHeap(int i) : i(i) {} int getVal() const { return i; } }; int main() { auto_ptr<TraceHeap> pMyObject(new TraceHeap(5)); cout << pMyObject->getVal() << endl; // Prints 5 } ///:~
22 i i i i
i i
//: C01:FunctionTryBlock.cpp {-bor} // Function-level try blocks. // {RunByHand} (Dont run automatically by the makefile) #include <iostream> using namespace std; int main() try { throw "main"; } catch(const char* msg) { cout << msg << endl; return 1; } ///:~
23 i i i i
i i
void f();
//: C01:Unexpected.cpp // Exception specifications & unexpected(), //{-msc} (Doesnt terminate properly) #include <exception> #include <iostream> using namespace std; class Up {}; class Fit {}; void g(); void f(int i) throw(Up, Fit) { switch(i) { case 1: throw Up(); case 2: throw Fit(); } g(); } // void g() {} // Version 1 void g() { throw 47; } // Version 2 void my_unexpected() { cout << "unexpected exception thrown" << endl; exit(0); } int main() { set_unexpected(my_unexpected); // (Ignores return value) for(int i = 1; i <=3; i++) try { f(i); } catch(Up) { cout << "Up caught" << endl; } catch(Fit) { cout << "Fit caught" << endl; } } ///:~
//: C01:BadException.cpp {-bor} #include <exception> // For std::bad_exception #include <iostream> #include <cstdio>
24 i i i i
i i
25 i i i i
i i
template<class T> T stack<T>::pop() { if(count == 0) throw logic_error("stack underflow"); else return data[--count]; }
//: C01:SafeAssign.cpp // An Exception-safe operator=. #include <iostream> #include <new> // For std::bad_alloc
26 i i i i
i i
27 i i i i
i i
2.10. Sobrecarga
//: C01:HasDestructor.cpp {O} class HasDestructor { public: ~HasDestructor() {} }; void g(); // For all we know, g may throw. void f() { HasDestructor h; g(); } ///:~
28 i i i i
i i 2.11. Resumen
29 i i i i
i i
i i i
i i
3: Programacin defensiva
Escribir software puede ser un objetivo difcil para desarrolladores, pero unas pocas tcnicas defensivas, aplicadas rutinariamente, pueden dirigir a un largo camino hacia la mejora de la calidad de su cdigo. Aunque la complejidad de la produccin tpica de software garantiza que los probadores tendrn siempre trabajo, esperamos que anheles producir software sin defectos. Las tcnicas de diseo orientada a objetos hacen mucho para limitar la dicultad de proyectos grandes, pero nalmente debe escribir bucles y funciones. Estos pequeos detalles de programacin se convierten en los bloques de construccin de componentes mayores necesarios para sus diseos. Si sus blucles fallan por uno o sus funciones calculan los valores correctos slo la mayora de las veces, tiene problemas no importa como de elaborada sea su metodologa general. En este captulo, ver prcticas que ayudan a crear cdigo robusto sin importar el tamao de su proyecto. Su cdigo es, entre otras cosas, una expresin de su intento de resolver un problema. Sera claro para el lector (incluyendo usted) exactamente lo que estaba pensando cuando diseo aquel bucle. En ciertos puntos de su programa, deber crear atreverse con sentencias que considera alguna u otra condicin. (Si no puede, no ha realmente solucionado todava el problema.) Tales sentencias se llaman invariantes, puesto que deberan ser invariablemente verdad en el punto donde aparecen en el cdigo; si no, o su diseo es defectuoso, o su cdigo no reeja con precisin su diseo. Considere un programa que juega al juego de adivinanza mayor-menor. Una persona piensa un nmero entre el 1 y 100,y la otra persona adivina el nmero. (Permitir al ordenador hacer la adivinanza.) La persona que piensa el nmero le dice al adivinador si su conjetura es mayor, menor o correcta. La mejor estrategia para el adivinador es la bsqueda binaria, que elige el punto medio del rango de los nmeros donde el nmero buscado reside. La respuesta mayor-menor dice al adivinador que mitad de la lista ocupa el nmero, y el proceso se repite, reduciendo el tamao del rango de bsqueda activo en cada iteracin. Entonces cmo escribe un bucle para realizar la repeticin correctamente? No es suciente simplemente decir bool adivinado = false; while(!adivinado) { ... } porque un usuario malintencionado podra responder engaosamente, y podra pasarse todo el da adivinando. Qu suposicin, que sea sencilla, est haciendo cada vez que adivina? En otras palabras, qu condicin debera cumplir por diseo en cada iteracin del bucle? La suposicin sencilla es que el nmero secreto est dentro del actual rango activo de nmeros sin adivinar: [1, 100]. Suponga que etiquetamos los puntos nales del rango con las variables bajo y alto. Cada vez que pasa por el bucle necesita asegurarse que si el nmero estaba en el rango [bajo, alto] al principio del bucle, calcule 31 i i i i
i i
Captulo 3. Programacin defensiva el nuevo rango de modo que todava contenga el nmero al nal de la iteracin en curso. El objetivo es expresar el invariante del bucle en cdigo de modo que una violacin pueda ser detectada en tiempo de ejecucin. Desafortunadamente, ya que el ordenador no conoce el nmero secreto, no puede expresar esta condicin directamente en cdigo, pero puede al menos hacer un comentario para este efecto: while(!adivinado) { // INVARIANTE: el nmero est en el rango [low, high] Qu ocurre cuando el usuario dice que una conjetura es demasiado alta o demasiado baja cuando no lo es? El engao excluira el nmero secreto del nuevo subrango. Porque una mentira siempre dirige a otra, nalmente su rango disminuir a nada (puesto que se reduce a la mitad cada vez y el nmero secreto no est all). Podemos expresar esta condicin en el siguiente programa:
//: C02:HiLo.cpp {RunByHand} // Plays the game of Hi-Lo to illustrate a loop invariant. #include <cstdlib> #include <iostream> #include <string> using namespace std; int main() { cout << "Think of a number between 1 and 100" << endl << "I will make a guess; " << "tell me if Im (H)igh or (L)ow" << endl; int low = 1, high = 100; bool guessed = false; while(!guessed) { // Invariant: the number is in the range [low, high] if(low > high) { // Invariant violation cout << "You cheated! I quit" << endl; return EXIT_FAILURE; } int guess = (low + high) / 2; cout << "My guess is " << guess << ". "; cout << "(H)igh, (L)ow, or (E)qual? "; string response; cin >> response; switch(toupper(response[0])) { case H: high = guess - 1; break; case L: low = guess + 1; break; case E: guessed = true; break; default: cout << "Invalid response" << endl; continue; } } cout << "I got it!" << endl; return EXIT_SUCCESS; } ///:~
32 i i i i
i i 3.1. Aserciones
La violacin del invariante se detecta con la condicin if(menor > mayor), porque si el usuario siempre dice la verdad, siempre encontraremos el nmero secreto antes que agotsemos los intentos. Usamos tambin una tcnica del estndar C para informar sobre el estado de un programa al contexto llamante devolviendo diferentes valores desde main( ). Es portable para usar la sentencia return 0; para indicar xito, pero no hay un valor portable para indicar fracaso. Por esta razn usamos la macro declarada para este propsito en <cstdlib>:EXIT_FAILURE. Por consistencia, cuando usamos EXIT_FAILURE tambin usamos EXIT_SUCCESS, a pesar de que ste es siempre denido como cero.
3.1. Aserciones
La condicin en el programa mayor-menor depende de la entrada del usuario, por lo tanto no puede prevenir una violacin del invariante. Sin embargo, los invariantes normalmente dependen solo del cdigo que escribe, por eso comprobarn siempre si ha implementado su diseo correctamente. En este caso, es ms claro hacer una asercin, que es un sentencia positiva que muestra sus decisiones de diseo. Suponga que est implementando un vector de enteros: un array expandible que crece a peticin. La funcin que aade un elemento al vector debe primero vericar que hay un espacio vaco en el array subyacente que contiene los elementos; de lo contrario, necesita solicitar ms espacio en la pila y copiar los elementos existentes al nuevo espacio antes de aadir el nuevo elemento (y borrar el viejo array). Tal funcin podra ser de la siguiente forma:
void MyVector::push_back(int x) { if(nextSlot == capacity) grow(); assert(nextSlot < capacity); data[nextSlot++] = x; }
En este ejemplo, la informacin es un array dinmico de ints con capacidad espacios y espacioSiguiente espacios en uso. El propsito de grow( ) es expandir el tamao de la informacin para que el nuevo valor de capacidad sea estrictamente mayor que espacioSiguiente. El comportamiento correcto de MiVector depende de esta decisin de diseo, y nunca fallar si el resto del cdigo secundario es correcto. Armamos la condicin con la macro assert( ), que est denido en la cabecera <cassert>. La macro assert( ) de la biblioteca Estndar de C es breve, que resulta, portable. Si la condicin en su parmetro no evala a cero, la ejecucin contina ininterrumpidamente; si no, un mensaje contiene el texto de la expresin culpable con su nombre de chero fuente y el nmero de lnea impreso en el canal de error estndar y el programa se suspende. Es eso tan drstico? En la prctica, es mucho ms drstico permitir que la ejecucin continue cuando un supuesto de diseo bsico ha fracasado. Su programa necesita ser arreglado. Si todo va bien, probar a conciencia su cdigo con todas las aserciones intactas hasta el momento en que se haga uso del producto nal. (Diremos ms sobre pruebas ms tarde.) Depende de la naturaleza de su aplicacin, los ciclos de mquina necesarios para probar todas las aserciones en tiempo de ejecucin podran tener 33 i i i i
i i
Captulo 3. Programacin defensiva demasiado impacto en el rendimiento en produccin. En ese caso, puede eliminar todas las aserciones del cdigo automticamente deniendo la macro NDEBUG y reconstruir la aplicacin. Para ver como funciona esto, observe que una implementacin tpica de assert( ) se parece a esto:
#ifdef NDEBUG #define assert(cond) ((void)0) #else void assertImpl(const char*, const char*, long); #define assert(cond) \ ((cond) ? (void)0 : assertImpl(???)) #endif
Cuando la macro NDEBUG est denida, el cdigo se descompone a la expresin (void) 0, todo lo que queda en la cadena de compilacin es una sentencia esencialmente vaca como un resultado de la semicolumna que aade a cada invocacin de assert( ). Si NDEBUG no est denido, assert(cond) se expande a una sentencia condicional que, cuando cond es cero, llama a una funcin dependiente del compilador (que llamamos assertImpl( )) con argumento string representando el texto de cond, junto con el nombre de chero y el nmero de lnea donde aparece la asercin. (Usamos como un marcador de posicin en el ejemplo, pero la cadena mencionada es de hecho computada all, junto con el nombre del chero y el nmero de lnea donde la macro aparece en ese chero. Como estos valores se obtienen es irrelevante para nuestra discusin.) Si quiere activar y desactivar aserciones en diferentes puntos de su programa, no debe solo #dene o #undef NDEBUG, sino que debe tambin reincluir <cassert>. Las macros son evaluadas cuando el preprocesador los encuentra y as usa cualquier estado NDEBUG se aplica en el punto de inclusin. El camino ms comn dene NDEBUG una vez para todo el programa es como una opcin del compilador, o mediante la conguracin del proyecto en su entorno visual o mediante la lnea de comandos, como en:
mycc NDEBUG myfile.cpp
La mayora de los compiladores usan la bandera para denir los nombres de las macros. (Substituya el nombre del ejecutable de su compiladores por mycc arriba.) La ventaja de este enfoque es que puede dejar sus aserciones en el cdigo fuente como un inapreciable parte de documentacin, y no hay an castigo en tiempo de ejecucin. Porque el cdigo en una asercin desaparece cuando NDEBUG est denido, es importante que no haga trabajo en una asercin. Slo las condiciones de prueba que no cambien el estado de su programa. Si usar NDEBUG para liberar cdigo es una buena idea queda un tema de debate. Tony Hoare, una de los ms inuyentes expertos en informtica de todos los tiempos,[15] ha sugerido que desactivando las comprobaciones en tiempo de ejecucin como las aserciones es similar a un entusiasta de navegacin que lleva un chaleco salvavidas mientras entrena en tierra y luego se deshace de l cuando va al mar.[16] Si una asercin falla en produccin, tiene un problema mucho peor que la degradacin en rendimiento, as que elija sabiamente. No todas las condiciones deberan ser cumplidas por aserciones. Los errores de usuario y los fallos de los recursos en tiempos de ejecucin deberan ser sealados lanzando excepciones, como explicamos en detalle en el Captulo 1. Es tentador usar aserciones para la mayora de las condiciones de error mientras esbozamos cdigo, 34 i i i i
i i
3.2. Un framework de pruebas unitarias sencillo con el propsito de remplazar muchos de ellos despus con un manejador de excepciones robusto. Como cualquier otra tentacin, sese con moderacin, pues podra olvidar hacer todos los cambios necesarios ms tarde. Recuerde: las aserciones tienen la intencin de vericar decisiones de diseo que fallarn slo por lgica defectuosa del programador. Lo ideal es solucionar todas las violaciones de aserciones durante el desarrollo. No use aserciones para condiciones que no estn totalmente en su control (por ejemplo, condiciones que dependen de la entrada del usuario). En particular, no querra usar aserciones para validar argumentos de funcin; lance un logic_error en su lugar. El uso de aserciones como una herramienta para asegurar la correccin de un programa fue formalizada por Bertran Meyer en su Diseo mediante metodologa de contrato.[17] Cada funcin tiene un contrato implcito con los clientes que, dadas ciertas precondiciones, garantiza ciertas postcondiciones. En otras palabras, las precondiciones son los requerimientos para usar la funcin, como los argumentos que se facilitan dentro de ciertos rangos, y las postcondiciones son los resultados enviados por la funcin o por retorno por valor o por efecto colateral. Cuando los programas clientes fallan al darle un entrada vlida, debe comentarles que han roto el contrato. Este no es el mejor momento para suspender el programa (aunque est justicado hacerlo desde que el contrato fue violado), pero una excepcin es desde luego apropiada. Esto es porque la librera Estndar de C++ lanza excepciones derivadas de logic_error, como out_of_range.[18] Si hay funciones que slo usted llama, no obstante, como funciones privadas en una clase de su propio diseo, la macro assert( ) es apropiada, puesto que tiene total control sobre la situacin y desde luego quiere depurar su cdigo antes de enviarlo. Una postcondicin fallada indica un error de programa, y es apropiado usar aserciones para cualquier invariante en cualquier momento, incluyendo la postcondicin de prueba al nal de una funcin. Esto se aplica en particular a las funciones de una clase que mantienen el estado de un objeto. En el ejemplo MyVector previo, por ejemplo, un invariante razonable para todas las funciones sera: assert(0 <= siguienteEspacio && siguienteEspacio <= capacidad); o, si siguienteEspacio es un integer sin signo, sencillamente assert(siguienteEspacio <= capacidad); Tal tipo de invariante se llama invariante de clase y puede ser razonablemente forzada por una asercin. Las subclases juegan un papel de subcontratista para sus clases base porque deben mantener el contrato original entre la clase base y sus clientes. Por esta razn, las precondiciones en clases derivadas no deben imponer requerimientos adicionales ms all de aquellos del contrato base, y las postcondiciones deben cumplir al menos como mucho.[19] Validar resultados devueltos por el cliente, sin embargo, no es ms o menos que probar, de manera que usar aserciones de postcondicin en este caso sera duplicar trabajo. S, es buena documentacin, pero ms de un desarrollador has sido engaado usando incorrectamente las aserciones de post-condicin como un substituto para pruebas de unidad.
i i
Captulo 3. Programacin defensiva exactamente lo que los usuarios realmente quieren. Las personas no pueden articular requerimientos de software sin muestrear un sistema de trabajo en evolucin. Es mucho mejor especicar un poco, disear un poco, codicar un poco y probar un poco. Entonces, despus de evaluar el resultado, hacerlo todo de nuevo. La habilidad para desarrollar con una moda iterativa es uno de los mejores avances del enfoque orientado a objetos, pero requiere programadores giles que pueden hacer cdigo fuerte. El cambio es duro. Otro mpetu para el cambio viene de usted, el programador. El artce que hay en usted quiere continuamente mejorar el diseo de su cdigo. Qu programador de mantenimiento no ha maldecido el envejecimiento, el producto de la compaa insignia como un mosaico de espaguetis inmodicable, enrevesado? La reluctancia de los supervisores en permitir que uno interera con un sistema que funciona le roba al cdigo la exibilidad que necesita para que perdure. Si no est roto, no arreglarlo nalmente le da el camino para, no podemos arreglarlo reescribmoslo. El cambio es necesario. Afortunadamente, nuestra industria est creciendo acostumbrada a la disciplina de refactoring, el arte de reestructura internamente cdigo para mejorar su diseo, sin cambiar su comportamiento.[21] Tales mejoras incluyen extraer una nueva funcin de otra, o de forma inversa, combinar funciones, reemplazar una funcin con un objeto; parametrizar una funcin o clase; y reemplazar condicionales con polimorsmo. Refactorizar ayuda al cdigo evolucionar. Si la fuerza para el cambio viene de los usuarios o programadores, los cambios hoy pueden destrozar lo trabajado ayer. Necesitamos un modo para construir cdigo que resista el cambio y mejoras a lo largo del tiempo. La Programacin Extrema (XP)[22] es slo uno de las muchas prcticas que motivan la agilidad. En esta seccin exploramos lo que pensamos es la clave para hacer un desarrollo exible, incremental que tenga xito: un framework de pruebas unitarias automatizada fcil de usar. (Note que los probadores, profesionales de software que prueban el cdigo de otros para ganarse la vida, son todava indispensables. Aqu, estamos simplemente describiendo un modo para ayudar a los desarrolladores a escribir mejor cdigo.) Los desarrolladores escriben pruebas unitarias para conseguir conanza para decir las dos cosas ms importantes que cualquier desarrollador puede decir: 1. Entiendo los requerimientos. Mi cdigo cumple esos requerimientos (hasta donde yo s) No hay mejor modo para asegurar que sabe lo que el cdigo que est por escribir debera hacer mejor que escribir primero pruebas unitarias. Este ejercicio sencillo ayuda a centrar la mente en las tareas siguientes y probablemente guiar a cdigo que funcionalmente ms rpido mejor que slo saltar a codicar. O, expresarlo en trminos XP: Probar + programar es ms rpido que slo programar. Escribir primero pruebas slo le protegen contra condiciones lmite que podran destrozar su cdigo, por lo tanto su cdigo es ms robusto. Cuando su cdigo pasa todas sus pruebas, sabe que si el sistema no est funcionando, su cdigo no es probablemente el problema. La frase todas mis pruebas funcionan es un fuerte razonamiento.
36 i i i i
i i
37 i i i i
i i
Antes de que implemente esta clase, puede solidicar sus conocimientos de los requerimientos escribiendo el principio de un programa de prueba. Podra idear algo como lo siguiente:
//: C02:SimpleDateTest.cpp //{L} Date #include <iostream> #include "Date.h" // From Appendix B using namespace std; // Test machinery int nPass = 0, nFail = 0; void test(bool t) { if(t) nPass++; else nFail++; } int main() { Date mybday(1951, 10, 1); test(mybday.getYear() == 1951); test(mybday.getMonth() == 10); test(mybday.getDay() == 1); cout << "Passed: " << nPass << ", Failed: " << nFail << endl; } /* Expected output: Passed: 3, Failed: 0 */ ///:~
En este caso trivial, la funcin test( ) mantiene las variables globales nAprobar y nSuspender. La nica revisin visual que hace es leer el resultado nal. Si una prueba falla, un test( ) ms sosticado muestra un mensaje apropiado. El framework descrito ms tarde en este captulo tiene un funcin de prueba, entre otras cosas. Puede ahora implementar la clase Fecha para hacer pasar estas pruebas, y luego puede proceder iterativamente hasta que se satisfagan todos los requerimientos. Escribiendo primero pruebas, es ms probable que piense en casos lmite que podran destrozar su prxima implementacin, y es ms probable que escriba el cdigo correctamente la primera vez. Como ejercicio podra realizar la siguiente versin de una prueba para la clase Fecha:
//: C02:SimpleDateTest2.cpp //{L} Date #include <iostream>
38 i i i i
i i
Esta prueba puede ser desarrollada por completo. Por ejemplo, no hemos probado que duraciones grandes son manejadas correctamente. Pararemos aqu, pero coja la idea. La implementacin entera para la case Fecha est disponible en los cheros Date.h y Date.cpp en el apndice.[23]
i i
Captulo 3. Programacin defensiva aqu no es slo presentar un mecanismo de prueba que sea fcil de usar, sino tambin fcil de entender internamente e incluso modicar si es necesario. Por lo tanto, en el espritu de Hacer Lo Ms Simple Que Podra Posiblemente Funcionar,[25] hemos desarrollado el Framework TestSuite, un espacio de nombres llamado TestSuite que contiene dos clases principales: Test y Suite. La clase Test es una clase base abstracta de la cual deriva un objeto test. Tiene constancia del nmero de xitos y fracasos y muestra el texto de cualquier condicin de prueba que falla. Simplemente para sobreescribir la funcin run( ), que debera llamar en turnos a la macro test_() para cada condicin de prueba boolean que dena. Para denir una prueba para la clase Fecha usando el framework, puede heredar de Test como se muetra en el siguiente programa:
//: C02:DateTest.h #ifndef DATETEST_H #define DATETEST_H #include "Date.h" #include "../TestSuite/Test.h" class DateTest : public TestSuite::Test { Date mybday; Date today; Date myevebday; public: DateTest(): mybday(1951, 10, 1), myevebday("19510930") {} void run() { testOps(); testFunctions(); testDuration(); } void testOps() { test_(mybday < today); test_(mybday <= today); test_(mybday != today); test_(mybday == mybday); test_(mybday >= mybday); test_(mybday <= mybday); test_(myevebday < mybday); test_(mybday > myevebday); test_(mybday >= myevebday); test_(mybday != myevebday); } void testFunctions() { test_(mybday.getYear() == 1951); test_(mybday.getMonth() == 10); test_(mybday.getDay() == 1); test_(myevebday.getYear() == 1951); test_(myevebday.getMonth() == 9); test_(myevebday.getDay() == 30); test_(mybday.toString() == "19511001"); test_(myevebday.toString() == "19510930"); } void testDuration() { Date d2(2003, 7, 4); Date::Duration dur = duration(mybday, d2); test_(dur.years == 51); test_(dur.months == 9);
40 i i i i
i i
Ejecutar la prueba es una sencilla cuestin de instaciacin de un objeto DateTest y llamar a su funcin run( ):
//: C02:DateTest.cpp // Automated testing (with a framework). //{L} Date ../TestSuite/Test #include <iostream> #include "DateTest.h" using namespace std; int main() { DateTest test; test.run(); return test.report(); } /* Output: Test "DateTest": Passed: 21, */ ///:~
Failed: 0
La funcin Test::report( ) muestra la salida previa y devuelve el nmero de fallos, de este modo es conveniente usarlo como valor de retorno desde el main( ). La clase Test usa RTTI[26] para obtener el nombre de su clase(por ejemplo, DateTest) para el informe. Hay tambin una funcin setStream() si quiere enviar los resultados de la prueba a un chero en lugar de la salida estndar (por defecto). Ver la implementacin de la clase Test ms tarde en este captulo. La macro test_( ) puede extraer el texto de la condicin booleana que falla, junto con el nombre del chero y nmero de lnea.[27] Para ver lo que ocurre cuando un fallo aparece, puede insertar un error intencionado en el cdigo, por ejemplo invirtiendo la condicin en la primera llamda a test_( ) en DateTest::testOps( ) en el cdigo de ejemplo previo. La salida indica exactamente que la prueba tena un error y dnde ocurri: DateTest fallo: (mybday > hoy) , DateTest.h (lnea 31) Test "DateTest": Passados: 20 Fallados: 1 Adems de test_( ), el framework incluye las funciones succed_( ) y fail_( ), para casos donde una prueba Boolean no funcionar. Estas funciones se aplican cuando la clase que est probando podra lanzar excepciones. Durante la prueba, crear un conjunto de entrada que causar que la excepcin aparezca. Si no, es un error y puede llamar a fail_( ) explicitamente para mostrar un mensaje y actualizar el contador de fallos. Si lanza la excecpin como se esperaba, llame a succeed_( ) para actualizar el contador de xitos. Para ilustrar, suponga que modicamos la especicacin de los dos constructor no por defecto de Date para lanzar una excepcin DateError (un tipo anidado dentro de Date y derivado de std::logic_error) si los parmetros de entrada no representa un fecha vlida: Date(const string& s) throw(DateError); Date(int year, int month, 41 i i i i
i i
Captulo 3. Programacin defensiva int day) throw(DateError); La funcin DateTest::run( ) puede ahora llamar a la siguiente funcin para probar el manejo de excepciones:
void testExceptions() { try { Date d(0,0,0); // Invalid fail_("Invalid date undetected in Date int ctor"); } catch(Date::DateError&) { succeed_(); } try { Date d(""); // Invalid fail_("Invalid date undetected in Date string ctor"); } catch(Date::DateError&) { succeed_(); } }
En ambos casos, si una excepcin no se lanza, es un error. Fjese que debe pasar manualmente un mensaje a fail_( ), pues no se est evaluando una expresin booleana.
42 i i i i
i i
5 de los tests de ms arriba estn completamente contenidos en los cheros de cabecera. TrimTest no lo est, porque contiene datos estticos que deben estar denidos en un chero de implementacin. Las dos primeras lneas de salida son trazos de la prueba StringStorage. Debe dar a la suite un nombre como argumento del constructor. La funcin Suite::run( ) llama a Test::run( ) po cada una de las pruebas que tiene. Ms de lo mismo pasa con Suite::report( ), excepto que puede enviar los informes de pruebas individuales a cadenas destinaciones diferentes mejor que el informe de la suite. Si la prueba pasa a addSuite( ) ya tiene un puntero de cadena asignado, que lo guarda. En otro caso, obtiene su cadena del objeto Suite. (Como con Test, hay un segundo argumento opcional para el constructor suite que no se presenta a std::cout.) El destructor para Suite no borra automticamente los punteros contenidos en Test porque no necesitan residir en la pila; este es el trabajo de Suite::free( ).
43 i i i i
i i
// fail_() has an underscore to prevent collision with // ios::fail(). For consistency, test_() and succeed_() // also have underscores. #define test_(cond) \ do_test(cond, #cond, __FILE__, __LINE__) #define fail_(str) \ do_fail(str, __FILE__, __LINE__) namespace TestSuite { class Test { ostream* osptr; long nPass; long nFail; // Disallowed: Test(const Test&); Test& operator=(const Test&); protected: void do_test(bool cond, const string& lbl, const char* fname, long lineno); void do_fail(const string& lbl, const char* fname, long lineno); public: Test(ostream* osptr = &cout) { this->osptr = osptr; nPass = nFail = 0; } virtual ~Test() {} virtual void run() = 0; long getNumPassed() const { return nPass; } long getNumFailed() const { return nFail; } const ostream* getStream() const { return osptr; } void setStream(ostream* osptr) { this->osptr = osptr; } void succeed_() { ++nPass; } long report() const; virtual void reset() { nPass = nFail = 0; } }; } // namespace TestSuite #endif // TEST_H ///:~
Hay tres funciones virtuales en la clase Test: Un destructor virtual La funcin reset( ) La funcin virtual pura run( ) Como se explic en el Volumen 1, es un error eliminar un objeto derivado de la pila a travs de un puntero base a menos que la clase base tenga un destructor virtual. Cualquier clase propuesta para ser una clase base (normalmente evidenciadas por la presencia de al menos una de las otras funciones virtuales) tendra un destructor virtual. La implementacin por defecto de Test::reset( ) pone los contadores de xitos y fallos a cero. Podra querer sobreescribir esta funcin para poner el estado de los datos en su objeto de test derivado; slo asegrese de llamar a Test::rest( ) 44 i i i i
i i
3.2. Un framework de pruebas unitarias sencillo explcitamente en su sobreescritura de modo que los contadores se reajusten. La funcin Test::run( ) es virtual pura ya que es necesario para sobreescribirla en su clase derivada. Las macros test_( ) y fail_( ) pueden incluir la informacin disponible del nombre del chero y el nmero de lnea del preprocesador. Originalmente omitimos el guin bajo en los nombres, pero la macro fail colisiona con ios::fail( ), provocando errores de compilacin. Aqu est la implementacin del resto de las funciones Test:
//: TestSuite:Test.cpp {O} #include "Test.h" #include <iostream> #include <typeinfo> using namespace std; using namespace TestSuite; void Test::do_test(bool cond, const std::string& lbl, const char* fname, long lineno) { if(!cond) do_fail(lbl, fname, lineno); else succeed_(); } void Test::do_fail(const std::string& lbl, const char* fname, long lineno) { ++nFail; if(osptr) { *osptr << typeid(*this).name() << "failure: (" << lbl << ") , " << fname << " (line " << lineno << ")" << endl; } } long Test::report() const { if(osptr) { *osptr << "Test \"" << typeid(*this).name() << "\":\n\tPassed: " << nPass << "\tFailed: " << nFail << endl; } return nFail; } ///:~
La clase Test lleva la cuenta del nmero de xitos y fracasos adems de la cadena donde quiere que Test::report( ) muestre los resultados. Las macros test_( ) y fail_() extraen la informacin del nombre del chero actual y el nmero de lnea del preprocesador y pasa el nombre del chero a do_test( ) y el nmero de lnea a do_fail( ), que hacen el mismo trabajo de mostrar un mensaje y actualizar el contador apropiado. No podemos pensar una buena razn para permitir copiar y asignar objetos de prueba, por lo que hemos rechazado estas operaciones para hacer sus prototipos privados y omitir el cuerpo de sus respectivas funciones. Aqu est el chero de cabecera para Suite: 45 i i i i
i i
//: TestSuite:Suite.h #ifndef SUITE_H #define SUITE_H #include <vector> #include <stdexcept> #include "../TestSuite/Test.h" using std::vector; using std::logic_error; namespace TestSuite { class TestSuiteError : public logic_error { public: TestSuiteError(const string& s = "") : logic_error(s) {} }; class Suite { string name; ostream* osptr; vector<Test*> tests; void reset(); // Disallowed ops: Suite(const Suite&); Suite& operator=(const Suite&); public: Suite(const string& name, ostream* osptr = &cout) : name(name) { this->osptr = osptr; } string getName() const { return name; } long getNumPassed() const; long getNumFailed() const; const ostream* getStream() const { return osptr; } void setStream(ostream* osptr) { this->osptr = osptr; } void addTest(Test* t) throw(TestSuiteError); void addSuite(const Suite&); void run(); // Calls Test::run() repeatedly long report() const; void free(); // Deletes tests }; } // namespace TestSuite #endif // SUITE_H ///:~
La clase Suite tiene punteros a sus objetos Test en un vector. Fjese en la especicacin de la excepcin en la funcin addTest( ). Cuando aada una prueba a una suite, Suite::addTest( ) verique que el puntero que pasa no sea null; si es null, se lanza una excepcin TestSuiteError. Puesto que esto hace imposible aadir un puntero null a una suite, addSuite( ) arma esta condicin en cada prueba, como hacen las otras funciones que atraviesan el vector de pruebas (vea la siguiente implementacin). Copiar y asignar estn desestimados como estn en la clase Test.
//: TestSuite:Suite.cpp {O} #include "Suite.h" #include <iostream> #include <cassert>
46 i i i i
i i
47 i i i i
i i
long Suite::getNumPassed() const { long totPass = 0; for(size_t i = 0; i < tests.size(); ++i) { assert(tests[i]); totPass += tests[i]->getNumPassed(); } return totPass; } long Suite::getNumFailed() const { long totFail = 0; for(size_t i = 0; i < tests.size(); ++i) { assert(tests[i]); totFail += tests[i]->getNumFailed(); } return totFail; } void Suite::reset() { for(size_t i = 0; i < tests.size(); ++i) { assert(tests[i]); tests[i]->reset(); } } ///:~
Usaremos el framework TestSuite donde sea pertinente a lo largo del resto de este libro.
i i
3.3. Tcnicas de depuracin que no es exactamente lo que quiere. Por lo tanto, debe usar esta tcnica cuidadosamente. Lo siguiente es una variacin en la macro TRACE( ): #dene D(a) cout << #a "=[" << a << "]" << endl; Si quiere mostrar una expresin, simplemente pngala dentro de una llamada a D( ). La expresin se muestra, seguida de su valor ( asumiendo que hay un operador sobrecargado << para el tipo de resultado). Por ejemplo, puede decir D(a + b). Puede usar esta macro en cualquier momento que quiera comprobar un valor intermedio. Estas dos macros representan las dos cosas fundamentales que hace con un depurador: trazar la ejecucin de cdigo y mostrar valores. Un buen depurador es una herramienta de productividad excelente, pero a veces los depuradores no estn disponibles, o no es conveniente usarlos. Estas tcnicas siempre funcionan, sin tener en cuenta la situacin.
49 i i i i
i i
Porque cout ha sido textualmente convertido en algo ms por Trace.h, todas las sentencias cout en su programa ahora envan informacin al chero de seguimiento. Esto es una forma conveniente de capturar su salida en un chero, en caso de que su sistema operativo no haga una fcil redireccin de la salida.
50 i i i i
i i
// For size_t
// Usurp the new operator (both scalar and array versions) void* operator new(std::size_t, const char*, long); void* operator new[](std::size_t, const char*, long); #define new new (__FILE__, __LINE__) extern bool traceFlag; #define TRACE_ON() traceFlag = true #define TRACE_OFF() traceFlag = false extern bool activeFlag; #define MEM_ON() activeFlag = true #define MEM_OFF() activeFlag = false #endif // MEMCHECK_H ///:~
Es importante incluir este chero en cualquier chero fuente en el que quiera seguir la actividad de la memoria libre, pero inclyalo al nal (despus de sus otras directivas #include). La mayora de las cabeceras en la biblioteca estndar son plantillas, y puesto que la mayora de los compiladores usan el modelo de inclusin de compilacin de plantilla (signica que todo el cdigo fuente est en las cabeceras), la macro que reemplaza new en MemCheck.h usurpar todas las instancias del operador new en el cdigo fuente de la biblioteca (y casi resultara en errores de compilacin). Adems, est slo interesado en seguir sus propios errores de memoria, no los de la biblioteca. En el siguiente chero, que contiene la implementacin del seguimiento de memoria, todo est hecho con C estndar I/O ms que con iostreams C++. No debera inuir, puesto que no estamos interriendo con el uso de iostream en la memoria libre, pero cuando lo intentamos, algunos compiladores se quejaron. Todos los compiladores estaban felices con la versin <cstdio>.
//: C02:MemCheck.cpp {O} #include <cstdio> #include <cstdlib> #include <cassert> #include <cstddef> using namespace std; #undef new // Global flags set by macros in MemCheck.h bool traceFlag = true; bool activeFlag = false; namespace { // Memory map entry type struct Info { void* ptr; const char* file; long line; };
51 i i i i
i i
52 i i i i
i i
Las banderas booleanas de traceFalg y activeFlag son globales, por lo que pueden ser modicados en su cdigo por las macros TRACE_ON( ), TRACE_OFF( ), MEM_ON( ), y MEM_OFF( ). En general, encierre todo el cdigo en su main( ) dentro una pareja MEM_ON( )-MEM_OFF( ) de modo que la memoria sea siempre trazada. Trazar, que repite la actividad de las funciones de sustitucin por el operador new( ) y el operador delete( ), es por defecto, pero puede desactivarlo con TRACE_OFF( ). En cualquier caso, los resultados nales son siempre impresos (vea la prueba que se ejecuta ms tarde en este captulo). La facilidad MemCheck rastrea la memoria guardando todas las direcciones asignadas por el operador new( ) en un array de estructuras Info, que tambin tiene el nombre del chero y el nmero de lnea donde la llamada new se encuentra. Para prevenir la colisin con cualquier nombre que haya colocado en el espacio de nombres global, tanta informacin como sea posible se guarda dentro del espacio de nombre annimo. La clase Sentinel existe nicamente para llamar a un destructor de objetos con esttico cuando el programa termina. Este destructor inspecciona memMap para ver si algn puntero est esperando a ser borrado (indicando una perdida de memoria). Nuestro operador new( ) usa malloc( ) para conseguir memoria, y luego aade el puntero y su informacin de chero asociado a memMap. La funcin de operador delete( ) deshace todo el trabajo llamando a free( ) y decrementando nptrs, pero primero se comprueba para ver si el puntero en cuestin est en el mapa en el primer lugar. Si no es as, o reintenta borrar una direccin que no est en el almacn libre, o re intenta borrar la que ya ha sido borrada y eliminada del mapa. La variable activeFlag es importante aqu porque no queremos procesar ninguna desasignacin de alguna actividad del cierre del sistema. Llamando a MEM_OFF( ) al nal de su cdigo, activeFlag ser puesta a falso, y posteriores llamadas para borrar sern ig53 i i i i
i i
Captulo 3. Programacin defensiva noradas. (Est mal en un programa real, pero nuestra intencin aqu es encontrar agujeros, no est depurando la biblioteca.) Por simplicidad, enviamos todo el trabajo por array new y delete a sus homlogos escalares. Lo siguiente es un test sencillo usando la facilidad MemCheck:
//: C02:MemTest.cpp //{L} MemCheck // Test of MemCheck system. #include <iostream> #include <vector> #include <cstring> #include "MemCheck.h" // Must appear last! using namespace std; class Foo { char* s; public: Foo(const char*s ) { this->s = new char[strlen(s) + 1]; strcpy(this->s, s); } ~Foo() { delete [] s; } }; int main() { MEM_ON(); cout << "hello" << endl; int* p = new int; delete p; int* q = new int[3]; delete [] q; int* r; delete r; vector<int> v; v.push_back(1); Foo s("goodbye"); MEM_OFF(); } ///:~
Este ejemplo verica que puede usar MemCheck en presencia de streams, contenedores estndar, y clases que asignan memoria en constructores. Los punteros p y q son asignados y desasignados sin ningn problema, pero r no es un puntero de pila vlido, as que la salida indica el error como un intento de borrar un puntero desconocido: hola Asignados 4 bytes en la direccin 0xa010778 (chero: memtest.cpp, lnea: 25) Deleted memory at address 0xa010778 Asignados 12 bytes en la direccin 0xa010778 (chero: memtest.cpp, lnea: 27) Memoria borrada en la direccin 0xa010778 Intento de borrar puntero desconocido: 0x1 Asignados 8 bytes en la direccin 0xa0108c0 (chero: memtest.cpp, lnea: 14) Memoria borrada en la direccin 0xa0108c0 No hay agujeros de memoria de usuario! A causa de la llamada a MEM_OFF( ), no se procesan posteriores llamadas al operador delete( ) por vector o ostream. Todava podra conseguir algunas llamadas a delete realizadas dsede reasignaciones por los contenedores. 54 i i i i
i i 3.4. Resumen Si llama a TRACE_OFF( ) al principio del programa, la salida es Hola Intento de borrar puntero desconocido: 0x1 No hay agujeros de memoria de usuario!
3.4. Resumen
Muchos de los dolores de cabeza de la ingenera del software pueden ser evitados reexionando sobre lo que est haciendo. Probablemente ha estado usando aserciones mentales cuando ha navegado por sus blucles y funciones, incluso si no ha usado rutinariamente la macro assert( ). Si usa assert( ), encontrar errores lgicos ms pronto y acabar con cdigo ms legible tambin. Recuerde usar solo aserciones para invariantes, aunque, no para el manejo de error en tiempo de ejecucin. Nada le dar ms tranquilidad que cdigo probado rigurosamente. Si ha sido un lo en el pasado, use un framework automatizado, como el que hemos presentado aqu, para integrar la rutina de pruebas en su trabajo diario. Usted (y sus usarios!) estarn contentos de que lo haga.
3.5. Ejercicios
Las soluciones para ejercicios seleccionados pueden encontrarse en el documento electrnico Pensar en C++ Volumen 2 Gua de Soluciones Comentadas disponible por una pequea cuota en www.MindView.net. 1. Escriba un programa de prueba usando el Framework TestSuite para la clase estndar vector que prueba rigurosamente prueba las siguientes funciones con un vector de enteros: push_back( ) (aade un elemento al nal del vector) front( ) (devuelve el primer elemento en el vector), back( ) (devuelve el ltimo elemento en el vector), pop_back( ) (elimina el ltimo elemento sin devolverlo), at( ) (devuelve el elemento en una posicin especca), y size( ) (devuelve el nmero de elementos). Asegrese de vericar que vector::at( ) lanza una excepcin std::out_of_range si el ndice facilitado est fuera de rango. 2. Supngase que le piden desarrollar un clase llamada Rational que da soporte a nmeros racionales (fracciones). La fraccin en un objecto Rational debera siempre almacenarse en los trminos ms bajos, y un denominador de cero es un error. Aqu est una interfaz de ejemplo para esa clase Rational:
//: C02:Rational.h {-xo} #ifndef RATIONAL_H #define RATIONAL_H #include <iosfwd> class Rational { public: Rational(int numerator = 0, int Rational operator-() const; friend Rational operator+(const const friend Rational operator-(const const friend Rational operator*(const const friend Rational operator/(const
55 i i i i
i i
Escriba una especicacin completa para esta clase, incluyendo especicaciones de precondiciones, postcondiciones, y de excepcin. 3. Escriba un prueba usando el framework TestSuite que pruebe rigurosamente todas las especicaciones del ejercicio anterior, incluyendo probar las excepciones. 4. Implemente la clase Rational de modo que pase todas las pruebas del ejercicio anterior. Use aserciones slo para las invariantes. 5. El chero BuggedSearch.cpp de abajo contiene un funcin de bsqueda binaria que busca para el rango [pedir, nal). Hay algunos errores en el algoritmo. Use las tcnicas de seguimiento de este captulo para depurar la funcin de bsqueda.
56 i i i i
i i
Parte II
57 i i i i
i i
i i i
i i
El C++ Estndar no solo incorpora todas las libreras de Estndar C (con pequeos aadidos y cambios para permitir tipos seguros), tambin aade sus propias libreras. Estas libreras son mucho ms potentes que las de C. La mejora al usarlas es anloga a la que se consigue al cambiar de C a C++.
Esta seccin del libro le da una introduccin en profundidad a las partes clave de la librera Estndar de C++. La referencia ms completa y tambin la ms oscura para las libreras es el propio Estndar. The C++ Programming Language, Third Edition (Addison Wesley, 2000) de Bjarne Stroustrup sigue siendo una referencia able tanto para el lenguaje como para la librera. La referencia ms aclamada en cuanto a la librera es The C++ Standard Library: A Tutorial and Reference, by Nicolai Josuttis (Addison Wesley, 1999). El objetivo de los captulos de esta parte del libro es ofrecer un catlogo de descripciones y ejemplos para que disponga de un buen punto de partida para resolver cualquier problema que requiera el uso de las libreras Estndar. Sin embargo, algunas tcnicas y temas se usan poco y no se tratan aqu. Si no puede encontrar algo en estos captulos, mire en los dos libros que se citan anteriormente; esto libro no pretende reemplazarlos, ms bien completarlos. En particular, esperamos que despus de consular el material de los siguientes captulos pueda comprender mejor esos libros. El lector notar que estos captulos no contienen documentacin exhaustiva describiendo cada funcin o clase del la Librera Estndar C++. Hemos dejado las descripciones completas a otros; en particular a Dinkumware C/C++ Library Reference de P.J. Plauger. Esta es una excelente documentacin que puede puede ver con un navegador web cada vez que necesite buscar algo. Puede verla on-line o comprarla para verla en local. Contiene una referencia completa para las libreras de C y C++ (de modo que es buena para cualquier cuestin de programacin en C/C++ Estndar). La documentacin electrnica no slo es efectiva porque pueda tenerla siempre a mano, sino porque tambin puede hacer bsquedas electrnicas. Cuando usted est programando activamente, estos recursos deberan satisfacer sus necesidades de referencias (y puede usarlas para buscar algo de este captulo que no tenga claro). El Apndice A incluye referencias adicionales. El primer captulo de esta seccin introduce la clase string del Estndar C++, que es una herramienta potente que simplica la mayora de las tareas de procesamiento de texto que podra tener que realizar. Casi cualquier cosas que tenga hecho para cadenas de caracteres en C puede hacerse con una llamada a un mtodo de la clase string. El captulo 4 cubre la librera iostreams, que contiene clases para procesar entrada y salida con cheros, cadenas, y la consola del sistema. Aunque el Captulo 5: Las plantillas a fondo no es explcitamente un captulo de la librera, es una preparacin necesaria para los dos siguientes captulos. En el captulo 6 examinaremos los algoritmos genricos que ofrece la librera Estndar C++. Como estn implementados con plantillas, esos algoritmos se pueden aplicar a cualquier secuencia de objetos. El Captulo 7 cubre los contenedores estndar y sus iteradores asociados Vemos los algoritmos primero porque se pueden utilizar usando nicamente arrays y el contenedor vector (que vimos en el Volumen 1). Tambin es normal el uso de algoritmos estndar junto con contenedores, y es bueno que le resulten familiares antes de estudiar los contenedores.
59 i i i i
i i
i i i
i i
4.1. Qu es un string?
En C, una cadena es simplemente un arreglo de caracteres que siempre incluye un 0 binario (frecuentemente llamado terminador nulo) como elemento nal del
1
Algunos materiales de este captulo fueron creados originalmente por Nancy Nicolaisen
61 i i i i
i i
Captulo 4. Las cadenas a fondo arreglo. Existen diferencias signicativas entre los string de C++ y sus progenitoras en C. Primero, y ms importante, los string de C++ esconden la implementacin fsica de la secuencia de caracteres que contiene. No debe preocuparse de las dimensiones del arreglo o del terminador nulo. Un string tambin contiene cierta informacin para uso interno sobre el tamao y la localizacin en memoria de los datos. Especcamente, un objeto string de C++ conoce su localizacin en memoria, su contenido, su longitud en caracteres, y la cantidad de caracteres que puede crecer antes de que el objeto string deba redimensionar su buffer interno de datos. Las string de C++, por tanto, reducen enormemente las probabilidades de cometer uno de los tres errores de programacin en C ms comunes y destructivos: sobrescribir los lmites del arreglo, intentar acceder a un arreglo no inicializado o con valores de puntero incorrectos, y dejar punteros colgando despus de que el arreglo deje de ocupar el espacio que estaba ocupando. La implementacin exacta del esquema en memoria para una clase string no esta denida en el estndar C++. Esta arquitectura esta pensada para ser sucientemente exible para permitir diferentes implementaciones de los fabricantes de compiladores, garantizando igualmente un comportamiento predecible por los usuarios. En particular, las condiciones exactas de cmo situar el almacenamiento para alojar los datos para un objeto string no estn denidas. FIXME: Las reglas de alojamiento de un string fueron formuladas para permitir, pero no requerir, una implementacin con referencias mltiples, pero dependiendo de la implementacin usar referencias mltiples sin variar la semntica. Por decirlo de otra manera, en C, todos los arreglos de char ocupan una nica regin fsica de memoria. En C++, los objetos string individuales pueden o no ocupar regiones fsicas nicas de memoria, pero si su conjunto de referencias evita almacenar copias duplicadas de datos, los objetos individuales deben parecer y actuar como si tuvieran sus propias regiones nicas de almacenamiento.
//: C03:StringStorage.h #ifndef STRINGSTORAGE_H #define STRINGSTORAGE_H #include <iostream> #include <string> #include "../TestSuite/Test.h" using std::cout; using std::endl; using std::string; class StringStorageTest : public TestSuite::Test { public: void run() { string s1("12345"); // This may copy the first to the second or // use reference counting to simulate a copy: string s2 = s1; test_(s1 == s2); // Either way, this statement must ONLY modify s1: s1[0] = 6; cout << "s1 = " << s1 << endl; // 62345 cout << "s2 = " << s2 << endl; // 12345 test_(s1 != s2); } }; #endif // STRINGSTORAGE_H ///:~
62 i i i i
i i
4.2. Operaciones con cadenas Decimos que cuando una implementacin solo hace una sola copia al modicar el string usa una estrategia de copiar al escribir. Esta aproximacin ahorra tiempo y espacio cuando usamos string como parmetros por valor o en otras situaciones de solo lectura. El uso de referencias mltiples en la implementacin de una librera debera ser transparente al usuario de la clase string. Desgraciadamente, esto no es siempre el caso. En programas multihilo, es prcticamente imposible usar implementaciones con mltiples referencias de forma segura[32].2
63 i i i i
i i
Este ejemplo demuestra que aunque puede ignorar con seguridad muchas de las responsabilidades de reserva y gestin de la memoria que tus string ocupan, C++ provee a los string con varias herramientas para monitorizar y gestionar su tamao. Ntese la facilidad con la que hemos cambiado el tamao de la memoria reservada para los string. La funcin size() retorna el numero de caracteres actualmente almacenados en el string y es idntico a la funcin miembro lenght(). La funcin capacity() retorna el tamao de la memoria subyacente actual, es decir, el nmero de caracteres que el string puede almacenar sin tener que reservar ms memoria. La funcin reserve() es una optimizacin del mecanismo que indica su intencin de especicar cierta cantidad de memoria para un futuro uso; capacity() siempre retorna un valor al menos tan largo como la ultima llamada a reserve(). La funcin resize() aade espacio si el nuevo tamao es mayor que el tamao actual del string; sino trunca el string. (Una sobrecarga de resize() puede especicar una adicin diferente de caracteres). 64 i i i i
i i
4.2. Operaciones con cadenas La manera exacta en que las funciones miembro de string reservan espacio para sus datos depende de la implementacin de la librera. Cuando testeamos una implementacin con el ejemplo anterior, parece que se hacia una reserva de una palabra de memoria (esto es, un entero) dejando un byte en blanco entre cada una de ellas. Los arquitectos de la clase string se esforzaron para poder mezclar el uso de las cadenas de caracteres de C y los objetos string, por lo que es probable por lo que se puede observar en StrSize.cpp, en esta implementacin en particular, el byte est aadido para acomodar fcilmente la insercin de un terminador nulo.
Tag es insertada en s (notese que la insercin ocurre antes de que el valor indicando el punto de insercin y de que el espacio extra haya sido aadido despues de Tag), y entonces es encontrada y reemplazada. Debera cerciorarse de que ha encontrado algo antes de realizar el replace(). En los ejemplos anteriores se reemplaza con un char*, pero existe una versin sobrecargada que reemplaza con un string. Aqui hay un ejempl ms completo de demostracin de replace():
//: C03:Replace.cpp #include <cassert>
65 i i i i
i i
Si replace() no encuentra la cadena buscada, retorna un string::npos. El dato miembro npos es una constante estatica de la clase string que representa una posicin de carcter que no existe[33]. 3 A diferencia de insert(), replace() no aumentar el espacio de alamcenamiento de string si copia nuevos caracteres en el medio de una serie de elementos de array existentes. Sin embargo, s que cerecer su espacio si es necesario, por ejemplo, cuando hace un "reemplazamiento" que pueda expandir el string ms all del nal de la memoria reservada actual. Aqu un ejemplo:
//: C03:ReplaceAndGrow.cpp #include <cassert> #include <string> using namespace std; int main() { string bigNews("I have been working the grave."); string replacement("yard shift."); // The first argument says "replace chars // beyond the end of the existing string": bigNews.replace(bigNews.size() - 1, replacement.size(), replacement); assert(bigNews == "I have been working the " "graveyard shift."); } ///:~
3 Es una abrviacin de "no position", y su valor ms alto puede ser representado por el ubicador de string size_type (std::size_t por defecto).
66 i i i i
i i
4.2. Operaciones con cadenas La llamada a replace() empieza "reemplazando" ms all del nal del array existente, que es equivalente a la operacin append(). Ntese que en este ejemplo replace() expande el array coherentemente. Puede que haya estado buscando a travs del captulo; intentando hacer algo relativamente fcil como reemplazar todas las ocurrencias de un carcter con diferentes caracteres. Al buscar el material previo sobre reemplazar, puede que haya encontrado la respuesta, pero entonces ha empezaro viendo grupos de caracteres y contadores y otras cosas que parecen un poco demasiado complejas. No tiene string una manera para reemplazar un carcter con otro simplemente? Puede escribir fcilmente cada funcin usando las funciones miembro find() y replace() como se muestra acontinuacion.
//: C03:ReplaceAll.h #ifndef REPLACEALL_H #define REPLACEALL_H #include <string> std::string& replaceAll(std::string& context, const std::string& from, const std::string& to); #endif // REPLACEALL_H ///:~
//: C03:ReplaceAll.cpp {O} #include <cstddef> #include "ReplaceAll.h" using namespace std; string& replaceAll(string& context, const string& from, const string& to) { size_t lookHere = 0; size_t foundHere; while((foundHere = context.find(from, lookHere)) != string::npos) { context.replace(foundHere, from.size(), to); lookHere = foundHere + to.size(); } return context; } ///:~
La versin de find() usada aqu toma como segundo argumento la posicin donde empezar a buscar y retorna string::npos si no lo encuentra. Es importante avanzar en la posicin contenida por la variable lookHere pasada como subcadena, en caso de que from es una subcadena de to. El siguiente programa comprueba la funcion replaceAll():
//: C03:ReplaceAllTest.cpp //{L} ReplaceAll #include <cassert> #include <iostream> #include <string> #include "ReplaceAll.h" using namespace std;
67 i i i i
i i
Como puede comprobar, la clase string por ella sola no resuelve todos los posibles problemas. Muchas soluciones se han dejado en los algoritmos de la librera estndar4 por que la clase string puede parece justamente como una secuencia STL(gracias a los iteradores descritos antes). Todos los algoritmos genricos funcionan en un "rango" de elementos dentro de un contenedor. Generalmente este rango es justamente desde el principio del contenedor hasta el nal. Un objeto string se parece a un contenedor de caracteres: para obtener el principio de este rango use string::begin(), y para obtener el nal del rango use string::end(). El siguiente ejemplomuestra el uso del algoritmo replace() para reemplazar todas las instancias de un determinado carcter "X" con "Y"
//: C03:StringCharReplace.cpp #include <algorithm> #include <cassert> #include <string> using namespace std; int main() { string s("aaaXaaaXXaaXXXaXXXXaaa"); replace(s.begin(), s.end(), X, Y); assert(s == "aaaYaaaYYaaYYYaYYYYaaa"); } ///:~
Ntese que esta funcin replace() no es llamada como funcin miembro de string. Adems, a diferencia de la funcin string::replace(), que solo realiza un reemplazo, el algoritmo replace() reemplaza todas las instancias de un carcter con otro. El algoritmo replace() solo funciona con objetos individuales (en este caso, objetos char) y no reemplazar arreglos constantes o objetos string. Desde que un string se copmporta como una secuencia STL, un conjunto de algoritmos pueden serle aplicados, que resolvern otros problemas que las funciones miembro de string no resuelven.
68 i i i i
i i
Usar los operadores operator+ y operator+= es una manera exible y conveniente de combinar los datos de las cadenas. En la parte derecha de la sentencia, puede usar casi cualquier tipo que evale a un grupo de uno o ms caracteres.
i i
Captulo 4. Las cadenas a fondo Busca en un string, desde el nal hasta el origen, un carcter o grupo de caracteres y retorna la posicin inicial de la ocurrencia si se ha encontrado alguna. Si no encuentra ocurrencias, retorna npos. El uso ms simple de find(), busca uno o ms caracteres en un string. La versin sobrecargada de find() toma un parmetro que especica el/los carcter(es) que buscar y opcionalmente un parmetro que dice donde empezar a buscar en el string la primera ocurrencia. (Por defecto la posicin de incio es 0). Insertando la llamada a la funcin find() dentro de un bucle puede buscar fcilmente todas las ocurrencias de un carcter dado o un grupo de caracteres dentro de un string. El siguiente programa usa el mtodo del Tamiz de Eratostenes para hallar los nmeros primos menores de 50. Este mtodo empieza con el nmero 2, marca todos los subsecuentes mltiplos de 2 ya que no son primos, y repite el proceso para el siguiente candidato a primo. El constructor de sieveTest inicializa sieveChars poniendo el tamao inicial del arreglo de carcter y escribiendo el valor P para cada miembro.
//: C03:Sieve.h #ifndef SIEVE_H #define SIEVE_H #include <cmath> #include <cstddef> #include <string> #include "../TestSuite/Test.h" using std::size_t; using std::sqrt; using std::string; class SieveTest : public TestSuite::Test { string sieveChars; public: // Create a 50 char string and set each // element to P for Prime: SieveTest() : sieveChars(50, P) {} void run() { findPrimes(); testPrimes(); } bool isPrime(int p) { if(p == 0 || p == 1) return false; int root = int(sqrt(double(p))); for(int i = 2; i <= root; ++i) if(p % i == 0) return false; return true; } void findPrimes() { // By definition neither 0 nor 1 is prime. // Change these elements to "N" for Not Prime: sieveChars.replace(0, 2, "NN"); // Walk through the array: size_t sieveSize = sieveChars.size(); int root = int(sqrt(double(sieveSize))); for(int i = 2; i <= root; ++i) // Find all the multiples: for(size_t factor = 2; factor * i < sieveSize; ++factor) sieveChars[factor * i] = N;
70 i i i i
i i
//: C03:Sieve.cpp //{L} ../TestSuite/Test #include "Sieve.h" int main() { SieveTest t; t.run(); return t.report(); } ///:~
La funcin find() puede recorrer el string, detectando mltiples ocurrencias de un carcter o un grupo de caracteres, y find_first_not_of() encuentra otros caracteres o subcadenas. No existen funciones en la clase string para cambiar entre maysculas/minsculas en una cadena, pero puede crear esa funcin fcilmente usando la funcin de la libreria estndar de C toupper() y tolower(), que cambian los caracteres entre maysculas/minsculas de uno en uno. El ejemplo siguiente ilustra una bsqueda sensible a maysculas/minsculas.
//: C03:Find.h #ifndef FIND_H #define FIND_H #include <cctype> #include <cstddef> #include <string> #include "../TestSuite/Test.h" using std::size_t; using std::string; using std::tolower; using std::toupper; // Make an uppercase copy of s inline string upperCase(const string& s) { string upper(s); for(size_t i = 0; i < s.length(); ++i) upper[i] = toupper(upper[i]); return upper;
71 i i i i
i i
72 i i i i
i i
Tanto las funciones upperCase() como lowerCase() siguen la misma forma: hacen una copia de la cadena argumento y cambian entre maysculas/minsculas. El programa Find.cpp no es la mejor solucin para el problema para las maysculas/minsculas, por lo que lo revisitaremos cuando examinemos la comparacin entre cadenas.
73 i i i i
i i
//: C03:Rparse.cpp //{L} ../TestSuite/Test #include "Rparse.h" int main() { RparseTest t; t.run(); return t.report(); } ///:~
La funcin miembro de string rfind() vuelve por la cadena buscando elementos y reporta el indice del arreglo de las coincidencias de caracteres o string::npos si no tiene xito.
74 i i i i
i i
La primera prueba checkea si el string esta vaco; en ese caso, ya no se realizan ms test, y se retorna una copia. Ntese que una vez los puntos del nal son encontrados, el constructor de string construye un nuevo string desde el viejo, dndole el contador incial y la longitud. Las pruebas de una herramienta tan general den ser cuidadosas
//: C03:TrimTest.h #ifndef TRIMTEST_H #define TRIMTEST_H #include "Trim.h" #include "../TestSuite/Test.h" class TrimTest : public TestSuite::Test { enum {NTESTS = 11}; static std::string s[NTESTS]; public: void testTrim() { test_(trim(s[0]) == "abcdefghijklmnop"); test_(trim(s[1]) == "abcdefghijklmnop"); test_(trim(s[2]) == "abcdefghijklmnop"); test_(trim(s[3]) == "a"); test_(trim(s[4]) == "ab"); test_(trim(s[5]) == "abc"); test_(trim(s[6]) == "a b c"); test_(trim(s[7]) == "a b c"); test_(trim(s[8]) == "a \t b \t c"); test_(trim(s[9]) == ""); test_(trim(s[10]) == ""); } void run() { testTrim(); } }; #endif // TRIMTEST_H ///:~
75 i i i i
i i
// Initialize static data std::string TrimTest::s[TrimTest::NTESTS] = { " \t abcdefghijklmnop \t ", "abcdefghijklmnop \t ", " \t abcdefghijklmnop", "a", "ab", "abc", "a b c", " \t a b c \t ", " \t a \t b \t c \t ", "\t \n \r \v \f", "" // Must also test the empty string }; ///:~
//: C03:TrimTestMain.cpp //{L} ../TestSuite/Test TrimTest #include "TrimTest.h" int main() { TrimTest t; t.run(); return t.report(); } ///:~
En el arrglo de string, puede ver que los arreglos de carcter son automticamente convertidos a objetos string. Este arreglo provee casos para checkear el borrado de espacios en blanco y tabuladores en los extremos, adems de asegurar que los espacios y tabuladores no son borrados de la mitad de un string.
76 i i i i
i i
77 i i i i
i i
Captulo 4. Las cadenas a fondo Este ejemplo borrar incluso las etiquetas HTML que se extienden a lo largo de varias lneas.5 Esto se cumple gracias a la bandera esttica inTag, que evala a cierto si el principio de una etiqueta es encontrada, pero la etiqueta de nalizacin correspondiente no es encontrada en la misma lnea. Todas la formas de erase() aparecen en la funcin stripHTMLFlags().6 La versin de getline() que usamos aqu es una funcin (global) declarada en la cabecera de string y es til porque guarda una lnea arbitrariamente larga en su argumento string. No necesita preocuparse de las dimensiones de un arreglo cuando trabaja con istream::getline(). Ntese que este programa usa la funcin replaceAll() vista antes en este captulo. En el pximo capitulo, usaremos los ujos de cadena para crear una solucin ms elegante.
Para mantener la exposicin simple, esta version no maneja etiquetas anidadas, como los comenta-
rios.
6 Es tentador usar aqu las matemticas para evitar algunas llamadas a erase(), pero como en algunos casos uno de los operandos es string::npos (el entero sin signo ms grande posible), ocurre un desbordamiento del entero y se cuelga el algoritmo.
78 i i i i
i i
//: C03:CompStr.cpp //{L} ../TestSuite/Test #include "CompStr.h" int main() { CompStrTest t; t.run(); return t.report(); } ///:~
Los operadores de comaracin sobrecargados son tiles para comparar dos cadenas completas y elementos individuales de una cadena de caracteres. Ntese en el siguiente ejemplo la exibilidad de los tipos de argumento ambos lados de los operadores de comparacin. Por eciencia, la clase string provee operadores sobrecargados para la comparacin directa de objetos string, literales de cadena, y punteros a cadenas estilo C sin tener que crear objetos string temporales.
//: C03:Equivalence.cpp #include <iostream> #include <string> using namespace std; int main() { string s2("That"), s1("This"); // The lvalue is a quoted literal // and the rvalue is a string: if("That" == s2) cout << "A match" << endl; // The left operand is a string and the right is // a pointer to a C-style null terminated string: if(s1 != s2.c_str()) cout << "No match" << endl; } ///:~
La funcin c_str() retorna un const char* que apunta a una cadena estilo C terminada en nulo, equivalente en contenidos al objeto string. Esto se vuelve muy til cuando se quiere pasar un strin a una funcin C, como atoi() o cualquiera de las funciones denidas en la cabecera cstring. Es un error usar el valor retornado por c_str() como un argumento constante en cualquier funcin. No encontrar el operador not (!) o los operadores de comparacin lgicos (&& y ||) entre los operadore para string. (No encontrar ninguna versin sobrecar79 i i i i
i i
Captulo 4. Las cadenas a fondo gada de los operadores de bits de C: &, |, , o ~.) Los operadores de conversin no miembros sobrecargados para la clases string estn limitados a un subconjunto que tiene una aplicacin clara y no ambigua para caracteres individuales o grupos de caracteres. La funcin miembro compare() le ofrece un gran modo de comparacin ms sosticado y preciso que el conjunto de operadores nomiembro. Provee versiones sobrecargadas para comparar: Dos string completos Parte de un string con un string completo Partes de dos string
//: C03:Compare.cpp // Demonstrates compare() and swap(). #include <cassert> #include <string> using namespace std; int main() { string first("This"); string second("That"); assert(first.compare(first) == 0); assert(second.compare(second) == 0); // Which is lexically greater? assert(first.compare(second) > 0); assert(second.compare(first) < 0); first.swap(second); assert(first.compare(second) < 0); assert(second.compare(first) > 0); } ///:~
La funcin swap() en este ejemplo hace lo que su nombre implica: cambia el contenido del objeto por el del parmetro. Para comparar un subconjunto de caracteres en un o ambos string, aada argumentos que denen donde empezar y cuantos caracteres considerar. Por ejemplo, puede usar las siguientes versiones sobrecargadas de compare(): s1.compare(s1StartPos, s1NumberChars, s2, s2StartPos, s2NumberChars); Aqui un ejemplo:
//: C03:Compare2.cpp // Illustrate overloaded compare(). #include <cassert> #include <string> using namespace std; int main() { string first("This is a day that will live in infamy"); string second("I dont believe that this is what " "I signed up for"); // Compare "his is" in both strings:
80 i i i i
i i
Hasta ahora, en los ejemplos, hemos usado la sintaxis de indexacin de arrays estilo C para referirnos a un carcter individual en un string. C++ provee de una alternativa a la notacin s[n]: el miembro at(). Estos dos mecanismos de indexacin producen los mismos resultados si todo va bien:
//: C03:StringIndexing.cpp #include <cassert> #include <string> using namespace std; int main() { string s("1234"); assert(s[1] == 2); assert(s.at(1) == 2); } ///:~
Sin embargo, existe una importante diferencia entre [ ] y at() . Cuando usted intenta referenciar el elemento de un arreglo que esta fuera de sus lmites, at() tiene la delicadeza de lanzar una excepcin, mientras que ordinariamente [ ] le dejar a su suerte.
//: C03:BadStringIndexing.cpp #include <exception> #include <iostream> #include <string> using namespace std; int main() { string s("1234"); // at() saves you by throwing an exception: try { s.at(5); } catch(exception& e) { cerr << e.what() << endl; } } ///:~
Los programadores responsables no usarn ndices errticos, pero puede que quiera beneciarse de la comprobacin automtica de indices, usandoat() en el lugar de [ ] le da la oportunidad de recuperar diligentemente de las referencias a elementos de un arreglo que no existen. La ejecucin de sobre uno de nuestros compiladores le da la siguiente salida: "invalid string position" La funcin miembro at() lanza un objeto de clase out_of_class, que deriva nalmente de std::exception. Capturando este objeto en un manejador de excepciones, puede tomar las medidas adecuadas como recalcular el ndice incorrecto o hacer crecer el arreglo. Usar string::operator[]( ) no proporciona ningn 81 i i i i
i i
Captulo 4. Las cadenas a fondo tipo de proteccin y es tan peligroso como el procesado de arreglos de caracteres en C.[37] 7
82 i i i i
i i
4.3. Buscar en cadenas individual de las funciones miembro de comparacin carcteres. Puede usar esta informacin para hacer un nuevo tipo de string que ignora las maysculas/minsculas. Primero, deniremos una nueva plantilla no sensible a maysculas/minsculas de char_traits< > que hereda de una plantilla existente. Luego, sobrescribiremos slo los miembros que necesitamos cambiar para hacer la comparacin carcter por carcter. (Adems de los tres miembros de comparacin lxica mencionados antes, daremos una nueva implementacin para laspara las funciones de char_traits find() y compare()). Finalmente, haremos un typedef de una nueva clase basada en basic_string, pero usando nuestra plantilla insensible a maysculas/minsculas, ichar_traits, como segundo argumento:
//: C03:ichar_traits.h // Creating your own character traits. #ifndef ICHAR_TRAITS_H #define ICHAR_TRAITS_H #include <cassert> #include <cctype> #include <cmath> #include <cstddef> #include <ostream> #include <string> using std::allocator; using std::basic_string; using std::char_traits; using std::ostream; using std::size_t; using std::string; using std::toupper; using std::tolower; struct ichar_traits : char_traits<char> { // Well only change character-by// character comparison functions static bool eq(char c1st, char c2nd) { return toupper(c1st) == toupper(c2nd); } static bool ne(char c1st, char c2nd) { return !eq(c1st, c2nd); } static bool lt(char c1st, char c2nd) { return toupper(c1st) < toupper(c2nd); } static int compare(const char* str1, const char* str2, size_t n) { for(size_t i = 0; i < n; ++i) { if(str1 == 0) return -1; else if(str2 == 0) return 1; else if(tolower(*str1) < tolower(*str2)) return -1; else if(tolower(*str1) > tolower(*str2)) return 1; assert(tolower(*str1) == tolower(*str2)); ++str1; ++str2; // Compare the other chars } return 0;
83 i i i i
i i
Proporcionamos un typedef llamado istring ya que nuestra clase actuar como un string ordinario en todas sus formas, excepto que realizar todas las comparaciones sin respetar las maysculas/minsculas. Por conveniencia, damos un operador sobrecargado operator<<() para que pueda imprimir los istring. Aque hay un ejemplo:
//: C03:ICompare.cpp #include <cassert> #include <iostream> #include "ichar_traits.h" using namespace std; int main() { // The same letters except for case: istring first = "tHis"; istring second = "ThIS"; cout << first << endl; cout << second << endl; assert(first.compare(second) == 0); assert(first.find(h) == 1); assert(first.find(I) == 2); assert(first.find(x) == string::npos); } ///:~
Este es solo un ejemplo de prueba. Para hacer istring completamente equivalente a un string, deberiamos haber creado las otras funciones necesarias para soportar el nuevo tipo istring. La cabecera <string> provee de un string ancho 8 gracias al siguiente typedef: typedef basic_string<wchar_t> wstring; El soporte para string ancho se revela tambien en los streams anchos (wost8 (N.del T.) Se reere a string amplio puesto que esta formado por caracteres anchos wchar_t que deben soportar la codicacin mas grande que soporte el compilador. Casi siempre esta codicacin es Unicode, por lo que casi siempre el ancho de wchar_t es 2 bytes
84 i i i i
i i
4.3. Buscar en cadenas ream en lugar de ostream, tambien denido en <iostream>) y en la especializacin de wchar_t de los char_traits en la libreria estndar le da la posibilidad de hacer una version de carcter ancho de ichar_traits
//: C03:iwchar_traits.h {-g++} // Creating your own wide-character traits. #ifndef IWCHAR_TRAITS_H #define IWCHAR_TRAITS_H #include <cassert> #include <cmath> #include <cstddef> #include <cwctype> #include <ostream> #include <string> using using using using using using using using std::allocator; std::basic_string; std::char_traits; std::size_t; std::towlower; std::towupper; std::wostream; std::wstring;
struct iwchar_traits : char_traits<wchar_t> { // Well only change character-by// character comparison functions static bool eq(wchar_t c1st, wchar_t c2nd) { return towupper(c1st) == towupper(c2nd); } static bool ne(wchar_t c1st, wchar_t c2nd) { return towupper(c1st) != towupper(c2nd); } static bool lt(wchar_t c1st, wchar_t c2nd) { return towupper(c1st) < towupper(c2nd); } static int compare( const wchar_t* str1, const wchar_t* str2, size_t n) { for(size_t i = 0; i < n; i++) { if(str1 == 0) return -1; else if(str2 == 0) return 1; else if(towlower(*str1) < towlower(*str2)) return -1; else if(towlower(*str1) > towlower(*str2)) return 1; assert(towlower(*str1) == towlower(*str2)); ++str1; ++str2; // Compare the other wchar_ts } return 0; } static const wchar_t* find(const wchar_t* s1, size_t n, wchar_t c) { while(n-- > 0) if(towupper(*s1) == towupper(c)) return s1; else
85 i i i i
i i
Como puede ver, esto es principalmente un ejercicio de poner w en el lugar adecuado del cdigo fuente. El programa de prueba podria ser asi:
//: C03:IWCompare.cpp {-g++} #include <cassert> #include <iostream> #include "iwchar_traits.h" using namespace std; int main() { // The same letters except for case: iwstring wfirst = L"tHis"; iwstring wsecond = L"ThIS"; wcout << wfirst << endl; wcout << wsecond << endl; assert(wfirst.compare(wsecond) == 0); assert(wfirst.find(h) == 1); assert(wfirst.find(I) == 2); assert(wfirst.find(x) == wstring::npos); } ///:~
Desgraciadamente, todavia algunos compiladores siguen sin ofrecer un soporte robusto para caracteres anchos.
i i
4.4. Una aplicacin con cadenas tradas en un chero (solo es para cheros solo de datos). (Si se est preguntando por que evitamos mostrar estos elementos, es por que no queremos romper el extractor de cdigo cuando lo aplicamos al texto del libro!). El programa en Python de Bruce hace muchas ms cosas que simplemente extraer el cdigo. Si el elemento "{O}" sigue al nombre del chero, su entrada en el makele solo ser congurada para compilar y no para enlazarla en un ejecutable. (El Test Framework en el Captulo 2 est contruida de esta manera). Para enlazar un chero con otro fuente de ejemplo, el chero fuente del ejecutable objetivo contendr una directiva "{L}", como aqu: //{L} ../TestSuite/Test Esta seccin le presentar un programa para extraer todo el cdigo para que pueda compilarlo e inspeccionarlo manualmente. Puede usar este programa para extraer todo el codigo de este libro salvando el chero como un chero de texto9 (llammosle TICV2.txt)y ejecutando algo como la siguiente lnea de comandos: C:> extractCode TICV2.txt /TheCode Este comando lee el chero de texto TICV2.txt y escribe todos los archivos de cdigo fuente en subdirectorios bajo el denido /TheCode. El arbol de directorios se mostrar como sigue: TheCode/ C0B/ C01/ C02/ C03/ C04/ C05/ C06/ C07/ C08/ C09/ C10/ C11/ TestSuite/ Los cheros de cdigo fuente que contienen los ejemplos de cada captulo estarn en el correspondiente directorio. Aqu est el programa:
//: C03:ExtractCode.cpp {-edg} {RunByHand} // Extracts code from text. #include <cassert> #include <cstddef> #include <cstdio> #include <cstdlib> #include <fstream> #include <iostream> #include <string> using namespace std; // Legacy non-standard C header for mkdir() #if defined(__GNUC__) || defined(__MWERKS__) #include <sys/stat.h> #elif defined(__BORLANDC__) || defined(_MSC_VER) \ || defined(__DMC__) #include <direct.h> #else #error Compiler not supported #endif // Check to see if directory exists // by attempting to open a new file // for output within it. bool exists(string fname) {
9 Est alerta porque algunas versiones de Microsoft Word que substituyen erroneamente los caracteres con comilla simple con un carcter ASCII cuando salva el documento como texto, causan un error de compilacin. No tenemos idea de porqu pasa esto. Simplemente reemplace el carcter manualmente con un apstrofe.
87 i i i i
i i
88 i i i i
i i
89 i i i i
i i
Primero observar algunas directivas de compilacin condicionales. La funcin mkdir(), que crea un directorio en el sistema de cheros, se dene por el estndar POSIX10 en la cabecera (<direct.h>). La respectiva signatura de mkdir() tambin diere: POSIX especica dos argumentos, las viejas versiones slo uno. Por esta razn, existe ms de una directiva de compilacin condicional despus en el programa para elegir la llamada correcta a mkdir(). Normalmente no usamos compilaciones condicionales en los ejemplos de este libro, pero en este programa en particular es demasiado til para no poner un poco de trabajo extra dentro, ya que puede usarse para extraer todo el cdigo con l. La funcin exists() en ExtractCode.cpp prueba que un directorio existe abriendo un echero temporal en l. Si la obertura falla, el directorio no existe. Borre el chero enviando su nombre como unchar* a std::remove(). El programa principal valida los argumentos de la lnea de comandos y despus lee el chero de entrada lnea por lnea, mirando por los delimitadores especiales de cdigo fuente. La bandera booleana inCode indica que el programa esta en el medio de un chero fuente, as que las lineas deben ser extradas. La bandera printDelims ser verdadero si el elemento de obertura no est seguido de un signo de exclamancin; si no la primera y la ltima lnea no son escritas. Es importante comprobar el ltimo delimitador primero, por que el elemnto inicial es un subconjuntom y buscando por el elemento inicial debera retornar cierto en ambos casos. Si encontramos el elemento nal, vericamos que estamos en el medio del procesamiento de un chero fuente; sino, algo va mal con la manera en que los delimitadores han sido colocados en el chero de texto. Si inCode es verdadero, todo est bien, y escribiremos (opcionalmente) la ltima linea y cerraremos el chero. Cuando el elemento de obertura se encuentra, procesamos el directorio y el nombre del chero y abrimos el chero. Las siguientes funciones relacionadas con string fueron usadas en este ejemplo: length( ), append( ), getline( ), find( ) (dos versiones), find_first_not_of( ), substr( ),find_first_of( ), c_str( ), y, por supuesto, operator<<( )
4.5. Resumen
Los objetos string proporcionan a los desarrolladores un gran nmero de ventajas sobre sus contrapartidas en C. La mayoria de veces, la clase string hacen a las cadenas con punteros a caracteres innecesarios. Esto elimina por completo una clase de defectos de software que radican en el uso de punteros no inicializados o con valores incorrectos. FIXME: Los string de C++, de manera transparente y dinmica, hacen crecer el espacio de alamcenamiento para acomodar los cambios de tamao de los datos de la cadena. Cuando los datos en n string crece por encima de los lmites de la memoria asignada inicialmente para ello, el objeto string har las llamadas para la gestin de la memoria para obtener el espacio y retornar el espacio al montn. La gestin consistente de la memoria previente lagunas de memoria y tiene el potencial de ser mucho ms eciente que un "hgalo usted mismo".
10 POSIX, un estndar IEEE, es un "Portable Operating System Interface" (Intercie de Sistema Operativo Portable) y es una generalizacin de muchas de las llamadas a sistema de bajo nivel encontradas en los sistemas UNIX.
90 i i i i
i i 4.6. Ejercicios Las funciones de la clase string proporcionan un sencillo y comprensivo conjunto de herramientas para crear, modicar y buscar en cadenas. Las comparaciones entre string siempre son sensibles a maysculas/minsculas, pero usted puede solucionar el problema copiando los datos a una cadena estilo C acabada en nulo y usando funciones no sensibles a maysculas/minsculas, convirtiendo temporalmente los datos contenidos a maysculas o minsculas, o creando una clase string sensible que sobreescribe los rasgos de carcter usados para crear un objeto basic_string
4.6. Ejercicios
Las soluciones a los ejercicios se pueden encontrar en el documento electrnico titulado The Thinking in C++ Annotated Solution Guide, disponible por poco dinero en www.BruceEckel.com. 1. Escriba y pruebe una funcin que invierta el orden de los caracteres en una cadena. 2. 2. Un palindromo es una palabra o grupo de palabras que tanto hacia delante hacia atrs se leen igual. Por ejemplo "madam" o "wow". Escriba un programa que tome un string como argumento desde la lnea de comandos y, usando la funcin del ejercicio anterior, escriba si el string es un palndromo o no. 3. 3. Haga que el programa del Ejercicio 2 retorne verdadero incluso si las letras simetricas dieren en maysculas/minsculas. Por ejemplo, "Civic" debera retornar verdadero aunque la primera letra sea mayscula. 4. 4. Cambie el programa del Ejercicio 3 para ignorar la puntuacin y los espacios tambin. Por ejemplo "Able was I, ere I saw Elba." debera retornar verdadero. 5. 5. Usando las siguientes declaraciones de string y solo char (no literales de cadena o nmeros mgicos): string one("I walked down the canyon with the moving mountain bikers."); string two("The bikers passed by me too close for comfort."); string three("I went hiking instead."); produzca la siguiente frase: I moved down the canyon with the mountain bikers. The mountain bikers passed by me too close for comfort. So I went hiking instead. 6. 6. Escriba un programa llamado "reemplazo" que tome tres argumentos de la lnea de comandos representando un chero de texto de entrada, una frase para reemplazar (llmela from), y una cadena de reemplazo (llmela to). El programa debera escribir un nuevo chero en la salida estandar con todas las ocurrencias de from reemplazadas por to. 7. 7. Repetir el ejercicio anterior pero reemplazando todas las instancias pero ignorando las maysculas/minsculas. 8. 8. Haga su programa a partir del Ejercicio 3 tomando un nombre de chero de la linea de comandos, y despues mostrando todas las palabras que son palndromos (ignorando las maysculas/minsculas) en el chero. No intente buscar palabras para palndromos que son mas largos que una palabra (a diferencia del ejercicio 4). 91 i i i i
i i
Captulo 4. Las cadenas a fondo 9. 9. Modique HTMLStripper.cpp para que cuando encuentre una etiqueta, muestre el nombre de la etiqueta, entonces muestre el contenido del chero entre la etiqueta y la etiqueta de nalizacin de chero. Asuma que no existen etiquetas anidadas, y que todas las etiquetas tienen etiquetas de nalizacion (denotadas con </TAGNAME>). 10. 10. Escriba un programa que tome tres argumentos de la lnea de comandos (un nombre de chero y dos cadenas) y muestre en la consola todas la lneas en el chero que tengan las dos cadenas en la lnea, alguna cadena, solo una cadena o ninguna de ellas, basndose en la entreada de un usuario al principio del programa (el usuario elegir que modo de bsqueda usar). Para todo excepto para la opcin "ninguna cadena", destaque la cadena(s) de entrada colocando un asterisco (*) al principio y al nal de cada cadena que coincida cuando sea mostrada. 11. 11. Escriba un programa que tome dos argumentos de la linea de comandos (un nombre de chero y una cadena) y cuente el numero de veces que la cadena esta en el chero, incluso si es una subcadena (pero ignorando los solapamientos). Por ejemplo, una cadena de entrada de "ba" debera coincidir dos veces en la palabra "basquetball", pero la cadena de entrada "ana" solo deberia coincidir una vez en "banana". Muestre por la consola el nmero de veces que la cadena coincide en el chero, igual que la longitud media de las palabras donde la cadena coincide. (Si la cadena coincide ms de una vez en una palabra, cuente solamente la palabra una vez en el clculo de la media). 12. 12. Escriba un programa que tome un nombre de chero de la lnea de comandos y perle el uso del carcter, incluyendo la puntuacin y los espacios (todos los valores de caracteres desde el 0x21 [33] hasta el 0x7E [126], adems del carcter de espacio). Esto es, cuente el numero de ocurrencias para cada carcter en el chero, despus muestre los resultados ordenados secuencialmente (espacio, despues !, ", #, etc.) o por frecuencia descendente o ascendente basado en una entrada de usuario al principio del programa. Para el espacio, muestre la palabra "espacio" en vez del carcter . Una ejecucin de ejemplo debe mostrarse como esto: Formato secuencial, ascendente o descendente (S/A/D): D t: 526 r: 490 etc. 13. 13. Usando find() y rfind(), escriba un programa que tome dos argumentos de lnea de comandos (un nombre de chero y una cadena) y muestre la primera y la ltima palapra (y sus indices) que no coinciden con la cadena, asi como los indice de la primera y la ltima instancia de la cadena. Muestre "No Encontrado" si alguna de las busquedas fallan. 14. 14. Usando la familia de fuciones find_first_of (pero no exclusivamente), escriba un programa que borrar todos los caracteres no alfanumricos excepto los espacios y los puntos de un chero. Despues convierta a maysculas la primera letra que siga a un punto. 15. 15. Otra vez, usando la familia de funciones find_first_of, escriba un programa que acepte un nombre de chero como argumentod elinea de comandos y despus formatee todos los nmeros en un chero de moneda. Ignore los puntos decimales despus del primero despues de un carcter no mumrico, e redondee al 16. 16. Escriba un programa que acepte dos argumentos por lnea de comandos (un nombre de chero y un numero) y mezcle cada paralabra en el chero cambiando aleatoriamente dos de sus letras el nmero de veces especicado 92 i i i i
i i 4.6. Ejercicios en el segundo parametro. (Esto es, si le pasamos 0 a su programa desde la lnea de comandos, las palabras no sern mezcladas; si le pasamos un 1, un par de letras aleatoriamente elegidas deben ser cambiadas, para una entrada de 2, dos parejas aleatorias deben ser intercambiadas, etc.). 17. 17. Escriba un programa que acepte un nombre de chero desde la lnea de comandos y muestre el numero de frases (denido como el numero de puntos en el chero), el nmero medio de caracteres por frase, y el nmero total de caracteres en el chero.
93 i i i i
i i
i i i
i i
5: Iostreams
Puedes hacer mucho ms con el problema general de E/S que simplemente coger el E/S estndar y convertirlo en una clase.
No seria genial si pudiera hacer que todos los receptculos -E/S estndar, cheros, e incluso boques de memoria- parecieran iguales de manera que solo tuviera que recordar una intercie? Esta es la idea que hay detrs de los iostreams. Son mucho ms sencillos, seguros, y a veces incluso ms ecientes que el conjunto de funciones de la libreria estndar de C stdio. Las clases de iostream son generalmente la primera parte de la libreria de C++ que los nuevos programadores de C++ parender a usar. En este captulo se discute sobre las mejoras que representan los iostream sobre las funciones de stdio de C y explora el comprotamiento de los cheros y streams de strings adems de los streams de consola.
95 i i i i
i i
Captulo 5. Iostreams
#endif // FILECLASS_H ///:~
Cuando trabaja con cheros E/S en C, usted trabaja con punteros desnudos a una struct de FILE, pero esta clase envuelve los punteros y garantiza que es correctamente inicializada y destruida usando el constructor y el destructor. El segundo parmetro del constructor es el modo del chero, que por defecto es r para leer Para pedir el valor del puntero para usarlo en las funciones de chero de E/S, use la funcin de acceso fp(). Aqu estn las deniciones de las funciones miembro:
//: C04:FileClass.cpp {O} // FileClass Implementation. #include "FileClass.h" #include <cstdlib> #include <cstdio> using namespace std; FileClass::FileClass(const char* fname, const char* mode) { if((f = fopen(fname, mode)) == 0) throw FileClassError("Error opening file"); } FileClass::~FileClass() { fclose(f); } FILE* FileClass::fp() { return f; } ///:~
El constructor llama a fopen(), tal como se hara normalmente, pero adems se asegura que el resultado no es cero, que indica un error al abrir el chero. Si el chero no se abre correctamente, se lanza una excepcin. El destructor cierra el chero, y la funcin de acceso fp() retorna f. Este es un ejemplo de uso de FileClass:
//: C04:FileClassTest.cpp //{L} FileClass #include <cstdlib> #include <iostream> #include "FileClass.h" using namespace std; int main() { try { FileClass f("FileClassTest.cpp"); const int BSIZE = 100; char buf[BSIZE]; while(fgets(buf, BSIZE, f.fp())) fputs(buf, stdout); } catch(FileClass::FileClassError& e) { cout << e.what() << endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } // File automatically closed by destructor ///:~
96 i i i i
i i
Se crea el objeto FileClass y se usa en llamadas a funciones E/S de chero normal de C, llamando a fp(). Cuando haya acabado con ella, simplemente olvdese; el chero ser cerrado por el destructor al nal del mbito de la variable. Incluso teniendo en cuenta que FILE es un puntero privado, no es particularmente seguro porque fp() lo recupera. Ya que el nico efecto que parece estar garantizado es la inicializacin y la liberacin, por que no hacerlo pblico o usar una struct en su lugar? Ntese que mientras se puede obtener una copia de f usando fp(), no se puede asignar a f -que est completamente bajo el control de la clase. Despus de capturar el puntero retornado por fp(), el programador cliente todava puede asignar a la estructura elementos o incluso cerrarlo, con lo que la seguridad esta en la garanta de un puntero a FILE vlido mas que en el correcto contenido de la estructura. Si quiere completa seguridad, tiene que evitar que el usuario acceda directamente al puntero FILE. Cada una de las versiones de las funciones normales de E/S a cheros deben ser mostradas como miembros de clase para que todo lo que se pueda hacer desde el acercamiento de C est disponible en la clase de C++.
//: C04:Fullwrap.h // Completely hidden file IO. #ifndef FULLWRAP_H #define FULLWRAP_H #include <cstddef> #include <cstdio> #undef getc #undef putc #undef ungetc using std::size_t; using std::fpos_t; class File { std::FILE* f; std::FILE* F(); // Produces checked pointer to f public: File(); // Create object but dont open file File(const char* path, const char* mode = "r"); ~File(); int open(const char* path, const char* mode = "r"); int reopen(const char* path, const char* mode); int getc(); int ungetc(int c); int putc(int c); int puts(const char* s); char* gets(char* s, int n); int printf(const char* format, ...); size_t read(void* ptr, size_t size, size_t n); size_t write(const void* ptr, size_t size, size_t n); int eof(); int close(); int flush(); int seek(long offset, int whence); int getpos(fpos_t* pos); int setpos(const fpos_t* pos); long tell(); void rewind();
97 i i i i
i i
Captulo 5. Iostreams
void setbuf(char* buf); int setvbuf(char* buf, int type, size_t sz); int error(); void clearErr(); }; #endif // FULLWRAP_H ///:~
Esta clase contiene casi todas las funciones de E/S de chero de <cstdio>. (vfprintf() no esta; se implementa en la funcin miembro printf() ) El chero tiene el mismo constructor que en el ejemplo anterior, y tambin tiene un constructor por defecto. El constructor por defecto es importante si se crea un array de objetos File o se usa un objeto File como miembro de otra clase donde la inicializacin no se realiza en el contructor, sino cierto tiempo despus de que el objeto envolvente se cree. El constructor por defecto pone a cero el puntero a FILE privado f. Pero ahora , antes de cualquier referencia a f, el valor debe ser comprobado para asegurarse que no es cero. Esto se consigue con F(), que es privado porque est pensado para ser usado solamente por otras funciones miembro. (No queremos dar acceso directo a usuarios a la estructura de FILE subyacente en esta clase). Este acercamiento no es terrible en ningn sentido. Es bastante funcional, y se puede imaginar haciendo clases similares para la E/S estndar (consola) y para los formateos en el core (leer/escribir un trozo de la memoria en vez de un chero o la consola). Este bloque de cdigo es el interprete en tiempo de ejecucin usado para las listas variables de argumentos. Este es el cdigo que analiza el formato de su cadena en tiempo de ejecucin y recoge e interpreta argumentos desde una lista variable de argumentos. Es un problema por cuatro razones: 1. Incluso si solo se usa una fraccin de la funcionalidad del interprete, se carga todo en el ejecutable. Luego si quiere usar un printf(" %c", x); , usted tendr todo el paquete, incluido las partes que imprimen nmeros en coma otante y cadenas. No hay una opcin estndar para reducir el la cantidad de espacio usado por el programa. 2. Como la interpretacin pasa en tiempo de ejecucin, no se puede evitar un empeoramiento del rendimiento. Esto es frustrante por que toda la informacin est all, en el formato de la cadena, en tiempo de compilacin, pero no se evalua hasta la ejecucin. Por otro lado, si se pudieran analizar los argumentos en el formateo de la cadena durante la compilacin, se podran hacer llamadas directas a funciones que tuvieran el potencial de ser mucho ms rpidas que un interprete en tiempo de ejecucin (aunque la familia de funciones de printf() acostumbran a estar bastante bien optimizadas). 3. Como el formateo de la cadena no se evalua hasta la ejecucin, no se hace una comprobacin de errores al compilar. Probalblemente est familiarizado con este problema si ha intentado buscar errores que provienen del uso de un nmero o tipo de argumentos incorrecto en una sentencia printf(). C++ ayuda mucho a encontrar rpidamente errores durante la compilacin y hacerle la vida ms fcil. Parece una tonteria desechar la seguridad en los tipos de datos para la libreria de E/S, especialmente cuando usamos intensivamente las E/S. 4. Para C++, el ms crucial de los problemas es que la familia de funciones de 98 i i i i
i i
5.2. Iostreams al rescate printf() no es particularmente extensible. Esta realmente diseada para manejar solo los tipos bsicos de datos en C (char, int, oat, double, wchar_t, char*, wchar_t*, y void*) y sus variaciones. Debe estar pensando que cada vez que aade una nueva clase, puede aadir funciones sobrecargadas printf() y scanf() (y sus variaciones para cheros y strings), pero recuerde: las funciones sobrecargadas deben tener diferentes tipos de listas de argumentos, y la familia de funciones de printf() esconde esa informacin en la cadena formateada y su lista variable de argumentos. Para un lenguage como C++, cuya virtud es que se pueden aadir fcilmente nuevos tipos de datos, esta es una restriccin inaceptable.
99 i i i i
i i
Captulo 5. Iostreams
Todas las clases mencionadas antes estan denidas de manera similar. Tambin hay deniciones de tipo para todas las clases de stream usando wchar_t (la anchura de este tipo de carcteres se discute en el Captulo 3) en lugar de char. Miraremos esto al nal de este captulo. La plantilla basic_ios dene funciones comunes para la entrada y la salida, pero depende del tipo de carcter subyacente (no vamos a usarlo mucho). La plantilla basic_istream dene funciones genricas para la entrada y basic_ostream hace lo mismo para la salida. Las clases para cheros y streams de strings introducidas despus aaden funcionalidad para sus tipos especicos de stream. En la librera de iostream, se han sobrecargado dos operadores para simplicar el uso de iostreams. El operador << se denomina frecuentemente instertador para iostreams, y el operador >> se denomina frecuentemente extractor. Los extractores analizan la informacin esperada por su objeto destino de acuerdo con su tipo. Para ver un ejemplo de esto, puede usar el objeto cin, que es el equivalente de iostream de stdin en C, esto es, entrada estndar redireccionable. Este objeto viene predenido cuando usted incluye la cabecera <iostream>.
int i; cin >> i; float f; cin >> f; char c; cin >> c; char buf[100]; cin >> buf;
Existe un operador sobrecargado >> para cada tipo fundamental de dato. Usted tambin puede sobrecargar los suyos, como ver ms adelante. Para recuperar el contenido de las variables, puede usar el objeto cout (correspondiente con la salida estndar; tambin existe un objeto cerr correspondiente con la salida de error estndar) con el insertador <<:
cout cout cout cout cout cout cout cout cout cout cout cout << << << << << << << << << << << << "i = "; i; "\n"; "f = "; f; "\n"; "c = "; c; "\n"; "buf = "; buf; "\n";
Esto es tedioso y no parece ser un gran avance sobre printf(), aparte de la mejora en la comprobacin de tipos. Afortunadamente, los insertadores y extracto100 i i i i
i i
5.2. Iostreams al rescate res sobrecargados estn diseados para ser encadenados dentro de expresiones ms complejas que son mucho ms fciles de escribir (y leer):
cout cout cout cout << << << << "i = "f = "c = "buf " " " = << i << f << c " << << endl; << endl; << endl; buf << endl;
Denir insertadores y extractores para sus propias clases es simplemente una cuestion de sobrecargar los operadores asociados para hacer el trabajo correcto, de la siguente manera: Hacer del primer parmetro una referencia no constante al stream (istream para la entrada, ostream para la salida). Realizar la operacin de insertar/extraer datos hacia/desde el stream (procesando los componentes del objeto). Retornar una referencia al stream El stream no debe ser constante porque el procesado de los datos del stream cambian el estado del stream. Retornando el stream, usted permite el encadenado de operaciones en una sentencia individual, como se mostr antes. Como ejemplo, considere como representar la salida de un objeto Date en formato MM-DD-AAAA . El siguiente insertador hace este trabajo:
ostream& operator<<(ostream& os, const Date& d) { char fillc = os.fill(0); os << setw(2) << d.getMonth() << - << setw(2) << d.getDay() << - << setw(4) << setfill(fillc) << d.getYear(); return os; }
Esta funcin no puede ser miembro de la clase Date por que el operando de la izquierda << debe ser el stream de salida. La funcin miembro fill() de ostream cambia el carcter de relleno usado cuando la anchura del campo de salida, determinada por el manipulador setw(), es mayor que el necesitado por los datos. Usamos un caracter 0 ya que los meses anteriores a Octubre mostrarn un cero en primer lugar, como 09 para Septiembre. La funcion fill() tambin retorna el caracter de relleno anterior (que por defecto es un espacio en blanco) para que podamos recuperarlo despus con el manipulador setfill(). Discutiremos los manipuladores en profundidad ms adelante en este captulo. Los extractores requieren algo ms cuidado porque las cosas pueden ir mal con los datos de entrada. La manera de avisar sobre errores en el stream es activar el bit de error del stream, como se muestra a continuacin:
istream& operator>>(istream& is, Date& d) { is >> d.month; char dash; is >> dash; if(dash != -) is.setstate(ios::failbit); is >> d.day; is >> dash;
101 i i i i
i i
Captulo 5. Iostreams
if(dash != -) is.setstate(ios::failbit); is >> d.year; return is; }
Cuando se activa el bit de error en un stream, todas las operaciones posteriores sern ignoradas hasta que el stream sea devuelto a un estado correcto (explicado brevemente). Esto es porque el cdigo de arriba continua extrayendo incluso is ios::failbit est activado. Esta implementacin es poco estricta ya que permite espacios en blanco entre los numeros y guiones en la cadena de la fecha (por que el operador >> ignora los espacios en blanco por defecto cuado lee tipos fundamentales). La cadena de fecha a continuacin es vlida para este extractor:
"08-10-2003" "8-10-2003" "08 - 10 - 2003"
Discutiremos los estados de los stream en mayor profundidad en la seccin Manejar errores de stream despus en este captulo.
102 i i i i
i i
Ntese que buf solo tiene la primera palabra porque la rutina de entrada busca un espacio que delimite la entrada, que es el que se encuentra despus de tihs. Adems, si la entrada continua de datos es mayor que el espacio reservado por buf, sobrepasamos los limites del buffer. En la prctica, usualmente desear obtener la entrada desde programas interactivos, una linea cada vez como secuencia de carcteres, leerla, y despus hacer las conversiones necesarias hasta que estn seguras en un buffer. De esta manera no deber preocuparse por la rutina de entrada fallando por datos inesperados. Otra consideracin es todo el concepto de interfaz de lnea de comandos. Esto tenia sentido en el pasado cuando la consola era la nica interfaz con la mquina, pero el mundo est cambiando rpidamente hacia otro donde la interfaz grca de usuario (GUI) domina. Cual es el sentido de la E/S por consola en este mundo? Esto le da mucho ms sentido a ignorar cin en general, salvo para ejemplos simples y tests, y hacer los siguientes acercamientos: 1. Si su programa requiere entrada, leer esta entrada desde un chero? Pronto ver que es remarcablemente fcil usar cheros con iostream. Iostream para cheros todavia funciona perfectamente con una GUI. 2. Leer la entrada sin intentar convertirla, como hemos sugerido. Cuando la entrada es algun sitio donde no podemos arriesgarnos durante la conversin, podemos escanearla de manera segura. 3. La salida es diferente. Si est usando una interfaz grca, cout no necesariamente funciona, y usted debe mandarlo a un chero (que es indntico a mandarlo a un cout) o usar los componentes del GUI para mostrar los datos. En cualquier otra situacion, a menudo tiene sentido mandarlo a cout. En ambos casos, la funciones de formateo de la salida de iostream son muy tiles. Otra prctica comn ahorra tiempo en compilaciones largas. Consideres, por ejemplo, cmo quiere declarar los operadores del stream Date introducidos antes en el captulo en un chero de cabecera. Usted solo necesita incluir los prototipos para las funciones, luego no es necesario incluir la cabecera entera de <iostream> en Date.h. La prctica estndar es declarar solo las clases, algo como esto:
class ostream;
Esta es una vieja tecnica para separar la interfaz de la implementacin y a menudo la llaman declaracin avanzada( y ostream en este punto debe ser considerada un tipo incompleto, ya que la denicin de la clase no ha sido vista todavia por el compilador). Esto con funcionar asi, igualmente, por dos razones: Las clases stream estan denidas en el espacio de nombres std. Son plantillas. La declaracin correcta debera ser:
namespace std { template<class charT, class traits = char_traits<charT> >
103 i i i i
i i
Captulo 5. Iostreams
class basic_ostream; typedef basic_ostream<char> ostream; }
(Como puede ver, como las clase string, las clases stream usan las clases de rasgos de caracter mencionadas en el Captulo 3). Como puede ser terriblemente tedioso darle un tipo a todas las clases stream a las que quiere referenciar, el estndar provee una cabecera que lo hace por usted:
// Date.h #include <iosfwd> class Date { friend std::ostream& operator<<(std::ostream&, const Date&); friend std::istream& operator>>(std::istream&, Date&); // Etc.
i i
105 i i i i
i i
Captulo 5. Iostreams Todo va bien; no hay errores. La nal de la entrada todava no ha ocurrido. Puede comprobar si alguna de estas condiciones ha ocurrido llamando a la funcin miembro correspondiente que retorna un valor Booleano indicando cual de estas ha sido activada. La funcin miembro de stream good() retorna cierto si ninguno de los otros tres bits se han activado. La funcin eof() retorna cierto si eofbit est activado, que ocurre con un intento de leer de un stream que ya no tiene datos (generalmente un chero). Como el nal de una entrada ocurre en C++ cuando tratamos de leer pasado el nal del medio fsico, failbit tambin se activa para indicar que los datos esperados no han sido correctamente ledos. La funcin fail() retorna cierto si failbit o badbit estn activados, y bad() retorna cierto solo si badbit est activado. Una vez alguno de los bit de error de un stream se activa, permanece activo, cosa que no siempre es lo que se quiere. Cuando leemos un chero, usted puede querer colocarse en una posicin anterior en el chero antes de su nal. Simplemenete moviendo el puntero del chero no se desactiva el eofbit o el failbit; debe hacerlo usted mismo con la funcin clear(), haciendo algo as:
myStream.clear(); // Clears all error bits
Despus de llamar a clear(), good() retornar cierto si es llamada inmediatamente. Como vi en el extractor de Date antes, la funcin setstate() activa los bits que usted le pasa.Eso signica que setstate no afecta a los otros bits? Si ya esta activo, permanece activo. Si usted quiere activar ciertos bits pero en el mismo momento, desactivar el resto, usted puede llamar una versin sobrecargada de clear(), pasandole una expresion binaria representando los bits que quiere que se activen, as:
myStream.clear(ios::failbit | ios::eofbit);
La mayora del tiempo usted no estar interesado en comprobar los bits de estado del stream individualmente. Generalmente usted simplemente quiere conocer si todo va bien. Ese es el caso cuando quiere leer un chero del principio al nal; usted quiere saber simplemente cuando la entrada de datos se ha agotado. Puede usar una conversion de la funcin denida para void* que es automticamente llamada cuando un stream esta en una expresin booleana. Leer un stream hasta el nal de la entrada usando este idioma se parece a lo siguiente:
int i; while(myStream >> i) cout << i << endl;
Recuerde que operator>>() retorna su argumento stream, as que la sentencia while anterior comprueba el stream como una expresin booleana. Este ejemplo particular asume que el stream de entrada myStream contiene enteros separados por un espacio en blanco. La funcin ios_base::operator void*() simplemente llama a good() en su stream y retorna el resultado.3 Como la mayora de operaciones de stream retornan su stream, usar ese idioma es conveniente.
3 Es comn el uso de operator void () en vez de operator bool() porque las conversiones * implcitas de booleano a entero pueden causar sorpresas; pueden emplazarle incorrectamente un stream en un contexto donde una conversion a integer puede ser aplicada. La funcin operator void*() solo ser llamada implcitamente en el cuerpo de una expresin booleana.
106 i i i i
i i
Usted activa las excepciones stream por stream, ya que exceptions() es una funcin miembro para los streams. La funcin exceptions() retorna una mscara de bits 4 (de tipo iostate, que es un tipo dependiente del compilador convertible a int) indicando que estados de stream causarn excepciones. Si estos estados ya han sido activados, la excepcin ser lanzada inmediatamente. Por supuesto, si usa excepciones en conexiones a streams, debera estar preparado paracapturarlas, lo que quiere decir que necesita envolver todos los stream bon bloques try que tengan un manejador ios::failure. Muchos programadores encuentran tedioso y simplemente comprueban manualmente donde esperan encontrar errores (ya que, por ejemplo, no esperan encontrar bad() al retornar true la mayoria de veces). Esto es otra razn que tienen los streams para que el lanzamiento de excepciones sea opcional y no por defecto. en cualquier caso, usted peude elegir como quiere manejar los errores de stream. Por las mismas razones que recomendamos el uso de excepciones para el manejo de rrores en otros contextos, lo hacemos aqui.
107 i i i i
i i
Captulo 5. Iostreams
typedef basic_ifstream<char> ifstream;
La creacin tanto del ifstream como del ofstream estn seguidas de un assure() para garantizar que el chero ha sido abierto exitosamente. El objeto resultante, usado en una situacin donde el compilador espera un resultado booleano, produce un valor que indica xito o fracaso. 108 i i i i
i i
5.4. Iostreams de chero El primer while demuestra el uso de dos formas de la funcin get(). La primera toma los carcteres dentro de un buffer y pone un delimitador cero en el buffer cuando bien SZ-1 carcteres han sido leidos o bien el tercer argumento (que por defecto es \n) es encontrado. La funcin get() deja el carcter delimitador en el stream de entrada, as que este delimitador debe ser eliminado via in.get() usando la forma de get() sin argumentos. Puede usar tambien la funcin miembro ignore(), que tiene dos parmetros por defecto. El primer argumento es el nmero de carcteres para descartar y por defecto es uno. El segundo argumento es el carcter en el que ignore() se detiene (despus de extraerlo) y por defecto es EOF. A continuacin, se muestran dos sentencias de salida similares: una hacia cout y la otra al chero de salida. Ntese la conveniencia aqu - no necesita preocuparse del tipo de objeto porque las sentencias de formateo trabajan igual con todos los objetos ostream. El primero hace eco de la linea en la salida estndar, y el segundo escribe la lnea hacia el chero de salida e incluye el nmero de lnea. Para demostrar getline(), abra el chero recin creado y quite los nmeros de linea. Para asegurarse que el chero se cierra correctamente antes de abrirlo para la lectura, usted tiene dos opciones. Puede envolver la primera parte del programa con llaves para forzar que el objeto out salga del mbito, llamando as al destructor y cerrando el chero, que es lo que se hace aqu. Tambien puede l lamar a close() para ambos cheros; si hace esto, puede despues rehusar el objeto de entrada llamando a la funcin miembro open(). El segundo while muestra como getline() borra el caracter terminador (su tercer argumento, que por defecto es \n) del stream de entrada cuando este es encontrado. Aunque getline(), como get(), pone un cero en el buffer, este todava no inserta el carcter de terminacin. Este ejemplo, as como la mayora de ejemplos en este captulo, asume que cada llamada a alguna sobrecarga de getline() encontrar un carcter de nueva lnea. Si este no es el caso, la estado eofbit del stream ser activado y la llamada a getline() retornar falso, causando que el programa pierda la ltima lnea de la entrada.
109 i i i i
i i
Captulo 5. Iostreams Abre un chero existente (ya sea de entrada o salida) y busca el nal. ios::trunc Trunca el chero antiguo si este ya existe. ios::binary Abre un chero en modo binario. Por defecto es en modo texto. Puede combinar estas banderas usando la operacin or para bits El ag binario, aun siendo portable, solo tiene efecto en algunos sistemas no UNIX, como sistemas operativos derivados de MS-DOS, que tiene convenciones especiales para el almacenamiento de delimitadores de nal de lnea. Por ejemplo, en sistemas MS-DOS en modo texto (el cual es por defecto), cada vez que usted inserta un nuevo carcter de nueva lnea (\n), el sistema de cheros en realidad inserta dos carcteres, un par retorno de carro/n de lnea (CRLF), que es el par de carcteres ASCII 0x0D y 0x0A. En sentido opuesto, cuando usted lee este chero de vuelta a memoria en modo texto, cada ocurrencia de este par de bytes causa que un \n sea enviado al programa en su lugar. Si quiere sobrepasar este procesado especial, puede abrir el chero en modo binario. El modo binario no tiene nada que ver ya que usted puede escribir bytes sin formato en un chero - siempre puede (llamando a write()). Usted debera, por tanto, abrir un chero en modo binario cuando vaya a usar read() o write(), porque estas funciones toman un contador de bytes como parmetro. Tener carcteres extra \r estropear su contador de bytes en estas instancias. Usted tambin puede abrir un chero en formato binario si va a usar comandos de posicionamiento en el stream que se discuten ms adelante. Usted puede abrir un chero tanto para entrada como salida declarando un objeto fstream. cuando declara un objeto fstream, debe usar sucientes banderas de modos de apertura mencionados antes para dejar que el sistema de cheros sepa si quiere leer, escribir, o ambos. Para cambiar de salida a entrada, necesita o bien limpiar el stream o bien cambiar la posicin en el chero. Para cambiar de entrada a salida, cambie la posicion en el chero. Para crear un chero usando un objeto fstream, use la bandera de modo de apertura ios::trunc en la llamada al constructor para usar entrada y salida.
i i
5.5. Almacenamiento de iostream Actualmente, la cosa ms importante que debe conocer es que cada objeto iostream contiene un puntero a un objeto streambuf, y el objeto streambuf tiene algunas funciones miembro que puede llamar si es necesario. Para cheros y streams de string, hay tipos especializados de buffers de stream, como ilustra la gura siguiente: Para permitirle el acceso al streambuf, cada objeto iostream tiene una funcin miembro llamada rdbuf() que retorna el puntero a un objeto streambuf. De esta manera usted puede llamar cualquier funcin miembro del streambuf subyacente. No obstante, una de las cosas ms interesantes que usted puede hacer con el puntero al streambuf es conectarlo con otro objeto iostream usando el operador <<. Esto inserta todos los carcteres del objeto dentro del que est al lado izquierdo del <<. Si quiere mover todos los carcteres de un iostream a otro, no necesita ponerse con el tedioso (y potencialmente inclinado a errores de cdigo) proceso de leer de carcter por carcter o lnea por lnea. Este es un acercamiento mucho ms elegante. Aqui est un programa muy simple que abre un chero y manda el contenido a la salida estndar (similar al ejemplo previo):
//: C04:Stype.cpp // Type a file to standard output. #include <fstream> #include <iostream> #include "../require.h" using namespace std; int main() { ifstream in("Stype.cpp"); assure(in, "Stype.cpp"); cout << in.rdbuf(); // Outputs entire file } ///:~
Un ifstream se crea usando el chero de cdigo fuente para este programa como argumento. La funcin assure() reporta un fallo si el chero no puede ser abierto. Todo el trabajo pasa realmente en la sentencia
cout << in.rdbuf();
que manda todo el contenido del chero a cout. No solo es un cdigo ms sucinto, a menudo es ms eciente que mover los byte de uno en uno. Una forma de get() escribe directamente dentro del streambuf de otro objeto. El primer argumento es una referencia al streambuf de destino, y el segundo es el carcter de terminacin (\n por defecto), que detiene la funcin get(). As que existe todava otra manera de imprimir el resultado de un chero en la salida estndar:
//: C04:Sbufget.cpp // Copies a file to standard output. #include <fstream> #include <iostream> #include "../require.h" using namespace std; int main() {
111 i i i i
i i
Captulo 5. Iostreams
ifstream in("Sbufget.cpp"); assure(in); streambuf& sb = *cout.rdbuf(); while(!in.get(sb).eof()) { if(in.fail()) // Found blank line in.clear(); cout << char(in.get()); // Process \n } } ///:~
La funcin rdbuf() retorna un puntero, que tiene que ser desreferenciado para satisfacer las necesidades de la funcin para ver el objeto. Los buffers de stream no estan pensados para ser copiados (no tienen contructor de copia), por lo que denimos sb como una referencia al buffer de stream de cout. Necesitamos las llamadas a fail() y clear() en caso de que el chero de entrada tenga una lnea en blanco (este la tiene). Cuando esta particular versin sobrecargada de get() vee dos carcteres de nueva lnea en una la (una evidencia de una lnea en blanco), activa el bit de error del stream de entrada, asi que se debe llamar a clear() para resetearlo y que as el stream pueda continuar siendo ledo. La segunda llamada a get() extrae y hace eco de cualquier delimitador de nueva lnea. (Recuerde, la funcin get() no extrae este delimitador como s lo hace getline()). Probablemente no necesitar usar una tcnica como esta a menudo, pero es bueno saber que existe.5
112 i i i i
i i
5.6. Buscar en iostreams ios::end Desde el principio del stream Aqu un ejemplo que muestra el movimiento por un chero, pero recuerde, no esta limitado a buscar en cheros como lo est con stdio de C. Con C++, puede buscar en cualquier tipo de iostream (aunque los objetos stream estndar, como cin y cout, lo impiden explcitamente):
//: C04:Seeking.cpp // Seeking in iostreams. #include <cassert> #include <cstddef> #include <cstring> #include <fstream> #include "../require.h" using namespace std; int main() { const int STR_NUM = 5, STR_LEN = 30; char origData[STR_NUM][STR_LEN] = { "Hickory dickory dus. . .", "Are you tired of C++?", "Well, if you have,", "Thats just too bad,", "Theres plenty more for us!" }; char readData[STR_NUM][STR_LEN] = {{ 0 }}; ofstream out("Poem.bin", ios::out | ios::binary); assure(out, "Poem.bin"); for(int i = 0; i < STR_NUM; i++) out.write(origData[i], STR_LEN); out.close(); ifstream in("Poem.bin", ios::in | ios::binary); assure(in, "Poem.bin"); in.read(readData[0], STR_LEN); assert(strcmp(readData[0], "Hickory dickory dus. . .") == 0); // Seek -STR_LEN bytes from the end of file in.seekg(-STR_LEN, ios::end); in.read(readData[1], STR_LEN); assert(strcmp(readData[1], "Theres plenty more for us!") == 0); // Absolute seek (like using operator[] with a file) in.seekg(3 * STR_LEN); in.read(readData[2], STR_LEN); assert(strcmp(readData[2], "Thats just too bad,") == 0); // Seek backwards from current position in.seekg(-STR_LEN * 2, ios::cur); in.read(readData[3], STR_LEN); assert(strcmp(readData[3], "Well, if you have,") == 0); // Seek from the begining of the file in.seekg(1 * STR_LEN, ios::beg); in.read(readData[4], STR_LEN); assert(strcmp(readData[4], "Are you tired of C++?") == 0); } ///:~
113 i i i i
i i
Captulo 5. Iostreams Este programa escribe un poema a un chero usando un stream de salida binaria. Como reabrimos como un ifstream, usamos seekg() para posicionar el get pointer. Como puede ver, puede buscar desde el principio o el nal del archivo o desde la posicin actual del archivo. Obviamente, debe proveer un nmero positivo para mover desde el principio del archivo y un nmero negativo para mover hacia atrs. Ahora que ya conoce el streambuf y como buscar, ya puede entender un mtodo alternativo (aparte de usar un objeto fstream) para crear un objeto stream que podr leer y escribir en un archivo. El siguiente cdigo crea un ifstream con banderas que dicen que es un chero de entrada y de salida. Usted no puede escribir en un ifstream, as que necesita crear un ostream con el buffer subyacente del stream:
ifstream in("filename", ios::in | ios::out); ostream out(in.rdbuf());
Debe estar preguntndose que ocurre cuando usted lee en uno de estos objetos. Aqui tiene un ejemplo:
//: C04:Iofile.cpp // Reading & writing one file. #include <fstream> #include <iostream> #include "../require.h" using namespace std; int main() { ifstream in("Iofile.cpp"); assure(in, "Iofile.cpp"); ofstream out("Iofile.out"); assure(out, "Iofile.out"); out << in.rdbuf(); // Copy file in.close(); out.close(); // Open for reading and writing: ifstream in2("Iofile.out", ios::in | ios::out); assure(in2, "Iofile.out"); ostream out2(in2.rdbuf()); cout << in2.rdbuf(); // Print whole file out2 << "Where does this end up?"; out2.seekp(0, ios::beg); out2 << "And what about this?"; in2.seekg(0, ios::beg); cout << in2.rdbuf(); } ///:~
Las primeras cinco lneas copian el cdigo fuente de este programa en un chero llamado iole.out y despus cierra los cheros. Esto le da un texto seguro con el que practicar. Entonces, la tcnica antes mencionada se usa para crear dos objetos que leen y escriben en el mismo chero. En cout << in2.rebuf(), puede ver como puntero get es inicializado al principio del chero. El puntero put, en cambio, se coloca en el nal del chero para que Where does this end up aparezca aadido al chero. No obstante, si el puntero put es movido al principio con un seekp(114 i i i i
i i
5.7. Iostreams de string ), todo el texto insertado sobreescribe el existente. Ambas escrituras pueden verse cuando el puntero get se mueve otra vez al principio con seekg(), y el chero se muestra. El chero es automticamente guardado cuando out2 sale del mbito y su destructor es invocado.
Puede ver que es un acercamiento ms exible y general para transformar cadenas de carcteres para valores con tipo que la librera de funciones del estndar 115 i i i i
i i
Captulo 5. Iostreams de C, como atof() o atoi(), aunque esta ltima puede ser ms ecaz para las conversiones individuales. En la expresin s >> i >> f, el primer nmero se extrae en i, y en el segundo en f. Este no es el primer conjunto de carcteres delimitado por espacios en blanco por que depende del tipo de datos que est siendo extrado. Por ejemplo, si la cadena fuera 1.414 47 This is a test, entonces i tomara el valor 1 porque la rutina de entrada se parara en el punto decimal. Entonces f tomara 0.414. Esto puede ser muy til i si quiere partir un nmero de coma otante entre la parte entera y la decimal. De otra manera parecera un error. El segundo assert() calcula el error relativo entre lo que leemos y lo que esperamos; siempre es mejor hacer esto que comparar la igualdad de nmeros de coma otante. La constante devuelta por epsilon(), denida en <limits>, representa la epsilon de la mquina para nmeros de doble precisin, el cual es la mejor tolerancia que se puede esperar para satisfacer las comparaciones de double.6 . Como debe haber supuesto, buf2 no toma el resto del string, simplemente la siguiente palabra delimitada por espacios en blanco. En general, el mejor usar el extractor en iostreams cuando usted conoce exactamente la secuencia de datos en el stream de entrada y los convierte a algn otro tipo que un string de carcteres. No obstante, si quiere extraer el resto del string de una sola vez y enviarlo a otro iostream, puede usar rdbuf() como se muestra. Para probar el extractor de Date al principio de este captulo, hemos usado un stream de cadena de entrada con el siguiente programa de prueba:
//: C04:DateIOTest.cpp //{L} ../C02/Date #include <iostream> #include <sstream> #include "../C02/Date.h" using namespace std; void testDate(const string& s) { istringstream os(s); Date d; os >> d; if(os) cout << d << endl; else cout << "input error with \"" << s << "\"" << endl; } int main() { testDate("08-10-2003"); testDate("8-10-2003"); testDate("08 - 10 - 2003"); testDate("A-10-2003"); testDate("08 %10/2003"); } ///:~
Cada literal de cadena en main() se pasa por referencia a testDate(), que a su vez lo envuelve en un istringstream con lo que podemos probar el extractor
6 Para ms informacin sobre la epsilon de la mquina y el cmputo de punto otante en general, vea el artculo de Chuck, "The Standard C Library, Part 3", C/C++ Users Journal, Marzo 1995, disponible en www.freshsources.com/1995006a.htm
116 i i i i
i i
5.7. Iostreams de string de stream que escribimos para los objetos Date. La funcin testDate() tambin empieza por probar el insertador, operator<<().
Esto es similar al ejemplo Istring.cpp anterior que peda un int y un oat. A continueacin una simple ejecucin (la entrada por teclado est escrita en negrita).
type an int, a float and a string: FIXME:10 20.5 the end integer = 10 float = 20.5 string = the end
Puede ver que, como otros stream de salida, puede usar las herramientas ordinarias de formateo, como el operador << y endl, para enviar bytes hacia el ostringstream. La funcin str() devuelve un nuevo objeto string cada vez que usted la llama con lo que el stringbuf contenido permanece inalterado. En el captulo previo, presentamos un programa, HTMLStripper.cpp, que borraba todas las etiqietas HTML y los cdigos especiales de un chero de texto. Como prometamos, aqui est una versin ms elegante usando streams de cadena.
//: C04:HTMLStripper2.cpp {RunByHand} //{L} ../C03/ReplaceAll // Filter to remove html tags and markers. #include <cstddef> #include <cstdlib>
117 i i i i
i i
Captulo 5. Iostreams
#include <fstream> #include <iostream> #include <sstream> #include <stdexcept> #include <string> #include "../C03/ReplaceAll.h" #include "../require.h" using namespace std; string& stripHTMLTags(string& s) throw(runtime_error) { size_t leftPos; while((leftPos = s.find(<)) != string::npos) { size_t rightPos = s.find(>, leftPos+1); if(rightPos == string::npos) { ostringstream msg; msg << "Incomplete HTML tag starting in position " << leftPos; throw runtime_error(msg.str()); } s.erase(leftPos, rightPos - leftPos + 1); } // Remove all special HTML characters replaceAll(s, "<", "<"); replaceAll(s, ">", ">"); replaceAll(s, "&", "&"); replaceAll(s, " ", " "); // Etc... return s; } int main(int argc, char* argv[]) { requireArgs(argc, 1, "usage: HTMLStripper2 InputFile"); ifstream in(argv[1]); assure(in, argv[1]); // Read entire file into string; then strip ostringstream ss; ss << in.rdbuf(); try { string s = ss.str(); cout << stripHTMLTags(s) << endl; return EXIT_SUCCESS; } catch(runtime_error& x) { cout << x.what() << endl; return EXIT_FAILURE; } } ///:~
En este programa leemos el chero entero dentro de un string insertando una llamada rdbuf() del stream de chero al ostringstream. Ahora es fcil buscar parejas de delimitadores HTML y borrarlas sin tener que preocuparnos de lmites de lneas como teniamos con la versin previa en el Captulo 3. El siguiente ejemplo muestra como usar un stream de cadena bidireccional (esto es, lectura/escritura):
//: C04:StringSeeking.cpp {-bor}{-dmc}
118 i i i i
i i
fish";
its time.");
Como siempre para mover el puntero de insercin, usted llama a seekp(), y para reposicionar el chero de lectura, usted llama a seekg(). Incluso aunque no lo hemos mostrado con este ejemplo, los stream de cadeana son un poco ms permisivos que los stream de chero ya que podemos cambiar de lectura a escritura y viceversa en cualquier momento. No necesita reposicionar el puntero de lectura o de escritura o vaciar el stream. Este progrma tambin ilustra la sobrecarga de str() que reemplaza el stringbuf contenido en el stream con una nueva cadena.
i i
Captulo 5. Iostreams para siempre usar un punto decimal para valores de coma otante, y cosas as. En el otro lado, funciones miembro separadas activan y leen valores para el caracter de relleno, la anchura del campo, y la precisin. En un intento de claricar todo esto, primero examinaremos el formateo interno de los datos de un iostream, y las funciones miembro que pueden modicar estos datos. (Todo puede ser controlado por funciones miembro si se desea). Cubriremos los manipuladores aparte.
La primera funcin fuerza que todas las banderas cambien, que a veces es lo que usted quiere. Ms a menudo, usted cambia una bandera cada vez usando las otras tres funciones. El uso de setf() puede parecer algo confusa. Para conocer qu versin sobrecargada usar, debe conocer el tipo de la bandera que est cambiando. Existen dos tipos de banderas: las que simplemente estan activadas o no, y aquellas que trabajan en grupo con otras banderas. La banderas que estan encendidas/apagadas son las ms simples de entender por que usted las enciende con setf(fmtflags) y las apaga con unsetf(fmtflags). Estas banderas se muestran en la siguiente tabla: bandera activa/inactiva Efecto ios::skipws Se salta los espacios en blanco. ( Para la entrada esto es por defecto). ios::showbase Indica la base numrica (que puede ser, por ejemplo, decimal, octal o hexadecimal) cuando imprimimos el valor entero. Los stream de entrada tambi reconocen el prejo de base cuando showbase est activo. ios::showpoint Muestra el punto decimal insertando ceros para valores de coma otante. ios::uppercase Muestra A-F maysculas para valores hexadecimales y E para cientcos. 120 i i i i
i i
5.8. Formateo de stream de salida ios::showpos Muestra el signo de sumar (+) para los valores positivos ios::unitbuf Unit buffering. El stream es borrado despus de cada insecin. Por ejemplo, para mostrar el signo de sumar para cout, puede usar cout.setf(ios::showpos). Para dejar de mostrar el signo de sumar, escriba cout.unsetf(ios::showpos). La bandera de unitbuf controla el almacenamiento unitario, que signica que cada insercin es lanzada a su stream de salida inmediatamente. Esto es til para hacer recuento de errores, ya que en caso de fallo del programa, sus datos son todava escritos al chero de log. El siguiente programa ilustra el almacenamiento unitario.
//: C04:Unitbuf.cpp {RunByHand} #include <cstdlib> // For abort() #include <fstream> using namespace std; int main() { ofstream out("log.txt"); out.setf(ios::unitbuf); out << "one" << endl; out << "two" << endl; abort(); } ///:~
Es necesario activar el almacenamiento unitario antes de que cualquier insercin sea hecha en el stream. Cuando hemos descomentado la llamada a setf(), un compilador en particular ha escrito solo la letra o en el chero log.txt. Con el almacenamiento unitario, ningun dato se perdi. El stream de salida estndar cerr tiene el almacenamiento unitario activado por defecto. Hay un coste para el almacenamiento unitario, asi que si un stream de salida se usa intensivamente, no active el almacenamiento unitario a menos que la eciencia no sea una consideracin.
i i
Captulo 5. Iostreams se con los detalles de la implementacin interna de esta clase o tener cuidado de que esto es una seria de banderas binarias. Ms adelante ver que hay manipuladores para proveer de la funcionalidad equivalente en todas las parts donde usted fuera a usar setf(). Aqu estn los grupos de banderas y sus efectos: ios::basefield Efecto ios::dec Formatea valores enteros en base 10 (decimal)(Formateo por defecto - ningn prejo es visible). ios::hex Formatea valores enteros en base 16 (hexadecimal). ios::oct Formatea valores enteros en base 8 (octal). ios::floatfield Efecto ios::scientific Muestra nmeros en coma otante en formato cientco. El campo precisin indica el numero de dgitos despus del punto decimal. ios::fixed Muestra nmeros en coma otante en formato jado. El campo precisin indica en nmero de dgitos despus del punto decimal. automatic (Ninguno de los bits est activado). El campo precisin indica el nmero total de dgitos signicativos. ios::adjustfield Efecto ios::left Valores con alineacin izquierda; se llena hasta la derecha con el carcter de relleno. ios::right Valores con alineacin derecha; se llena hasta la izquierda con el carcter de relleno. Esta es la alineacin por defecto. ios::internal Aade carcteres de relleno despues de algn signo inicial o indicador de base, pero antes del valor. (En otras palabras, el signo, si est presente, se justica a la izquierda mientras el nmero se justica a la derecha).
122 i i i i
i i
5.8. Formateo de stream de salida Funcin Efecto int ios::width( ) Retorna la anchura actual. Por defecto es 0. Se usa para la insercin y la extraccin. int ios::width(int n) Pone la anchura, retorna la anchura previa. int ios::fill( ) Retorna el carcter de relleno actual. Por defecto es el espacio. int ios::fill(int n) Poner el carcter de relleno, retorna el carcter de relleno anterior. int ios::precision( ) Retorna la precisin actual de la coma otante. Por defecto es 6. int ios::precision(int n) Pone la precisin de la coma otante, retorna la precisin anteriot. Vea la tabla ios::floatfield para el signicado de precisin. El relleno y la precisin son bastante claras, pero la anchura requiera alguna explicacin. Cuando la anchura es 0, insertar un valor produce el mnimo nmero de carcteres necesario para representar este valor. Una anchura positiva signica que insertar un valor producir al menos tantos carcteres como la anchura; si el valor tiene menos carcteres que la anchura, el carcter de relleno llena el campo. No obstante, el valor nunca ser truncado, con lo que si usted intenta escribir 123 con una anchura de dos, seguir obteniendo 123. El campo anchura especica un minimo nmero de carcteres; no hay forma de especicar un nmero mnimo. La anchura tambin es diferente por que vuelve a ser cero por cada insertador o extractor que puede ser inuenciado por este valor. Realmente no es una variable de estado, sino ms bien un argumento implcito para los extractores y insertadores. Si quiere una anchura constante, llame a width() despues de cada insercin o extraccin.
123 i i i i
i i
Captulo 5. Iostreams
D(float f = 2300114.414159;) const char* s = "Is there any more?"; D(T.setf(ios::unitbuf);) D(T.setf(ios::showbase);) D(T.setf(ios::uppercase | ios::showpos);) D(T << i << endl;) // Default is dec D(T.setf(ios::hex, ios::basefield);) D(T << i << endl;) D(T.setf(ios::oct, ios::basefield);) D(T << i << endl;) D(T.unsetf(ios::showbase);) D(T.setf(ios::dec, ios::basefield);) D(T.setf(ios::left, ios::adjustfield);) D(T.fill(0);) D(T << "fill char: " << T.fill() << endl;) D(T.width(10);) T << i << endl; D(T.setf(ios::right, ios::adjustfield);) D(T.width(10);) T << i << endl; D(T.setf(ios::internal, ios::adjustfield);) D(T.width(10);) T << i << endl; D(T << i << endl;) // Without width(10) D(T.unsetf(ios::showpos);) D(T.setf(ios::showpoint);) D(T << "prec = " << T.precision() << endl;) D(T.setf(ios::scientific, ios::floatfield);) D(T << endl << f << endl;) D(T.unsetf(ios::uppercase);) D(T << endl << f << endl;) D(T.setf(ios::fixed, ios::floatfield);) D(T << f << endl;) D(T.precision(20);) D(T << "prec = " << T.precision() << endl;) D(T << endl << f << endl;) D(T.setf(ios::scientific, ios::floatfield);) D(T << endl << f << endl;) D(T.setf(ios::fixed, ios::floatfield);) D(T << f << endl;) D(T.width(10);) T << s << endl; D(T.width(40);) T << s << endl; D(T.setf(ios::left, ios::adjustfield);) D(T.width(40);) T << s << endl; } ///:~
Este ejemplo usa un truco para crear un chero de traza para que pueda monitorizar lo que est pasando. La macro D(a) usa el preprocesador convirtiendo a string para convertir a en una cadena para mostrar. Entonces se reitera a con lo que la sentencia se ejecuta. La macro envia toda la informacin a un chero llamado T, que es 124 i i i i
i i
Estudiar esta salida debera claricar su entendimiento del formateo de las funciones miembro de iostream . 125 i i i i
i i
Captulo 5. Iostreams
5.9. Manipuladores
Como puede ver en el programa previo, llamar a funciones miembro para operaciones de formateo de stream puede ser un poco tedioso. Para hacer las cosas mas fciles de leer y escribir, existe un conjunto de manipuladores para duplicar las acciones previstas por las funciones miembro. Las manipuladores son convenientes por que usted puede insertarlos para que actuen dentro de una expresion contenedora; no necesita crear una sentencia de llamada a funcin separada. Los manipuladores cambian el estado de un stream en vez de (o adems de) procesar los datos. Cuando insertamos un endl en una expresin de salida, por ejemplo, no solo inserta un carcter de nueva linea, sino que ademas termina el stream (esto es, saca todos los carcteres pendientes que han sido almacenadas en el buffer interno del stream pero todavia no en la salida). Puede terminar el stream simplemente asi:
cout << flush;
como efecto lateral (nada es insertado dentro de stream). Adicionalmente los manipuladores bsicos cambirn la base del nmero a oct (octal), dec (decimal) o hex (hexadecimal).
cout << hex << "0x" << i << endl;
En este caso, la salida numrica continuar en modo hexadecimal hasta que usted lo cambie insertando o dec o oct en el stream de salida. Tambin existe un manipulador para la extraccin que se come los espacios en blanco:
cin >> ws;
Los manipuladores sin argumentos son provistos en <iostream>. Esto incluye dec, oct,y hex, que hacen las mismas acciones que, respectivamente, setf(ios::dec, ios::basefield), setf(ios::oct, ios::basefield), y setf(ios::hex, ios::basefield), aunque ms sucintamente. La cabecera <iostream> tambin incluye ws, endl, y ush y el conjunto adicional mostrado aqu: Manipulador Efecto showbase noshowbase Indica la base numrica (dec, oct, o hex) cuando imprimimos un entero. showpos noshowpos Muestra el signo ms (+) para valores positivos. uppercase nouppercase Muestra maysculas A-F para valores hexadecimales, y muestra E para valores 126 i i i i
i i
5.9. Manipuladores cientcos. showpoint noshowpoint Muestra punto decimal y ceros arrastrados para valores de coma otante. skipws noskipws Escapa los espacios en blanco en la entrada. left right internal Alineacin izquierda, relleno a la derecha. Alineacin derecha, relleno a la izquierda. Rellenar entre el signo o el indicador de base y el valor. scientic xed Indica la preferencia al mostrar la salida para coma otante (notacin cientca versus coma otante decimal).
127 i i i i
i i
Captulo 5. Iostreams
#include <iomanip> #include <iostream> using namespace std; int main() { ofstream trc("trace.out"); int i = 47; float f = 2300114.414159; char* s = "Is there any more?"; trc << setiosflags(ios::unitbuf | ios::showbase | ios::uppercase | ios::showpos); trc << i << endl; trc << hex << i << endl << oct << i << endl; trc.setf(ios::left, ios::adjustfield); trc << resetiosflags(ios::showbase) << dec << setfill(0); trc << "fill char: " << trc.fill() << endl; trc << setw(10) << i << endl; trc.setf(ios::right, ios::adjustfield); trc << setw(10) << i << endl; trc.setf(ios::internal, ios::adjustfield); trc << setw(10) << i << endl; trc << i << endl; // Without setw(10) trc << resetiosflags(ios::showpos) << setiosflags(ios::showpoint) << "prec = " << trc.precision() << endl; trc.setf(ios::scientific, ios::floatfield); trc << f << resetiosflags(ios::uppercase) << endl; trc.setf(ios::fixed, ios::floatfield); trc << f << endl; trc << f << endl; trc << setprecision(20); trc << "prec = " << trc.precision() << endl; trc << f << endl; trc.setf(ios::scientific, ios::floatfield); trc << f << endl; trc.setf(ios::fixed, ios::floatfield); trc << f << endl; trc << f << endl; trc << setw(10) << s << endl; trc << setw(40) << s << endl; trc.setf(ios::left, ios::adjustfield); trc << setw(40) << s << endl; } ///:~
Puede ver que un montn de sentencias mltiples han sido condensadas dentro de una sola insercin encadenada. Ntese que la llamada a setiosags() en que se pasa el OR binario de las banderas. Esto se podra haber hecho tambin con setf() y unsetf() como en el ejemplo previo.
//: C04:InputWidth.cpp
128 i i i i
i i
5.9. Manipuladores
// Shows limitations of setw with input. #include <cassert> #include <cmath> #include <iomanip> #include <limits> #include <sstream> #include <string> using namespace std; int main() { istringstream is("one 2.34 five"); string temp; is >> setw(2) >> temp; assert(temp == "on"); is >> setw(2) >> temp; assert(temp == "e"); double x; is >> setw(2) >> x; double relerr = fabs(x - 2.34) / x; assert(relerr <= numeric_limits<double>::epsilon()); } ///:~
5.9.2.
ostream& endl(ostream&);
//: C04:nl.cpp // Creating a manipulator. #include <iostream> using namespace std; ostream& nl(ostream& os) { return os << \n; } int main() { cout << "newlines" << nl << "between" << nl << "each" << nl << "word" << nl; } ///:~
cout.operator<<(nl) nl(cout)
129 i i i i
i i
Captulo 5. Iostreams
os << \n;
5.9.3.
//: C04:Effector.cpp // Jerry Schwarzs "effectors." #include <cassert> #include <limits> // For max() #include <sstream> #include <string> using namespace std; // Put out a prefix of a string: class Fixw { string str; public: Fixw(const string& s, int width) : str(s, 0, width) {} friend ostream& operator<<(ostream& os, const Fixw& fw) { return os << fw.str; } }; // Print a number in binary: typedef unsigned long ulong; class Bin { ulong n; public: Bin(ulong nn) { n = nn; } friend ostream& operator<<(ostream& os, const Bin& b) { const ulong ULMAX = numeric_limits<ulong>::max(); ulong bit = ~(ULMAX >> 1); // Top bit set while(bit) { os << (b.n & bit ? 1 : 0); bit >>= 1; } return os; } }; int main() { string words = "Things that make us happy, make us wise"; for(int i = words.size(); --i >= 0;) { ostringstream s; s << Fixw(words, i); assert(s.str() == words.substr(0, i)); } ostringstream xs, ys; xs << Bin(0xCAFEBABEUL); assert(xs.str() == "1100""1010""1111""1110""1011""1010""1011""1110"); ys << Bin(0x76543210UL); assert(ys.str() == "0111""0110""0101""0100""0011""0010""0001""0000"); } ///:~
130 i i i i
i i 5.10.
5.10.
5.10.1.
//: C04:Cppcheck.cpp // Configures .h & .cpp files to conform to style // standard. Tests existing files for conformance. #include <fstream> #include <sstream> #include <string> #include <cstddef> #include "../require.h" using namespace std; bool startsWith(const string& base, const string& key) { return base.compare(0, key.size(), key) == 0; } void cppCheck(string fileName) { enum bufs { BASE, HEADER, IMPLEMENT, HLINE1, GUARD1, GUARD2, GUARD3, CPPLINE1, INCLUDE, BUFNUM }; string part[BUFNUM]; part[BASE] = fileName; // Find any . in the string: size_t loc = part[BASE].find(.); if(loc != string::npos) part[BASE].erase(loc); // Strip extension // Force to upper case: for(size_t i = 0; i < part[BASE].size(); i++) part[BASE][i] = toupper(part[BASE][i]); // Create file names and internal lines: part[HEADER] = part[BASE] + ".h"; part[IMPLEMENT] = part[BASE] + ".cpp"; part[HLINE1] = "//" ": " + part[HEADER]; part[GUARD1] = "#ifndef " + part[BASE] + "_H"; part[GUARD2] = "#define " + part[BASE] + "_H"; part[GUARD3] = "#endif // " + part[BASE] +"_H"; part[CPPLINE1] = string("//") + ": " + part[IMPLEMENT]; part[INCLUDE] = "#include \"" + part[HEADER] + "\""; // First, try to open existing files: ifstream existh(part[HEADER].c_str()), existcpp(part[IMPLEMENT].c_str()); if(!existh) { // Doesnt exist; create it ofstream newheader(part[HEADER].c_str()); assure(newheader, part[HEADER].c_str()); newheader << part[HLINE1] << endl << part[GUARD1] << endl << part[GUARD2] << endl << endl << part[GUARD3] << endl; } else { // Already exists; verify it stringstream hfile; // Write & read ostringstream newheader; // Write hfile << existh.rdbuf();
131 i i i i
i i
Captulo 5. Iostreams
// Check that first three lines conform: bool changed = false; string s; hfile.seekg(0); getline(hfile, s); bool lineUsed = false; // The call to good() is for Microsoft (later too): for(int line = HLINE1; hfile.good() && line <= GUARD2; ++line) { if(startsWith(s, part[line])) { newheader << s << endl; lineUsed = true; if(getline(hfile, s)) lineUsed = false; } else { newheader << part[line] << endl; changed = true; lineUsed = false; } } // Copy rest of file if(!lineUsed) newheader << s << endl; newheader << hfile.rdbuf(); // Check for GUARD3 string head = hfile.str(); if(head.find(part[GUARD3]) == string::npos) { newheader << part[GUARD3] << endl; changed = true; } // If there were changes, overwrite file: if(changed) { existh.close(); ofstream newH(part[HEADER].c_str()); assure(newH, part[HEADER].c_str()); newH << "//@//\n" // Change marker << newheader.str(); } } if(!existcpp) { // Create cpp file ofstream newcpp(part[IMPLEMENT].c_str()); assure(newcpp, part[IMPLEMENT].c_str()); newcpp << part[CPPLINE1] << endl << part[INCLUDE] << endl; } else { // Already exists; verify it stringstream cppfile; ostringstream newcpp; cppfile << existcpp.rdbuf(); // Check that first two lines conform: bool changed = false; string s; cppfile.seekg(0); getline(cppfile, s); bool lineUsed = false; for(int line = CPPLINE1; cppfile.good() && line <= INCLUDE; ++line) { if(startsWith(s, part[line])) { newcpp << s << endl;
132 i i i i
i i 5.10.
lineUsed = true; if(getline(cppfile, s)) lineUsed = false; } else { newcpp << part[line] << endl; changed = true; lineUsed = false; } } // Copy rest of file if(!lineUsed) newcpp << s << endl; newcpp << cppfile.rdbuf(); // If there were changes, overwrite file: if(changed) { existcpp.close(); ofstream newCPP(part[IMPLEMENT].c_str()); assure(newCPP, part[IMPLEMENT].c_str()); newCPP << "//@//\n" // Change marker << newcpp.str(); } } } int main(int argc, char* argv[]) { if(argc > 1) cppCheck(argv[1]); else cppCheck("cppCheckTest.h"); } ///:~
5.10.2.
//: C04:Showerr.cpp {RunByHand} // Un-comment error generators. #include <cstddef> #include <cstdlib> #include <cstdio> #include <fstream> #include <iostream> #include <sstream> #include <string> #include "../require.h" using namespace std;
133 i i i i
i i
Captulo 5. Iostreams
const string USAGE = "usage: showerr filename chapnum\n" "where filename is a C++ source file\n" "and chapnum is the chapter name its in.\n" "Finds lines commented with //! and removes\n" "the comment, appending //(#) where # is unique\n" "across all files, so you can determine\n" "if your compiler finds the error.\n" "showerr /r\n" "resets the unique counter."; class Showerr { const int CHAP; const string MARKER, FNAME; // File containing error number counter: const string ERRNUM; // File containing error lines: const string ERRFILE; stringstream edited; // Edited file int counter; public: Showerr(const string& f, const string& en, const string& ef, int c) : CHAP(c), MARKER("//!"), FNAME(f), ERRNUM(en), ERRFILE(ef), counter(0) {} void replaceErrors() { ifstream infile(FNAME.c_str()); assure(infile, FNAME.c_str()); ifstream count(ERRNUM.c_str()); if(count) count >> counter; int linecount = 1; string buf; ofstream errlines(ERRFILE.c_str(), ios::app); assure(errlines, ERRFILE.c_str()); while(getline(infile, buf)) { // Find marker at start of line: size_t pos = buf.find(MARKER); if(pos != string::npos) { // Erase marker: buf.erase(pos, MARKER.size() + 1); // Append counter & error info: ostringstream out; out << buf << " // (" << ++counter << ") " << "Chapter " << CHAP << " File: " << FNAME << " Line " << linecount << endl; edited << out.str(); errlines << out.str(); // Append error file } else edited << buf << "\n"; // Just copy ++linecount; } } void saveFiles() { ofstream outfile(FNAME.c_str()); // Overwrites assure(outfile, FNAME.c_str());
134 i i i i
i i 5.10.
outfile << edited.rdbuf(); ofstream count(ERRNUM.c_str()); // Overwrites assure(count, ERRNUM.c_str()); count << counter; // Save new counter } }; int main(int argc, char* argv[]) { const string ERRCOUNT("../errnum.txt"), ERRFILE("../errlines.txt"); requireMinArgs(argc, 1, USAGE.c_str()); if(argv[1][0] == / || argv[1][0] == -) { // Allow for other switches: switch(argv[1][1]) { case r: case R: cout << "reset counter" << endl; remove(ERRCOUNT.c_str()); // Delete files remove(ERRFILE.c_str()); return EXIT_SUCCESS; default: cerr << USAGE << endl; return EXIT_FAILURE; } } if(argc == 3) { Showerr s(argv[1], ERRCOUNT, ERRFILE, atoi(argv[2])); s.replaceErrors(); s.saveFiles(); } } ///:~
5.10.3.
//: C04:DataLogger.h // Datalogger record layout. #ifndef DATALOG_H #define DATALOG_H #include <ctime> #include <iosfwd> #include <string> using std::ostream; struct Coord { int deg, min, sec; Coord(int d = 0, int m = 0, int s = 0) : deg(d), min(m), sec(s) {} std::string toString() const; }; ostream& operator<<(ostream&, const Coord&); class DataPoint { std::time_t timestamp; // Time & day Coord latitude, longitude; double depth, temperature;
135 i i i i
i i
Captulo 5. Iostreams
public: DataPoint(std::time_t ts, const Coord& lat, const Coord& lon, double dep, double temp) : timestamp(ts), latitude(lat), longitude(lon), depth(dep), temperature(temp) {} DataPoint() : timestamp(0), depth(0), temperature(0) {} friend ostream& operator<<(ostream&, const DataPoint&); }; #endif // DATALOG_H ///:~
//: C04:DataLogger.cpp {O} // Datapoint implementations. #include "DataLogger.h" #include <iomanip> #include <iostream> #include <sstream> #include <string> using namespace std; ostream& operator<<(ostream& os, const Coord& c) { return os << c.deg << * << c.min << \ << c.sec << "; } string Coord::toString() const { ostringstream os; os << *this; return os.str(); } ostream& operator<<(ostream& os, const DataPoint& d) { os.setf(ios::fixed, ios::floatfield); char fillc = os.fill(0); // Pad on left with 0 tm* tdata = localtime(&d.timestamp); os << setw(2) << tdata->tm_mon + 1 << \\ << setw(2) << tdata->tm_mday << \\ << setw(2) << tdata->tm_year+1900 << << setw(2) << tdata->tm_hour << : << setw(2) << tdata->tm_min << : << setw(2) << tdata->tm_sec; os.fill( ); // Pad on left with streamsize prec = os.precision(4); os << " Lat:" << setw(9) << d.latitude.toString() << ", Long:" << setw(9) << d.longitude.toString() << ", depth:" << setw(9) << d.depth << ", temp:" << setw(9) << d.temperature; os.fill(fillc); os.precision(prec); return os; } ///:~
136 i i i i
i i 5.10.
#include <cstdlib> #include <ctime> #include <cstring> #include <fstream> #include "DataLogger.h" #include "../require.h" using namespace std; int main() { time_t timer; srand(time(&timer)); // Seed the random number generator ofstream data("data.txt"); assure(data, "data.txt"); ofstream bindata("data.bin", ios::binary); assure(bindata, "data.bin"); for(int i = 0; i < 100; i++, timer += 55) { // Zero to 199 meters: double newdepth = rand() % 200; double fraction = rand() % 100 + 1; newdepth += 1.0 / fraction; double newtemp = 150 + rand() % 200; // Kelvin fraction = rand() % 100 + 1; newtemp += 1.0 / fraction; const DataPoint d(timer, Coord(45,20,31), Coord(22,34,18), newdepth, newtemp); data << d << endl; bindata.write(reinterpret_cast<const char*>(&d), sizeof(d)); } } ///:~
//: C04:Datascan.cpp //{L} DataLogger #include <fstream> #include <iostream> #include "DataLogger.h" #include "../require.h" using namespace std; int main() { ifstream bindata("data.bin", ios::binary); assure(bindata, "data.bin"); DataPoint d; while(bindata.read(reinterpret_cast<char*>(&d), sizeof d)) cout << d << endl; } ///:~
137 i i i i
i i
Captulo 5. Iostreams
5.11.
5.11.1. 5.11.2.
//: C04:Locale.cpp {-g++}{-bor}{-edg} {RunByHand} // Illustrates effects of locales. #include <iostream> #include <locale> using namespace std; int main() { locale def; cout << def.name() << endl; locale current = cout.getloc(); cout << current.name() << endl; float val = 1234.56; cout << val << endl; // Change to French/France cout.imbue(locale("french")); current = cout.getloc(); cout << current.name() << endl; cout << val << endl; cout << "Enter the literal 7890,12: "; cin.imbue(cout.getloc()); cin >> val; cout << val << endl; cout.imbue(def); cout << val << endl; } ///:~
//: C04:Facets.cpp {-bor}{-g++}{-mwcc}{-edg} #include <iostream> #include <locale> #include <string> using namespace std; int main() { // Change to French/France locale loc("french"); cout.imbue(loc); string currency = use_facet<moneypunct<char> >(loc).curr_symbol(); char point = use_facet<moneypunct<char> >(loc).decimal_point(); cout << "I made " << currency << 12.34 << " today!" << endl; } ///:~
138 i i i i
i i 5.12.
5.12. 5.13.
//: C04:Exercise14.cpp #include <fstream> #include <iostream> #include <sstream> #include "../require.h" using namespace std; #define d(a) cout << #a " ==\t" << a << endl; void tellPointers(fstream& s) { d(s.tellp()); d(s.tellg()); cout << endl; } void tellPointers(stringstream& s) { d(s.tellp()); d(s.tellg()); cout << endl; } int main() { fstream in("Exercise14.cpp"); assure(in, "Exercise14.cpp"); in.seekg(10); tellPointers(in); in.seekp(20); tellPointers(in); stringstream memStream("Here is a sentence."); memStream.seekg(10); tellPointers(memStream); memStream.seekp(5); tellPointers(memStream); } ///:~
//: C04:Exercise15.txt Australia 5E56,7667230284,Langler,Tyson,31.2147,0.00042117361 2B97,7586701,Oneill,Zeke,553.429,0.0074673053156065 4D75,7907252710,Nickerson,Kelly,761.612,0.010276276 9F2,6882945012,Hartenbach,Neil,47.9637,0.0006471644 Austria 480F,7187262472,Oneill,Dee,264.012,0.00356226040013 1B65,4754732628,Haney,Kim,7.33843,0.000099015948475 DA1,1954960784,Pascente,Lester,56.5452,0.0007629529 3F18,1839715659,Elsea,Chelsy,801.901,0.010819887645 Belgium BDF,5993489554,Oneill,Meredith,283.404,0.0038239127 5AC6,6612945602,Parisienne,Biff,557.74,0.0075254727 6AD,6477082,Pennington,Lizanne,31.0807,0.0004193544 4D0E,7861652688,Sisca,Francis,704.751,0.00950906238 Bahamas 37D8,6837424208,Parisienne,Samson,396.104,0.0053445
139 i i i i
i i
Captulo 5. Iostreams
5E98,6384069,Willis,Pam,90.4257,0.00122009564059246 1462,1288616408,Stover,Hazal,583.939,0.007878970561 5FF3,8028775718,Stromstedt,Bunk,39.8712,0.000537974 1095,3737212,Stover,Denny,3.05387,0.000041205248883 7428,2019381883,Parisienne,Shane,363.272,0.00490155 ///:~
140 i i i i
i i
6.1.1.
template<class T, size_t N> class Stack { T data[N]; // Fixed capacity is N size_t count; public: void push(const T& t); // Etc. };
//: C05:Urand.h {-bor} // Unique randomizer. #ifndef URAND_H #define URAND_H #include <bitset> #include <cstddef> #include <cstdlib> #include <ctime> using std::size_t; using std::bitset; template<size_t UpperBound> class Urand { bitset<UpperBound> used;
141 i i i i
i i
//: C05:UrandTest.cpp {-bor} #include <iostream> #include "Urand.h" using namespace std; int main() { Urand<10> u; for(int i = 0; i < 20; ++i) cout << u() << ; } ///:~
6.1.2.
template<class T, size_t N = 100> class Stack { T data[N]; // Fixed capacity is N size_t count; public: void push(const T& t); // Etc. };
template<class T = int, size_t N = 100> class Stack { T data[N]; // Fixed capacity is N size_t count; public: void push(const T& t); // Etc. }; Stack<> myStack;
// Both defaulted
142 i i i i
i i 6.1.
template<class T, class Allocator = allocator<T> > class vector;
//: C05:FuncDef.cpp #include <iostream> using namespace std; template<class T> T sum(T* b, T* e, T init = T()) { while(b != e) init += *b++; return init; } int main() { int a[] = { 1, 2, 3 }; cout << sum(a, a + sizeof a / sizeof a[0]) << endl; // 6 } ///:~
6.1.3.
//: C05:TempTemp.cpp // Illustrates a template template parameter. #include <cstddef> #include <iostream> using namespace std; template<class T> class Array { // A simple, expandable sequence enum { INIT = 10 }; T* data; size_t capacity; size_t count; public: Array() { count = 0; data = new T[capacity = INIT]; } ~Array() { delete [] data; } void push_back(const T& t) { if(count == capacity) { // Grow underlying array size_t newCap = 2 * capacity; T* newData = new T[newCap]; for(size_t i = 0; i < count; ++i) newData[i] = data[i]; delete [] data; data = newData; capacity = newCap; } data[count++] = t; } void pop_back() { if(count > 0)
143 i i i i
i i
Seq<T> seq;
T operator++(int);
//: C05:TempTemp2.cpp // A multi-variate template template parameter. #include <cstddef> #include <iostream> using namespace std; template<class T, size_t N> class Array { T data[N]; size_t count; public: Array() { count = 0; } void push_back(const T& t) { if(count < N) data[count++] = t; } void pop_back() { if(count > 0) --count;
144 i i i i
i i 6.1.
} T* begin() { return data; } T* end() { return data + count; } }; template<class T,size_t N,template<class,size_t> class Seq> class Container { Seq<T,N> seq; public: void append(const T& t) { seq.push_back(t); } T* begin() { return seq.begin(); } T* end() { return seq.end(); } }; int main() { const size_t N = 10; Container<int, N, Array> container; container.append(1); container.append(2); int* p = container.begin(); while(p != container.end()) cout << *p++ << endl; } ///:~
//: C05:TempTemp3.cpp {-bor}{-msc} // Template template parameters and default arguments. #include <cstddef> #include <iostream> using namespace std; template<class T, size_t N = 10> // A default argument class Array { T data[N]; size_t count; public: Array() { count = 0; } void push_back(const T& t) { if(count < N) data[count++] = t; } void pop_back() { if(count > 0) --count; } T* begin() { return data; } T* end() { return data + count; } }; template<class T, template<class, size_t = 10> class Seq> class Container { Seq<T> seq; // Default used public: void append(const T& t) { seq.push_back(t); } T* begin() { return seq.begin(); } T* end() { return seq.end(); } };
145 i i i i
i i
int main() { Container<int, Array> container; container.append(1); container.append(2); int* p = container.begin(); while(p != container.end()) cout << *p++ << endl; } ///:~
//: C05:TempTemp4.cpp {-bor}{-msc} // Passes standard sequences as template arguments. #include <iostream> #include <list> #include <memory> // Declares allocator<T> #include <vector> using namespace std; template<class T, template<class U, class = allocator<U> > class Seq> class Container { Seq<T> seq; // Default of allocator<T> applied implicitly public: void push_back(const T& t) { seq.push_back(t); } typename Seq<T>::iterator begin() { return seq.begin(); } typename Seq<T>::iterator end() { return seq.end(); } }; int main() { // Use a vector Container<int, vector> vContainer; vContainer.push_back(1); vContainer.push_back(2); for(vector<int>::iterator p = vContainer.begin(); p != vContainer.end(); ++p) { cout << *p << endl; } // Use a list Container<int, list> lContainer; lContainer.push_back(3); lContainer.push_back(4); for(list<int>::iterator p2 = lContainer.begin(); p2 != lContainer.end(); ++p2) { cout << *p2 << endl; } } ///:~
6.1.4.
146 i i i i
i i 6.1.
//: C05:TypenamedID.cpp {-bor} // Uses typename as a prefix for nested types. template<class T> class X { // Without typename, you should get an error: typename T::id i; public: void f() { i.g(); } }; class Y { public: class id { public: void g() {} }; }; int main() { X<Y> xy; xy.f(); } ///:~
//: C05:PrintSeq.cpp {-msc}{-mwcc} // A print function for Standard C++ sequences. #include <iostream> #include <list> #include <memory> #include <vector> using namespace std; template<class T, template<class U, class = allocator<U> > class Seq> void printSeq(Seq<T>& seq) { for(typename Seq<T>::iterator b = seq.begin(); b != seq.end();) cout << *b++ << endl; } int main() { // Process a vector vector<int> v; v.push_back(1); v.push_back(2); printSeq(v); // Process a list list<int> lst; lst.push_back(3); lst.push_back(4); printSeq(lst); } ///:~
147 i i i i
i i
//: C05:UsingTypename.cpp // Using typename in the template argument list. template<typename T> class X {}; int main() { X<int> x; } ///:~
6.1.5.
//: C05:DotTemplate.cpp // Illustrate the .template construct. #include <bitset> #include <cstddef> #include <iostream> #include <string> using namespace std; template<class charT, size_t N> basic_string<charT> bitsetToString(const bitset<N>& bs) { return bs. template to_string<charT, char_traits<charT>, allocator<charT> >(); } int main() { bitset<10> bs; bs.set(1); bs.set(5); cout << bs << endl; // 0000100010 string s = bitsetToString<char>(bs); cout << s << endl; // 0000100010 } ///:~
template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> to_string() const;
wstring s = bitsetToString<wchar_t>(bs);
148 i i i i
i i 6.1.
6.1.6.
template<typename T> class complex { public: template<class X> complex(const complex<X>&);
template<typename T> template<typename X> complex<T>::complex(const complex<X>& c) {/* Body here */}
//: C05:MemberClass.cpp // A member class template. #include <iostream> #include <typeinfo> using namespace std; template<class T> class Outer { public: template<class R> class Inner { public: void f(); }; }; template<class T> template<class R> void Outer<T>::Inner<R>::f() { cout << "Outer == " << typeid(T).name() << endl; cout << "Inner == " << typeid(R).name() << endl; cout << "Full Inner == " << typeid(*this).name() << endl; } int main() { Outer<int>::Inner<bool> inner; inner.f(); } ///:~
149 i i i i
i i
6.2.
template<typename T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; }
6.2.1.
int z = min(i, j);
template<typename T, typename U> const T& min(const T& a, const U& b) { return (a < b) ? a : b; }
//: C05:StringConv.h // Function templates to convert to and from strings. #ifndef STRINGCONV_H #define STRINGCONV_H #include <string> #include <sstream> template<typename T> T fromString(const std::string& s) { std::istringstream is(s); T t; is >> t; return t; } template<typename T> std::string toString(const T& t) { std::ostringstream s; s << t; return s.str(); } #endif // STRINGCONV_H ///:~
150 i i i i
i i 6.2.
//: C05:StringConvTest.cpp #include <complex> #include <iostream> #include "StringConv.h" using namespace std; int main() { int i = 1234; cout << "i == \"" << toString(i) << "\"" << endl; float x = 567.89; cout << "x == \"" << toString(x) << "\"" << endl; complex<float> c(1.0, 2.0); cout << "c == \"" << toString(c) << "\"" << endl; cout << endl; i = fromString<int>(string("1234")); cout << "i == " << i << endl; x = fromString<float>(string("567.89")); cout << "x == " << x << endl; c = fromString<complex<float> >(string("(1.0,2.0)")); cout << "c == " << c << endl; } ///:~
//: C05:ImplicitCast.cpp template<typename R, typename P> R implicit_cast(const P& p) { return p; } int main() { int i = 1; float x = implicit_cast<float>(i); int j = implicit_cast<int>(x); //! char* p = implicit_cast<char*>(i); } ///:~
//: C05:ArraySize.cpp #include <cstddef> using std::size_t; template<size_t R, size_t C, typename T> void init1(T a[R][C]) { for(size_t i = 0; i < R; ++i) for(size_t j = 0; j < C; ++j)
151 i i i i
i i
6.2.2.
//: C05:MinTest.cpp #include <cstring> #include <iostream> using std::strcmp; using std::cout; using std::endl; template<typename T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; } const char* min(const char* a, const char* b) { return (strcmp(a, b) < 0) ? a : b; } double min(double x, double y) { return (x < y) ? x : y; } int main() { const char *s2 = "say \"Ni-!\"", *s1 = "knights who"; cout << min(1, 2) << endl; // 1: 1 (template) cout << min(1.0, 2.0) << endl; // 2: 1 (double) cout << min(1, 2.0) << endl; // 3: 1 (double) cout << min(s1, s2) << endl; // 4: knights who (const // char*) cout << min<>(s1, s2) << endl; // 5: say "Ni-!" // (template) } ///:~
template<typename T> const T& min(const T& a, const T& b, const T& c);
152 i i i i
i i 6.2.
6.2.3.
//: C05:TemplateFunctionAddress.cpp {-mwcc} // Taking the address of a function generated // from a template. template<typename T> void f(T*) {} void h(void (*pf)(int*)) {} template<typename T> void g(void (*pf)(T*)) {} int main() { h(&f<int>); // Full type specification h(&f); // Type deduction g<int>(&f<int>); // Full type specification g(&f<int>); // Type deduction g<int>(&f); // Partial (but sufficient) specification } ///:~
//: C05:FailedTransform.cpp {-xo} #include <algorithm> #include <cctype> #include <iostream> #include <string> using namespace std; int main() { string s("LOWER"); transform(s.begin(), s.end(), s.begin(), tolower); cout << s << endl; } ///:~
template<class charT> charT toupper(charT const template<class charT> charT tolower(charT const
transform(s.begin(),s.end(),s.begin() static_cast<int(*)(int)>(tolower));
//: C05:StrTolower.cpp {O} {-mwcc} #include <algorithm> #include <cctype> #include <string> using namespace std;
153 i i i i
i i
//: C05:Tolower.cpp {-mwcc} //{L} StrTolower #include <algorithm> #include <cctype> #include <iostream> #include <string> using namespace std; string strTolower(string); int main() { string s("LOWER"); cout << strTolower(s) << endl; } ///:~
//: C05:ToLower2.cpp {-mwcc} #include <algorithm> #include <cctype> #include <iostream> #include <string> using namespace std; template<class charT> charT strTolower(charT c) { return tolower(c); // One-arg version called } int main() { string s("LOWER"); transform(s.begin(),s.end(),s.begin(),&strTolower<char>); cout << s << endl; } ///:~
6.2.4.
//: C05:ApplySequence.h // Apply a function to an STL sequence container. // const, 0 arguments, any type of return value: template<class Seq, class T, class R> void apply(Seq& sq, R (T::*f)() const) { typename Seq::iterator it = sq.begin(); while(it != sq.end()) ((*it++)->*f)(); }
154 i i i i
i i 6.2.
// const, 1 argument, any type of return value: template<class Seq, class T, class R, class A> void apply(Seq& sq, R(T::*f)(A) const, A a) { typename Seq::iterator it = sq.begin(); while(it != sq.end()) ((*it++)->*f)(a); } // const, 2 arguments, any type of return value: template<class Seq, class T, class R, class A1, class A2> void apply(Seq& sq, R(T::*f)(A1, A2) const, A1 a1, A2 a2) { typename Seq::iterator it = sq.begin(); while(it != sq.end()) ((*it++)->*f)(a1, a2); } // Non-const, 0 arguments, any type of return value: template<class Seq, class T, class R> void apply(Seq& sq, R (T::*f)()) { typename Seq::iterator it = sq.begin(); while(it != sq.end()) ((*it++)->*f)(); } // Non-const, 1 argument, any type of return value: template<class Seq, class T, class R, class A> void apply(Seq& sq, R(T::*f)(A), A a) { typename Seq::iterator it = sq.begin(); while(it != sq.end()) ((*it++)->*f)(a); } // Non-const, 2 arguments, any type of return value: template<class Seq, class T, class R, class A1, class A2> void apply(Seq& sq, R(T::*f)(A1, A2), A1 a1, A2 a2) { typename Seq::iterator it = sq.begin(); while(it != sq.end()) ((*it++)->*f)(a1, a2); } // Etc., to handle maximum likely arguments ///:~
//: C05:Gromit.h // The techno-dog. Has member functions // with various numbers of arguments. #include <iostream> class Gromit { int arf; int totalBarks; public: Gromit(int arf = 1) : arf(arf + 1), totalBarks(0) {} void speak(int) {
155 i i i i
i i
//: C05:ApplyGromit.cpp // Test ApplySequence.h. #include <cstddef> #include <iostream> #include <vector> #include "ApplySequence.h" #include "Gromit.h" #include "../purge.h" using namespace std; int main() { vector<Gromit*> dogs; for(size_t i = 0; i < 5; i++) dogs.push_back(new Gromit(i)); apply(dogs, &Gromit::speak, 1); apply(dogs, &Gromit::eat, 2.0f); apply(dogs, &Gromit::sleep, z, 3.0); apply(dogs, &Gromit::sit); purge(dogs); } ///:~
6.2.5.
template<class T> void f(T); template<class T> void f(T*); template<class T> void f(const T*);
//: C05:PartialOrder.cpp // Reveals ordering of function templates. #include <iostream> using namespace std;
156 i i i i
i i 6.3.
template<class T> void f(T) { cout << "T" << endl; } template<class T> void f(T*) { cout << "T*" << endl; } template<class T> void f(const T*) { cout << "const T*" << endl; } int main() { f(0); // T int i = 0; f(&i); // T* const int j = 0; f(&j); // const T* } ///:~
6.3.
6.3.1.
const char* min(const char* a, const char* b) { return (strcmp(a, b) < 0) ? a : b; }
//: C05:MinTest2.cpp #include <cstring> #include <iostream> using std::strcmp; using std::cout; using std::endl; template<class T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; } // An explicit specialization of the min template template<> const char* const& min<const char*>(const char* const& a, const char* const& b) { return (strcmp(a, b) < 0) ? a : b; } int main() { const char *s2 = "say \"Ni-!\"", *s1 = "knights who"; cout << min(s1, s2) << endl; cout << min<>(s1, s2) << endl; } ///:~
157 i i i i
i i
6.3.2.
template<class Allocator> class vector<bool, Allocator>;
//: C05:PartialOrder2.cpp // Reveals partial ordering of class templates. #include <iostream> using namespace std; template<class T, class U> class C { public: void f() { cout << "Primary Template\n"; } }; template<class U> class C<int, U> { public: void f() { cout << "T == int\n"; } }; template<class T> class C<T, double> { public: void f() { cout << "U == double\n"; } }; template<class T, class U> class C<T*, U> { public: void f() { cout << "T* used\n"; } }; template<class T, class U> class C<T, U*> { public: void f() { cout << "U* used\n"; } }; template<class T, class U> class C<T*, U*> { public: void f() { cout << "T* and U* used\n"; } }; template<class T> class C<T, T> { public: void f() { cout << "T == U\n"; } }; int main() { C<float, int>().f(); C<int, float>().f();
158 i i i i
i i 6.3.
C<float, double>().f(); // 3: U == double C<float, float>().f(); // 4: T == U C<float*, float>().f(); // 5: T* used [T is float] C<float, float*>().f(); // 6: U* used [U is float] C<float*, int*>().f(); // 7: T* and U* used [float,int] // The following are ambiguous: // 8: C<int, int>().f(); // 9: C<double, double>().f(); // 10: C<float*, float*>().f(); // 11: C<int, int*>().f(); // 12: C<int*, int*>().f(); } ///:~
6.3.3.
//: C05:Sortable.h // Template specialization. #ifndef SORTABLE_H #define SORTABLE_H #include <cstring> #include <cstddef> #include <string> #include <vector> using std::size_t; template<class T> class Sortable : public std::vector<T> { public: void sort(); }; template<class T> void Sortable<T>::sort() { // A simple sort for(size_t i = this->size(); i > 0; --i) for(size_t j = 1; j < i; ++j) if(this->at(j-1) > this->at(j)) { T t = this->at(j-1); this->at(j-1) = this->at(j); this->at(j) = t; } } // Partial specialization for pointers: template<class T> class Sortable<T*> : public std::vector<T*> { public: void sort(); }; template<class T> void Sortable<T*>::sort() { for(size_t i = this->size(); i > 0; --i) for(size_t j = 1; j < i; ++j) if(*this->at(j-1) > *this->at(j)) { T* t = this->at(j-1);
159 i i i i
i i
//: C05:Sortable.cpp //{-bor} (Because of bitset in Urand.h) // Testing template specialization. #include <cstddef> #include <iostream> #include "Sortable.h" #include "Urand.h" using namespace std; #define asz(a) (sizeof a / sizeof a[0]) char* words[] = { "is", "running", "big", "dog", "a", }; char* words2[] = { "this", "that", "theother", }; int main() { Sortable<int> is; Urand<47> rnd; for(size_t i = 0; i < 15; ++i) is.push_back(rnd()); for(size_t i = 0; i < is.size(); ++i) cout << is[i] << ; cout << endl; is.sort(); for(size_t i = 0; i < is.size(); ++i) cout << is[i] << ; cout << endl; // Uses the template partial specialization: Sortable<string*> ss; for(size_t i = 0; i < asz(words); ++i) ss.push_back(new string(words[i])); for(size_t i = 0; i < ss.size(); ++i) cout << *ss[i] << ; cout << endl; ss.sort(); for(size_t i = 0; i < ss.size(); ++i) {
160 i i i i
i i 6.3.
cout << *ss[i] << ; delete ss[i]; } cout << endl; // Uses the full char* specialization: Sortable<char*> scp; for(size_t i = 0; i < asz(words2); ++i) scp.push_back(words2[i]); for(size_t i = 0; i < scp.size(); ++i) cout << scp[i] << ; cout << endl; scp.sort(); for(size_t i = 0; i < scp.size(); ++i) cout << scp[i] << ; cout << endl; } ///:~
6.3.4.
//: C05:DelayedInstantiation.cpp // Member functions of class templates are not // instantiated until theyre needed. class X { public: void f() {} }; class Y { public: void g() {} }; template<typename T> class Z { T t; public: void a() { t.f(); } void b() { t.g(); } }; int main() { Z<X> zx; zx.a(); // Doesnt create Z<X>::b() Z<Y> zy; zy.b(); // Doesnt create Z<Y>::a() } ///:~
//: C05:Nobloat.h // Shares code for storing pointers in a Stack. #ifndef NOBLOAT_H #define NOBLOAT_H
161 i i i i
i i
162 i i i i
i i 6.3.
delete [] data; data = newData; capacity = newCapacity; } assert(count < capacity); data[count++] = t; } void pop() { assert(count > 0); --count; } void* top() const { assert(count > 0); return data[count-1]; } std::size_t size() const { return count; } }; // Partial specialization for other pointer types template<class T> class Stack<T*> : private Stack<void *> { typedef Stack<void *> Base; public: void push(T* const & t) { Base::push(t); } void pop() {Base::pop();} T* top() const { return static_cast<T*>(Base::top()); } std::size_t size() { return Base::size(); } }; #endif // NOBLOAT_H ///:~
//: C05:NobloatTest.cpp #include <iostream> #include <string> #include "Nobloat.h" using namespace std; template<class StackType> void emptyTheStack(StackType& stk) { while(stk.size() > 0) { cout << stk.top() << endl; stk.pop(); } } // An overload for emptyTheStack (not a specialization!) template<class T> void emptyTheStack(Stack<T*>& stk) { while(stk.size() > 0) { cout << *stk.top() << endl; stk.pop(); } } int main() { Stack<int> s1; s1.push(1); s1.push(2);
163 i i i i
i i
6.4.
6.4.1.
MyClass::f(); x.f(); p->f();
#include <iostream> #include <string> // ... std::string s("hello"); std::cout << s << std::endl;
std::operator<<(std::operator<<(std::cout,s),std::endl);
operator<<(std::cout, s);
//: C05:Lookup.cpp // Only produces correct behavior with EDG, // and Metrowerks using a special option. #include <iostream> using std::cout; using std::endl; void f(double) { cout << "f(double)" << endl; } template<class T> class X { public: void g() { f(1); } }; void f(int) { cout << "f(int)" << endl; } int main() { X<int>().g();
164 i i i i
i i 6.4.
} ///:~
f(double)
//: C05:Lookup2.cpp {-bor}{-g++}{-dmc} // Microsoft: use option -Za (ANSI mode) #include <algorithm> #include <iostream> #include <typeinfo> using std::cout; using std::endl; void g() { cout << "global g()" << endl; } template<class T> class Y { public: void g() { cout << "Y<" << typeid(T).name() << ">::g()" << endl; } void h() { cout << "Y<" << typeid(T).name() << ">::h()" << endl; } typedef int E; }; typedef double E; template<class T> void swap(T& t1, T& t2) { cout << "global swap" << endl; T temp = t1; t1 = t2; t2 = temp; } template<class T> class X : public Y<T> { public: E f() { g(); this->h(); T t1 = T(), t2 = T(1); cout << t1 << endl; swap(t1, t2); std::swap(t1, t2); cout << typeid(E).name() << endl; return E(t2); } }; int main() { X<int> x; cout << x.f() << endl; } ///:~
165 i i i i
i i
6.4.2.
//: C05:FriendScope.cpp #include <iostream> using namespace std; class Friendly { int i; public: Friendly(int theInt) { i = theInt; } friend void f(const Friendly&); // Needs global def. void g() { f(*this); } }; void h() { f(Friendly(1)); }
// Uses ADL
void f(const Friendly& fo) { cout << fo.i << endl; } int main() { h(); // Prints 1 Friendly(2).g(); // Prints 2 } ///:~
// Definition of friend
//: C05:FriendScope2.cpp #include <iostream> using namespace std; // Necessary forward declarations: template<class T> class Friendly; template<class T> void f(const Friendly<T>&); template<class T> class Friendly { T t; public: Friendly(const T& theT) : t(theT) {} friend void f<>(const Friendly<T>&); void g() { f(*this); } }; void h() { f(Friendly<int>(1)); }
166 i i i i
i i 6.4.
template<class T> void f(const Friendly<T>& fo) { cout << fo.t << endl; } int main() { h(); Friendly<int>(2).g(); } ///:~
//: C05:FriendScope3.cpp {-bor} // Microsoft: use the -Za (ANSI-compliant) option #include <iostream> using namespace std; template<class T> class Friendly { T t; public: Friendly(const T& theT) : t(theT) {} friend void f(const Friendly<T>& fo) { cout << fo.t << endl; } void g() { f(*this); } }; void h() { f(Friendly<int>(1)); } int main() { h(); Friendly<int>(2).g(); } ///:~
//: C05:Box1.cpp // Defines template operators. #include <iostream> using namespace std; // Forward declarations template<class T> class Box; template<class T> Box<T> operator+(const Box<T>&, const Box<T>&); template<class T> ostream& operator<<(ostream&, const Box<T>&);
167 i i i i
i i
template<class T> class Box { T t; public: Box(const T& theT) : t(theT) {} friend Box operator+<>(const Box<T>&, const Box<T>&); friend ostream& operator<< <>(ostream&, const Box<T>&); }; template<class T> Box<T> operator+(const Box<T>& b1, const Box<T>& b2) { return Box<T>(b1.t + b2.t); } template<class T> ostream& operator<<(ostream& os, const Box<T>& b) { return os << [ << b.t << ]; } int main() { Box<int> b1(1), b2(2); cout << b1 + b2 << endl; // [3] // cout << b1 + 2 << endl; // No implicit conversions! } ///:~
//: C05:Box2.cpp // Defines non-template operators. #include <iostream> using namespace std; template<class T> class Box { T t; public: Box(const T& theT) : t(theT) {} friend Box<T> operator+(const Box<T>& b1, const Box<T>& b2) { return Box<T>(b1.t + b2.t); } friend ostream& operator<<(ostream& os, const Box<T>& b) { return os << [ << b.t << ]; } }; int main() { Box<int> b1(1), b2(2); cout << b1 + b2 << endl; // [3] cout << b1 + 2 << endl; // [3] } ///:~
168 i i i i
i i 6.5.
template<class T> class Friendly { template<class U> friend void f<>(const Friendly<U>&);
6.5.
6.5.1.
template<class T> class numeric_limits { public: static const bool is_specialized = false; static T min() throw(); static T max() throw(); static const int digits = 0; static const int digits10 = 0; static const bool is_signed = false; static const bool is_integer = false; static const bool is_exact = false; static const int radix = 0; static T epsilon() throw(); static T round_error() throw(); static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const bool has_infinity = false; static const bool has_quiet_NaN = false; static const bool has_signaling_NaN = false; static const float_denorm_style has_denorm = denorm_absent; static const bool has_denorm_loss = false; static T infinity() throw(); static T quiet_NaN() throw(); static T signaling_NaN() throw(); static T denorm_min() throw(); static const bool is_iec559 = false; static const bool is_bounded = false; static const bool is_modulo = false; static const bool traps = false; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; };
template<class charT, class traits = char_traits<charT>, class allocator = allocator<charT> > class basic_string;
169 i i i i
i i
template<> struct char_traits<char> { typedef char char_type; typedef int int_type; typedef streamoff off_type; typedef streampos pos_type; typedef mbstate_t state_type; static void assign(char_type& c1, const char_type& c2); static bool eq(const char_type& c1, const char_type& c2); static bool lt(const char_type& c1, const char_type& c2); static int compare(const char_type* s1, const char_type* s2, size_t n); static size_t length(const char_type* s); static const char_type* find(const char_type* s, size_t n, const char_type& a); static char_type* move(char_type* s1, const char_type* s2, size_t n); static char_type* copy(char_type* s1, const char_type* s2, size_t n); static char_type* assign(char_type* s, size_t n, char_type a); static int_type not_eof(const int_type& c); static char_type to_char_type(const int_type& c); static int_type to_int_type(const char_type& c); static bool eq_int_type(const int_type& c1, const int_type& c2); static int_type eof(); };
std::string s;
//: C05:BearCorner.h #ifndef BEARCORNER_H #define BEARCORNER_H #include <iostream> using std::ostream; // Item classes (traits of guests): class Milk { public: friend ostream& operator<<(ostream& os, const Milk&) { return os << "Milk"; } }; class CondensedMilk { public: friend ostream& operator<<(ostream& os, const CondensedMilk &) { return os << "Condensed Milk";
170 i i i i
i i 6.5.
} }; class Honey { public: friend ostream& operator<<(ostream& os, const Honey&) { return os << "Honey"; } }; class Cookies { public: friend ostream& operator<<(ostream& os, const Cookies&) { return os << "Cookies"; } }; // Guest classes: class Bear { public: friend ostream& operator<<(ostream& os, const Bear&) { return os << "Theodore"; } }; class Boy { public: friend ostream& operator<<(ostream& os, const Boy&) { return os << "Patrick"; } }; // Primary traits template (empty-could hold common types) template<class Guest> class GuestTraits; // Traits specializations for Guest types template<> class GuestTraits<Bear> { public: typedef CondensedMilk beverage_type; typedef Honey snack_type; }; template<> class GuestTraits<Boy> { public: typedef Milk beverage_type; typedef Cookies snack_type; }; #endif // BEARCORNER_H ///:~
6.5.2.
template<> struct char_traits<wchar_t> { typedef wchar_t char_type; typedef wint_t int_type; typedef streamoff off_type;
171 i i i i
i i
//: C05:BearCorner2.cpp // Illustrates policy classes. #include <iostream> #include "BearCorner.h" using namespace std; // Policy classes (require a static doAction() function): class Feed { public: static const char* doAction() { return "Feeding"; } }; class Stuff { public: static const char* doAction() { return "Stuffing"; } }; // The Guest template (uses a policy and a traits class) template<class Guest, class Action, class traits = GuestTraits<Guest> > class BearCorner { Guest theGuest; typedef typename traits::beverage_type beverage_type; typedef typename traits::snack_type snack_type; beverage_type bev; snack_type snack; public: BearCorner(const Guest& g) : theGuest(g) {} void entertain() { cout << Action::doAction() << " " << theGuest << " with " << bev << " and " << snack << endl;
172 i i i i
i i 6.5.
} }; int main() { Boy cr; BearCorner<Boy, Feed> pc1(cr); pc1.entertain(); Bear pb; BearCorner<Bear, Stuff> pc2(pb); pc2.entertain(); } ///:~
6.5.3.
//: C05:CountedClass.cpp // Object counting via static members. #include <iostream> using namespace std; class CountedClass { static int count; public: CountedClass() { ++count; } CountedClass(const CountedClass&) { ++count; } ~CountedClass() { --count; } static int getCount() { return count; } }; int CountedClass::count = 0; int main() { CountedClass a; cout << CountedClass::getCount() << endl; CountedClass b; cout << CountedClass::getCount() << endl; { // An arbitrary scope: CountedClass c(b); cout << CountedClass::getCount() << endl; a = c; cout << CountedClass::getCount() << endl; } cout << CountedClass::getCount() << endl; } ///:~
// 1 // 2
// 3 // 3 // 2
//: C05:CountedClass2.cpp // Erroneous attempt to count objects. #include <iostream> using namespace std; class Counted { static int count; public:
173 i i i i
i i
// 1 // 2 // 3 (Error)
//: C05:CountedClass3.cpp #include <iostream> using namespace std; template<class T> class Counted { static int count; public: Counted() { ++count; } Counted(const Counted<T>&) { ++count; } ~Counted() { --count; } static int getCount() { return count; } }; template<class T> int Counted<T>::count = 0; // Curious class definitions class CountedClass : public Counted<CountedClass> {}; class CountedClass2 : public Counted<CountedClass2> {}; int main() { CountedClass a; cout << CountedClass::getCount() << endl; CountedClass b; cout << CountedClass::getCount() << endl; CountedClass2 c; cout << CountedClass2::getCount() << endl; } ///:~
// 1 // 2 // 1 (!)
6.6.
//: C05:Factorial.cpp // Compile-time computation using templates.
174 i i i i
i i 6.6.
#include <iostream> using namespace std; template<int n> struct Factorial { enum { val = Factorial<n-1>::val * n }; }; template<> struct Factorial<0> { enum { val = 1 }; }; int main() { cout << Factorial<12>::val << endl; // 479001600 } ///:~
6.6.1.
//: C05:Fibonacci.cpp #include <iostream> using namespace std; template<int n> struct Fib { enum { val = Fib<n-1>::val + Fib<n-2>::val }; }; template<> struct Fib<1> { enum { val = 1 }; }; template<> struct Fib<0> { enum { val = 0 }; }; int main() { cout << Fib<5>::val << endl; cout << Fib<20>::val << endl; } ///:~
// 6 // 6765
175 i i i i
i i
template<int N, int P> struct Power { enum { val = N * Power<N, P-1>::val }; }; template<int N> struct Power<N, 0> { enum { val = 1 }; }; int main() { cout << Power<2, 5>::val << endl; } ///:~
// 32
//: C05:Accumulate.cpp // Passes a "function" as a parameter at compile time. #include <iostream> using namespace std; // Accumulates the results of F(0)..F(n) template<int n, template<int> class F> struct Accumulate { enum { val = Accumulate<n-1, F>::val + F<n>::val }; }; // The stopping criterion (returns the value F(0)) template<template<int> class F> struct Accumulate<0, F> { enum { val = F<0>::val }; }; // Various "functions": template<int n> struct Identity { enum { val = n }; }; template<int n> struct Square { enum { val = n*n }; }; template<int n> struct Cube { enum { val = n*n*n }; }; int main() { cout << Accumulate<4, Identity>::val << endl; // 10 cout << Accumulate<4, Square>::val << endl; // 30 cout << Accumulate<4, Cube>::val << endl; // 100 } ///:~
void mult(int a[ROWS][COLS], int x[COLS], int y[COLS]) { for(int i = 0; i < ROWS; ++i) { y[i] = 0; for(int j = 0; j < COLS; ++j)
176 i i i i
i i 6.6.
y[i] += a[i][j]*x[j]; } }
void mult(int a[ROWS][COLS], int x[COLS], int y[COLS]) { for(int i = 0; i < ROWS; ++i) { y[i] = 0; for(int j = 0; j < COLS; j += 2) y[i] += a[i][j]*x[j] + a[i][j+1]*x[j+1]; } }
//: C05:Unroll.cpp // Unrolls an implicit loop via inlining. #include <iostream> using namespace std; template<int n> inline int power(int m) { return power<n-1>(m) * m; } template<> inline int power<1>(int m) { return m; } template<> inline int power<0>(int m) { return 1; } int main() { int m = 4; cout << power<3>(m) << endl; } ///:~
//: C05:Max.cpp #include <iostream> using namespace std; template<int n1, int n2> struct Max { enum { val = n1 > n2 ? n1 : n2 }; }; int main() { cout << Max<10, 20>::val << endl; } ///:~
// 20
177 i i i i
i i
//: C05:StaticAssert1.cpp {-xo} // A simple, compile-time assertion facility #define STATIC_ASSERT(x) \ do { typedef int a[(x) ? 1 : -1]; } while(0) int main() { STATIC_ASSERT(sizeof(int) <= sizeof(long)); // Passes STATIC_ASSERT(sizeof(double) <= sizeof(int)); // Fails } ///:~
//: C05:StaticAssert2.cpp {-g++} #include <iostream> using namespace std; // A template and a specialization
178 i i i i
i i 6.6.
template<bool> struct StaticCheck { StaticCheck(...); }; template<> struct StaticCheck<false> {}; // The macro (generates a local class) #define STATIC_CHECK(expr, msg) { \ class Error_##msg {}; \ sizeof((StaticCheck<expr>(Error_##msg()))); \ } // Detects narrowing conversions template<class To, class From> To safe_cast(From from) { STATIC_CHECK(sizeof(From) <= sizeof(To), NarrowingConversion); return reinterpret_cast<To>(from); } int main() { void* p = 0; int i = safe_cast<int>(p); cout << "int cast okay" << endl; //! char c = safe_cast<char>(p); } ///:~
int i = safe_cast<int>(p);
char c = safe_cast<char>(p);
sizeof(StaticCheck<false>(Error_NarrowingConversion()));
179 i i i i
i i
6.6.2.
D = A + B + C;
//: C05:MyVector.cpp // Optimizes away temporaries via templates. #include <cstddef> #include <cstdlib> #include <ctime> #include <iostream> using namespace std; // A proxy class for sums of vectors template<class, size_t> class MyVectorSum; template<class T, size_t N> class MyVector { T data[N]; public: MyVector<T,N>& operator=(const MyVector<T,N>& right) { for(size_t i = 0; i < N; ++i) data[i] = right.data[i]; return *this; } MyVector<T,N>& operator=(const MyVectorSum<T,N>& right); const T& operator[](size_t i) const { return data[i]; } T& operator[](size_t i) { return data[i]; } }; // Proxy class hold references; uses lazy addition template<class T, size_t N> class MyVectorSum { const MyVector<T,N>& left; const MyVector<T,N>& right; public: MyVectorSum(const MyVector<T,N>& lhs, const MyVector<T,N>& rhs) : left(lhs), right(rhs) {} T operator[](size_t i) const { return left[i] + right[i]; } }; // Operator to support v3 = v1 + v2 template<class T, size_t N> MyVector<T,N>& MyVector<T,N>::operator=(const MyVectorSum<T,N>& right) { for(size_t i = 0; i < N; ++i) data[i] = right[i]; return *this; } // operator+ just stores references template<class T, size_t N> inline MyVectorSum<T,N> operator+(const MyVector<T,N>& left, const MyVector<T,N>& right) { return MyVectorSum<T,N>(left, right); }
180 i i i i
i i 6.6.
// Convenience functions for the test program below template<class T, size_t N> void init(MyVector<T,N>& v) { for(size_t i = 0; i < N; ++i) v[i] = rand() % 100; } template<class T, size_t N> void print(MyVector<T,N>& v) { for(size_t i = 0; i < N; ++i) cout << v[i] << ; cout << endl; } int main() { srand(time(0)); MyVector<int, 5> v1; init(v1); print(v1); MyVector<int, 5> v2; init(v2); print(v2); MyVector<int, 5> v3; v3 = v1 + v2; print(v3); MyVector<int, 5> v4; // Not yet supported: //! v4 = v1 + v2 + v3; } ///:~
v3.operator=<int,5>(MyVectorSum<int,5>(v2, v3));
v4 = v1 + v2 + v3;
//: C05:MyVector2.cpp // Handles sums of any length with expression templates. #include <cstddef> #include <cstdlib> #include <ctime> #include <iostream> using namespace std; // A proxy class for sums of vectors template<class, size_t, class, class> class MyVectorSum; template<class T, size_t N> class MyVector { T data[N]; public:
181 i i i i
i i
182 i i i i
i i 6.7.
v[i] = rand() % 100; } template<class T, size_t N> void print(MyVector<T,N>& v) { for(size_t i = 0; i < N; ++i) cout << v[i] << ; cout << endl; } int main() { srand(time(0)); MyVector<int, 5> v1; init(v1); print(v1); MyVector<int, 5> v2; init(v2); print(v2); MyVector<int, 5> v3; v3 = v1 + v2; print(v3); // Now supported: MyVector<int, 5> v4; v4 = v1 + v2 + v3; print(v4); MyVector<int, 5> v5; v5 = v1 + v2 + v3 + v4; print(v5); } ///:~
v4 = v1 + v2 + v3;
6.7.
6.7.1. 6.7.2.
//: C05:OurMin.h #ifndef OURMIN_H #define OURMIN_H // The declaration of min() template<typename T> const T& min(const T&, const T&); #endif // OURMIN_H ///:~
183 i i i i
i i
//: C05:OurMin.cpp {O} #ifndef OURMIN_CPP #define OURMIN_CPP #include "OurMin.h" template<typename T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; } #endif // OURMIN_CPP ///:~
1 3.1
6.7.3.
//: C05:OurMin2.h // Declares min as an exported template // (Only works with EDG-based compilers) #ifndef OURMIN2_H #define OURMIN2_H export template<typename T> const T& min(const T&, const T&); #endif // OURMIN2_H ///:~
// C05:OurMin2.cpp // The definition of the exported min template // (Only works with EDG-based compilers) #include "OurMin2.h" export template<typename T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; } ///:~
6.7.4.
6.8.
//: C05:Exercise4.cpp {-xo} class Noncomparable {};
184 i i i i
i i 6.8.
struct HardLogic { Noncomparable nc1, nc2; void compare() { return nc1 == nc2; // Compiler error } }; template<class T> struct SoftLogic { Noncomparable nc1, nc2; void noOp() {} void compare() { nc1 == nc2; } }; int main() { SoftLogic<Noncomparable> l; l.noOp(); } ///:~
//: C05:Exercise7.cpp {-xo} class Buddy {}; template<class T> class My { int i; public: void play(My<Buddy>& s) { s.i = 3; } }; int main() { My<int> h; My<Buddy> me, bud; h.play(bud); me.play(bud); } ///:~
//: C05:Exercise8.cpp {-xo} template<class T> double pythag(T a, T b, T c) { return (-b + sqrt(double(b*b - 4*a*c))) / 2*a; } int main() { pythag(1, 2, 3); pythag(1.0, 2.0, 3.0); pythag(1, 2.0, 3.0); pythag<double>(1, 2.0, 3.0); } ///:~
185 i i i i
i i
i i i
i i
7: Algoritmos genricos
Los algoritmos son la base de la computacin. Ser capaz de escribir un algoritmo que funcione con cualquier tipo de se secuencia hace que sus programas sean simples y seguros. La habilidad para adaptar algoritmos en tiempo de ejecucin a revolucionado el desarrollo de software. El subconjunto de la Librera Estndar de C++ conocido como Standard Template Library (STL)1 fue diseado entorno a algoritmos genricos cdigo que procesa secuencias de cualquier tipo de valores de un modo seguro. El objetivo era usar algoritmos predenidos para casi cualquier tarea, en lugar de codicar a mano cada vez que se necesitara procesar una coleccin de datos. Sin embargo, ese potencial requiere cierto aprendizaje. Para cuando llegue al nal de este captulo, debera ser capaz de decidir por s mismo si los algoritmos le resultan tiles o demasiado confusos de recordar. Si es como la mayora de la gente, se resistir al principio pero entonces tender a usarlos ms y ms con el tiempo.
187 i i i i
i i
Los dos primeros parmetros de copy representan el rango de la secuencia de entrada en este caso del array a. Los rangos se especican con un par de punteros. El primero apunta al primer elemento de la secuencia, y el segungo apunta una posicin despus del nal del array (justo despus del ltimo elemento). Esto puede parecer extrao al principio, pero es una antigua expresin idiomtica de C que resulta bastante prctica. Por ejemplo, la diferencia entre esos dos punteros devuelve el nmero de elementos de la secuencia. Ms importante, en la implementacin de copy(), el segundo puntero puede actual como un centinela para para la iteracin a travs de la secuencia. El tercer argumento hace referencia al comienzo de la secuencia de salida, que es el array b en el ejemplo. Se asume que el array b tiene suciente espacio para recibir los elementos copiados. El algotirmo copy() no parece muy excitante if solo puediera procesar enteros. Puede copiar cualquier tipo de secuencia. El siguiente ejemplo copia objetos string.
//: C06:CopyStrings.cpp // Copies strings. #include <algorithm> #include <cassert> #include <cstddef> #include <string> using namespace std; int main() { string a[] = {"read", "my", "lips"}; const size_t SIZE = sizeof a / sizeof a[0]; string b[SIZE]; copy(a, a + SIZE, b); assert(equal(a, a + SIZE, b)); } ///:~
Este ejmeplo presenta otro algoritmo, equal(), que devuelve cierto solo si cada elemento de la primera secuencia es igual (usando su operator==()) a su elemento correspondiente en la segunda secuencia. Este ejemplo recorre cada secuencia 2 veces, una para copiar, y otra para comparar, sin ningn bucle explcito. Los algoritmos genricos consiguen esta exibilidad porque son funciones parametrizadas (plantillas). Si piensa en la implementacin de copy() ver que es algo como lo siguiente, que es casi correcto:
template<typename T> void copy(T* begin, T* end, T* dest) { while (begin != end) *dest++ = *begin++; }
Decimos casi porque copy() puede procesar secuencias delimitadas por cual188 i i i i
i i
7.1. Un primer vistazo quier cosa que acte como un puntero, tal como un iterador. De ese modo, copy() se puede utilizar para duplicar un vector, como en el siguiente ejemplo.
//: C06:CopyVector.cpp // Copies the contents of a vector. #include <algorithm> #include <cassert> #include <cstddef> #include <vector> using namespace std; int main() { int a[] = { 10, 20, 30 }; const size_t SIZE = sizeof a / sizeof a[0]; vector<int> v1(a, a + SIZE); vector<int> v2(SIZE); copy(v1.begin(), v1.end(), v2.begin()); assert(equal(v1.begin(), v1.end(), v2.begin())); } ///:~
El primer vector, v1, es inicializado a partir de una secuencia de enteros en el array a. La denicin del vector v2 usa un contructor diferente de vector que reserva sitio para SIZE elementos, inicializados a cero (el valor por defecto para enteros). Igual que con el ejemplo anterior con el array, es importante que v2 tenga suciente espacio para recibir una copia de los contenidos de v1. Por conveniencia, una funcin de librera especial, back_inserter(), retorna un tipo especial de iterador que inserta elementos en lugar de sobre-escribirlos, de modo que la memoria del contenedor se expande conforme se necesita. El siguiente ejemplo usa back_inserter(), y por eso no hay que establecer el tamao del vector de salida, v2, antes de tiempo.
//: C06:InsertVector.cpp // Appends the contents of a vector to another. #include <algorithm> #include <cassert> #include <cstddef> #include <iterator> #include <vector> using namespace std; int main() { int a[] = { 10, 20, 30 }; const size_t SIZE = sizeof a / sizeof a[0]; vector<int> v1(a, a + SIZE); vector<int> v2; // v2 is empty here copy(v1.begin(), v1.end(), back_inserter(v2)); assert(equal(v1.begin(), v1.end(), v2.begin())); } ///:~
La funcin back_inserter() est denida en el chero de cabecera <iterator>. Explicaremos los iteradores de insercin en profundidad en el prximo captulo. Dado que los iteradores son idnticos a punteros en todos los sentidos importan189 i i i i
i i
Captulo 7. Algoritmos genricos tes, puede escribir los algoritmos de la librera estndar de modo que los argumentos puedan ser tanto punteros como iteradores. Por esta razn, la implementacin de copy() se parece ms al siguiente cdigo:
template<typename Iterator> void copy(Iterator begin, Iterator end, Iterator dest) { while (begin != end) *begin++ = *dest++; }
Para cualquier tipo de argumento que use en la llamada, copy() asume que implementa adecuadamente la indireccin y los operadores de incremento. Si no lo hace, obtendrs un error de compilacin.
7.1.1. Predicados
A veces, podra querer copiar solo un subconjunto bien denido de una secuencia a otra; solo aquellos elementos que satisfagan una condicin particular. Para conseguir esta exibilidad, muchos algoritmos tienen una forma alternativa de llamada que permite proporcionar un predicado, que es simplemente una funcin que retorna un valor booleano basado en algn criterio. Suponga por ejemplo, que solo quiere extraer de una secuencia de enteros, aquellos que son menores o iguales de 15. Una versin de copy() llamada remove_copy_if() puede hacer el trabajo, tal que as:
//: C06:CopyInts2.cpp // Ignores ints that satisfy a predicate. #include <algorithm> #include <cstddef> #include <iostream> using namespace std; // You supply this predicate bool gt15(int x) { return 15 < x; } int main() { int a[] = { 10, 20, 30 }; const size_t SIZE = sizeof a / sizeof a[0]; int b[SIZE]; int* endb = remove_copy_if(a, a+SIZE, b, gt15); int* beginb = b; while(beginb != endb) cout << *beginb++ << endl; // Prints 10 only } ///:~
La funcin remove_copy_if() acepta los rangos denidos por punteros habituales, seguidos de un predicado de su eleccin. El predicado debe ser un puntero a funcin[FIXME] que toma un argumento simple del mismo tipo que los elementos de la secuencia, y que debe retornar un booleano. Aqu, la funcin gt15 returna verdadero si su argumento es mayor que 15. El algoritmo remove_copy_if() aplica gt15() a cada elemento en la secuencia de entrada e ignora aquellos elementos para los cuales el predicado devuelve verdad cuando escribe la secuencia de salida. El siguiente programa ilustra otra variacin ms del algoritmo de copia. 190 i i i i
i i
//: C06:CopyStrings2.cpp // Replaces strings that satisfy a predicate. #include <algorithm> #include <cstddef> #include <iostream> #include <string> using namespace std; // The predicate bool contains_e(const string& s) { return s.find(e) != string::npos; } int main() { string a[] = {"read", "my", "lips"}; const size_t SIZE = sizeof a / sizeof a[0]; string b[SIZE]; string* endb = replace_copy_if(a, a + SIZE, b, contains_e, string("kiss")); string* beginb = b; while(beginb != endb) cout << *beginb++ << endl; } ///:~
En lugar de simplemente ignorar elementos que no satisfagan el predicado, replace_copy_if() substituye un valor jo para esos elementos cuando escribe la secuencia de salida. La salida es:
kiss my lips
como la ocurrencia original de read, la nica cadena de entrada que contiene la letra e, es reemplazada por la palabra kiss, como se especic en el ltimo argumento en la llamada a replace_copy_if(). El algoritmo replace_if() cambia la secuencia original in situ, en lugar de escribir en una secuencia de salida separada, tal como muestra el siguiente programa:
//: C06:ReplaceStrings.cpp // Replaces strings in-place. #include <algorithm> #include <cstddef> #include <iostream> #include <string> using namespace std; bool contains_e(const string& s) { return s.find(e) != string::npos; } int main() { string a[] = {"read", "my", "lips"}; const size_t SIZE = sizeof a / sizeof a[0]; replace_if(a, a + SIZE, contains_e, string("kiss"));
191 i i i i
i i
En este ejemplo, reemplazaremos la secuencia de salida b en el tercer argumento de remove_copy_if() con un iterador de ujo de salida, que es una instancia de la clase ostream_iterator declarada en el chero <iterator>. Los iteradores de ujo de salida sobrecargan sus operadores de copia-asignacin para escribir a sus ujos. Esta instancia en particular de ostream_iterator est vinculada al ujo de salida cout. Cada vez que remove_copy_if() asigna un entero de la secuencia a a cout a travs de este iterador, el iterador escribe el entero a cout y automticamente escribe tambin una instancia de la cada de separador indicada en su segundo argumento, que en este caso contiene el carcter de nueva linea. Es igual de fcil escribir en un chero proporcionando un ujo de salida asociado a un chero en lugar de cout.
//: C06:CopyIntsToFile.cpp // Uses an output file stream iterator. #include <algorithm> #include <cstddef> #include <fstream>
192 i i i i
i i
Un iterador de ujo de entrada permite a un algoritmo leer su secuencia de entrada desde un ujo de entrada. Esto se consigue haciendo que tanto el constructor como operator++() lean el siguiente elemento del ujo subyacente y sobrecargando operator*() para conseguir el valor ledo previamente. Dado que los algoritmos requieren dos punteros para delimitar la secuencia de entrada, puede construir un istream_iterator de dos formas, como puede ver en el siguiente programa.
//: C06:CopyIntsFromFile.cpp // Uses an input stream iterator. #include <algorithm> #include <fstream> #include <iostream> #include <iterator> #include "../require.h" using namespace std; bool gt15(int x) { return 15 < x; } int main() { ofstream ints("someInts.dat"); ints << "1 3 47 5 84 9"; ints.close(); ifstream inf("someInts.dat"); assure(inf, "someInts.dat"); remove_copy_if(istream_iterator<int>(inf), istream_iterator<int>(), ostream_iterator<int>(cout, "\n"), gt15); } ///:~
El primer argumento de replace_copy_if() en este programa asocia un objeto istream_iterator al chero de entrada que contiene enteros. El segundo argumento usa el constructor por defecto de la clase istream_iterator. Esta llamada construye un valor especial de istream_iterator que indica el n de chero, de modo que cuando el primer iterador encuentra el nal del chero fsico, se compara con el valor de istream_iterator<int>(), permitiendo al algoritmo terminar correctamente. Fjese que este ejemplo evita usar un array explcito. 193 i i i i
i i
Dado que count_if() debe comprobar cada elemento exactamente una vez, se especic hacer un nmero de comprobaciones que sea exactamente igual que el nmero de elementos en la secuencia. El algoritmo copy() tiene la misma especicacin. Otros algoritmos pueden estar especicados para realizar cierto nmero mximo de operaciones. El algoritmo find() busca a travs de una secuencia hasta encontrar un elemento igual a su tercer argumento.
int* p = find(a, a + SIZE, 20);
Para tan pronto como encuentre el elemento y devuelve un puntero a la primera ocurrencia. Si no encuentra ninguno, retorna un puntero a una posicin pasado el nal de la secuencia (a+SIZE en este ejemplo). De modo que find() realiza como mximo tantas comparaciones como elementos tenga la secuencia. A veces el nmero de operaciones que realiza un algoritmo no se puede medir con tanta precisin. En esos casos, el estndar especica la complejidad asinttica del algoritmo, que es una medida de cmo se comportar el algoritmo con secuencias largas comparadas con formulas bien conocidas. Un buen ejemplo es el algoritmo sort(), del que el estndar dice que requiere aproximadamente n log n comparaciones de media (n es el nmero de elementos de la secuencia). [FIXME]. Esta medida de complejidad da una idea del coste de un algoritmo y al menos le da una base able para comparar algoritmos. Como ver en el siguiente captulo, el mtodo find() para el contendor set tiene complejidad logartmica, que implica que el coste de una bsqueda de un elemento en un set ser, para conjuntos grandes, proporcional al logaritmo del nmero de elementos. Eso es mucho menor que el nmero de elementos para un n grande, de modo que siempre es mejor buscar en un set utilizando el mtodo en lugar del algoritmo genrico.
7.2. Objetos-funcin
//: C06:GreaterThanN.cpp
194 i i i i
i i
7.2. Objetos-funcin
#include <iostream> using namespace std; class gt_n { int value; public: gt_n(int val) : value(val) {} bool operator()(int n) { return n > value; } }; int main() { gt_n f(4); cout << f(3) << endl; cout << f(5) << endl; } ///:~
//: C06:CountNotEqual.cpp // Count elements not equal to 20. #include <algorithm> #include <cstddef> #include <functional> #include <iostream> using namespace std; int main() { int a[] = { 10, 20, 30 }; const size_t SIZE = sizeof a / sizeof a[0]; cout << count_if(a, a + SIZE, not1(bind1st(equal_to<int>(), 20)));// 2 } ///:~
195 i i i i
i i
196 i i i i
i i
7.2. Objetos-funcin
#include "Generators.h" const char* CharGen::source = "ABCDEFGHIJK" "LMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const int CharGen::len = std::strlen(source); ///:~
//: C06:FunctionObjects.cpp {-bor} // Illustrates selected predefined function object // templates from the Standard C++ library. //{L} Generators #include <algorithm> #include <cstdlib> #include <ctime> #include <functional> #include <iostream> #include <iterator> #include <vector> #include "Generators.h" #include "PrintSequence.h" using namespace std; template<typename Contain, typename UnaryFunc> void testUnary(Contain& source, Contain& dest, UnaryFunc f) { transform(source.begin(), source.end(), dest.begin(), f); } template<typename Contain1, typename Contain2, typename BinaryFunc> void testBinary(Contain1& src1, Contain1& src2, Contain2& dest, BinaryFunc f) { transform(src1.begin(), src1.end(), src2.begin(), dest.begin(), f); } // Executes the expression, then stringizes the // expression into the print statement: #define T(EXPR) EXPR; print(r.begin(), r.end(), \ "After " #EXPR); // For Boolean tests: #define B(EXPR) EXPR; print(br.begin(), br.end(), \ "After " #EXPR); // Boolean random generator: struct BRand { bool operator()() { return rand() % 2 == 0; } }; int main() { const int SZ = 10; const int MAX = 50; vector<int> x(SZ), y(SZ), r(SZ); // An integer random number generator: URandGen urg(MAX); srand(time(0)); // Randomize generate_n(x.begin(), SZ, urg);
197 i i i i
i i
//: C06:FBinder.cpp // Binders arent limited to producing predicates. //{L} Generators #include <algorithm> #include <cstdlib> #include <ctime> #include <functional> #include <iostream> #include <iterator> #include <vector> #include "Generators.h" using namespace std; int main() { ostream_iterator<int> out(cout," "); vector<int> v(15); srand(time(0)); // Randomize generate(v.begin(), v.end(), URandGen(20)); copy(v.begin(), v.end(), out); transform(v.begin(), v.end(), v.begin(),
198 i i i i
i i
7.2. Objetos-funcin
bind2nd(multiplies<int>(), 10)); copy(v.begin(), v.end(), out); } ///:~
//: C06:BinderValue.cpp // The bound argument can vary. #include <algorithm> #include <functional> #include <iostream> #include <iterator> #include <cstdlib> using namespace std; int boundedRand() { return rand() % 100; } int main() { const int SZ = 20; int a[SZ], b[SZ] = {0}; generate(a, a + SZ, boundedRand); int val = boundedRand(); int* end = remove_copy_if(a, a + SZ, b, bind2nd(greater<int>(), val)); // Sort for easier viewing: sort(a, a + SZ); sort(b, end); ostream_iterator<int> out(cout, " "); cout << "Original Sequence:" << endl; copy(a, a + SZ, out); cout << endl; cout << "Values <= " << val << endl; copy(b, end, out); cout << endl; } ///:~
199 i i i i
i i
//: C06:PtrFun2.cpp {-edg} // Using ptr_fun() for a binary function. #include <algorithm> #include <cmath> #include <functional> #include <iostream> #include <iterator> #include <vector> using namespace std; double d[] = { 01.23, 91.370, 56.661, 023.230, 19.959, 1.0, 3.14159 }; const int DSZ = sizeof d / sizeof *d; int main() { vector<double> vd; transform(d, d + DSZ, back_inserter(vd), bind2nd(ptr_fun<double, double, double>(pow), 2.0)); copy(vd.begin(), vd.end(), ostream_iterator<double>(cout, " ")); cout << endl; } ///:~
//: C06:MemFun1.cpp // Applying pointers to member functions. #include <algorithm> #include <functional> #include <iostream> #include <vector> #include "../purge.h" using namespace std; class Shape { public: virtual void draw() = 0; virtual ~Shape() {} }; class Circle : public Shape { public: virtual void draw() { cout << "Circle::Draw()" << endl; } ~Circle() { cout << "Circle::~Circle()" << endl; } }; class Square : public Shape { public: virtual void draw() { cout << "Square::Draw()" << endl; }
200 i i i i
i i
7.2. Objetos-funcin
~Square() { cout << "Square::~Square()" << endl; } }; int main() { vector<Shape*> vs; vs.push_back(new Circle); vs.push_back(new Square); for_each(vs.begin(), vs.end(), mem_fun(&Shape::draw)); purge(vs); } ///:~
//: C06:MemFun2.cpp // Calling member functions through an object reference. #include <algorithm> #include <functional> #include <iostream> #include <iterator> #include <vector> using namespace std; class Angle { int degrees; public: Angle(int deg) : degrees(deg) {} int mul(int times) { return degrees *= times; } }; int main() { vector<Angle> va; for(int i = 0; i < 50; i += 10) va.push_back(Angle(i)); int x[] = { 1, 2, 3, 4, 5 }; transform(va.begin(), va.end(), x, ostream_iterator<int>(cout, " "), mem_fun_ref(&Angle::mul)); cout << endl; // Output: 0 20 60 120 200 } ///:~
//: C06:FindBlanks.cpp // Demonstrates mem_fun_ref() with string::empty(). #include <algorithm> #include <cassert> #include <cstddef> #include <fstream> #include <functional> #include <string> #include <vector> #include "../require.h" using namespace std; typedef vector<string>::iterator LSI; int main(int argc, char* argv[]) {
201 i i i i
i i
202 i i i i
i i
7.2. Objetos-funcin
//: C06:MemFun3.cpp // Using mem_fun(). #include <algorithm> #include <cstdlib> #include <ctime> #include <functional> #include <iostream> #include <iterator> #include <string> #include <vector> #include "NumStringGen.h" using namespace std; int main() { const int SZ = 9; vector<string> vs(SZ); // Fill it with random number strings: srand(time(0)); // Randomize generate(vs.begin(), vs.end(), NumStringGen()); copy(vs.begin(), vs.end(), ostream_iterator<string>(cout, "\t")); cout << endl; const char* vcp[SZ]; transform(vs.begin(), vs.end(), vcp, mem_fun_ref(&string::c_str)); vector<double> vd; transform(vcp, vcp + SZ, back_inserter(vd), std::atof); cout.precision(4); cout.setf(ios::showpoint); copy(vd.begin(), vd.end(), ostream_iterator<double>(cout, "\t")); cout << endl; } ///:~
//: C06:ComposeTry.cpp // A first attempt at implementing function composition. #include <cassert> #include <cstdlib> #include <functional> #include <iostream> #include <string> using namespace std; template<typename R, typename E, typename F1, typename F2> class unary_composer { F1 f1; F2 f2; public: unary_composer(F1 fone, F2 ftwo) : f1(fone), f2(ftwo) {} R operator()(E x) { return f1(f2(x)); } }; template<typename R, typename E, typename F1, typename F2> unary_composer<R, E, F1, F2> compose(F1 f1, F2 f2) {
203 i i i i
i i
//: C06:ComposeFinal.cpp {-edg} // An adaptable composer. #include <algorithm> #include <cassert> #include <cstdlib> #include <functional> #include <iostream> #include <iterator> #include <string> #include <vector> #include "NumStringGen.h" using namespace std; template<typename F1, typename F2> class unary_composer : public unary_function<typename F2::argument_type, typename F1::result_type> { F1 f1; F2 f2; public: unary_composer(F1 f1, F2 f2) : f1(f1), f2(f2) {} typename F1::result_type operator()(typename F2::argument_type x) { return f1(f2(x)); } }; template<typename F1, typename F2> unary_composer<F1, F2> compose(F1 f1, F2 f2) { return unary_composer<F1, F2>(f1, f2); } int main() { const int SZ = 9; vector<string> vs(SZ); // Fill it with random number strings: generate(vs.begin(), vs.end(), NumStringGen()); copy(vs.begin(), vs.end(), ostream_iterator<string>(cout, "\t")); cout << endl; vector<double> vd; transform(vs.begin(), vs.end(), back_inserter(vd), compose(ptr_fun(atof), mem_fun_ref(&string::c_str))); copy(vd.begin(), vd.end(), ostream_iterator<double>(cout, "\t")); cout << endl; } ///:~
204 i i i i
i i
205 i i i i
i i
206 i i i i
i i
7.3.3. Conteo
Ejemplo
//: C06:Counting.cpp // The counting algorithms. //{L} Generators #include <algorithm> #include <functional> #include <iterator> #include <set> #include <vector> #include "Generators.h" #include "PrintSequence.h" using namespace std; int main() { vector<char> v; generate_n(back_inserter(v), 50, CharGen()); print(v.begin(), v.end(), "v", ""); // Create a set of the characters in v: set<char> cs(v.begin(), v.end()); typedef set<char>::iterator sci; for(sci it = cs.begin(); it != cs.end(); it++) { int n = count(v.begin(), v.end(), *it); cout << *it << ": " << n << ", "; } int lc = count_if(v.begin(), v.end(), bind2nd(greater<char>(), a)); cout << "\nLowercase letters: " << lc << endl; sort(v.begin(), v.end()); print(v.begin(), v.end(), "sorted", ""); } ///:~
207 i i i i
i i
208 i i i i
i i
209 i i i i
i i
210 i i i i
i i
211 i i i i
i i
212 i i i i
i i
213 i i i i
i i
214 i i i i
i i
Ejemplo
//: C06:SetOperations.cpp // Set operations on sorted ranges. //{L} Generators #include <algorithm> #include <vector> #include "Generators.h" #include "PrintSequence.h" using namespace std; int main() { const int SZ = 30; char v[SZ + 1], v2[SZ + 1]; CharGen g; generate(v, v + SZ, g); generate(v2, v2 + SZ, g); sort(v, v + SZ); sort(v2, v2 + SZ); print(v, v + SZ, "v", ""); print(v2, v2 + SZ, "v2", ""); bool b = includes(v, v + SZ, v + SZ/2, v + SZ); cout.setf(ios::boolalpha); cout << "includes: " << b << endl; char v3[SZ*2 + 1], *end; end = set_union(v, v + SZ, v2, v2 + SZ, v3); print(v3, end, "set_union", ""); end = set_intersection(v, v + SZ, v2, v2 + SZ, v3); print(v3, end, "set_intersection", ""); end = set_difference(v, v + SZ, v2, v2 + SZ, v3); print(v3, end, "set_difference", ""); end = set_symmetric_difference(v, v + SZ, v2, v2 + SZ, v3); print(v3, end, "set_symmetric_difference",""); } ///:~
7.3.9. Operaciones sobre el montculo 7.3.10. Aplicando una operacin a cada elemento de un rango
Ejemplos
//: C06:Counted.h // An object that keeps track of itself. #ifndef COUNTED_H #define COUNTED_H #include <vector>
215 i i i i
i i
//: C06:ForEach.cpp {-mwcc} // Use of STL for_each() algorithm. //{L} Counted #include <algorithm> #include <iostream> #include "Counted.h" using namespace std; // Function object: template<class T> class DeleteT { public: void operator()(T* x) { delete x; } }; // Template function: template<class T> void wipe(T* x) { delete x; } int main() { CountedVector B("two"); for_each(B.begin(), B.end(), DeleteT<Counted>()); CountedVector C("three"); for_each(C.begin(), C.end(), wipe<Counted>); } ///:~
//: C06:Transform.cpp {-mwcc} // Use of STL transform() algorithm. //{L} Counted #include <iostream> #include <vector> #include <algorithm> #include "Counted.h" using namespace std;
216 i i i i
i i
template<class T> T* deleteP(T* x) { delete x; return 0; } template<class T> struct Deleter { T* operator()(T* x) { delete x; return 0; } }; int main() { CountedVector cv("one"); transform(cv.begin(), cv.end(), cv.begin(), deleteP<Counted>); CountedVector cv2("two"); transform(cv2.begin(), cv2.end(), cv2.begin(), Deleter<Counted>()); } ///:~
//: C06:Inventory.h #ifndef INVENTORY_H #define INVENTORY_H #include <iostream> #include <cstdlib> using std::rand; class Inventory { char item; int quantity; int value; public: Inventory(char it, int quant, int val) : item(it), quantity(quant), value(val) {} // Synthesized operator= & copy-constructor OK char getItem() const { return item; } int getQuantity() const { return quantity; } void setQuantity(int q) { quantity = q; } int getValue() const { return value; } void setValue(int val) { value = val; } friend std::ostream& operator<<( std::ostream& os, const Inventory& inv) { return os << inv.item << ": " << "quantity " << inv.quantity << ", value " << inv.value; } }; // A generator: struct InvenGen { Inventory operator()() { static char c = a; int q = rand() % 100; int v = rand() % 500; return Inventory(c++, q, v); } }; #endif // INVENTORY_H ///:~
217 i i i i
i i
//: C06:CalcInventory.cpp // More use of for_each(). #include <algorithm> #include <ctime> #include <vector> #include "Inventory.h" #include "PrintSequence.h" using namespace std; // To calculate inventory totals: class InvAccum { int quantity; int value; public: InvAccum() : quantity(0), value(0) {} void operator()(const Inventory& inv) { quantity += inv.getQuantity(); value += inv.getQuantity() * inv.getValue(); } friend ostream& operator<<(ostream& os, const InvAccum& ia) { return os << "total quantity: " << ia.quantity << ", total value: " << ia.value; } }; int main() { vector<Inventory> vi; srand(time(0)); // Randomize generate_n(back_inserter(vi), 15, InvenGen()); print(vi.begin(), vi.end(), "vi"); InvAccum ia = for_each(vi.begin(),vi.end(), InvAccum()); cout << ia << endl; } ///:~
//: C06:TransformNames.cpp // More use of transform(). #include <algorithm> #include <cctype> #include <ctime> #include <vector> #include "Inventory.h" #include "PrintSequence.h" using namespace std; struct NewImproved { Inventory operator()(const Inventory& inv) { return Inventory(toupper(inv.getItem()), inv.getQuantity(), inv.getValue()); } }; int main() { vector<Inventory> vi; srand(time(0)); // Randomize
218 i i i i
i i
//: C06:SpecialList.cpp // Using the second version of transform(). #include <algorithm> #include <ctime> #include <vector> #include "Inventory.h" #include "PrintSequence.h" using namespace std; struct Discounter { Inventory operator()(const Inventory& inv, float discount) { return Inventory(inv.getItem(), inv.getQuantity(), int(inv.getValue() * (1 - discount))); } }; struct DiscGen { float operator()() { float r = float(rand() % 10); return r / 100.0; } }; int main() { vector<Inventory> vi; srand(time(0)); // Randomize generate_n(back_inserter(vi), 15, InvenGen()); print(vi.begin(), vi.end(), "vi"); vector<float> disc; generate_n(back_inserter(disc), 15, DiscGen()); print(disc.begin(), disc.end(), "Discounts:"); vector<Inventory> discounted; transform(vi.begin(),vi.end(), disc.begin(), back_inserter(discounted), Discounter()); print(discounted.begin(), discounted.end(),"discounted"); } ///:~
219 i i i i
i i
//: C06:copy_if.h // Create your own STL-style algorithm. #ifndef COPY_IF_H #define COPY_IF_H template<typename ForwardIter, typename OutputIter, typename UnaryPred> OutputIter copy_if(ForwardIter begin, ForwardIter end, OutputIter dest, UnaryPred f) { while(begin != end) { if(f(*begin)) *dest++ = *begin;
220 i i i i
i i 7.5. Resumen
++begin; } return dest; } #endif // COPY_IF_H ///:~
221 i i i i
i i
i i i
i i
Parte III
Temas especiales
223 i i i i
i i
i i i
i i
La marca de un profesional aparece en su atencin a los detalles ms nos del ocio. En esta seccin del libro veremos caractersticas avanzadas de C++ junto con tcnicas de desarrollo usadas por profesionales brillantes de C++.
A veces necesita salir de los convencionalismos que suenan a diseo orientado a objetos, inspeccionando el tipo de un objeto en tiempo de ejecucin. La mayora de las veces debera dejar que las funciones virtuales hagan ese trabajo por usted, pero cuando escriba herramientas software para propsitos especiales, tales como depuradores, visualizadores de bases de datos, o navegadores de clases, necesitar determinar la informacin de tipado en tiempo de ejecucin. Ah es cuando el mecanismo de identicacin de tipo en tiempo de ejecucin (RTTI) resulta til. RTTI es el tema del Captulo 8. La herencia mltiple ha sido maltratado a lo largo de los aos, y algunos lenguajes incluso no la permiten. No obstante, cuando se usa adecuadamente, puede ser una herramienta potente para conseguir cdigo eciente y elegante. Un buen nmero de prcticas estndar que involucran herencia mltiple han evolucionado con el tiempo; las veremos en el Captulo 9. Quizs la innovacin ms notable en el desarrollo de software desde las tcnicas de orientacin a objetos es el uso de los patrones de diseo. Un patrn de diseo describe soluciones para muchos problemas comunes del diseo de software, y se puede aplicar a muchas situaciones e implementacin en cualquier lenguaje. En el Captulo 10 describiremos una seleccin de patrones de diseo y los implementaremos en C++. El Captulo 11 explica los benecios y desafos de la programacin multihilo. La versin actual de C++ Estndar no especica soporte para hilos, aunque la mayora de los sistema operativos los ofrecen. Usaremos un librera portable y disponible libremente para ilustrar cmo los programadores pueden sacar provecho de los hilos para construir aplicaciones ms usables y receptivas.
225 i i i i
i i
i i i
i i
8: Herencia mltiple
El concepto bsico de la herencia mltiple (HM) suena bastante simple: puede crear un nuevo tipo heredando de ms una una clase base. La sintaxis es exactamente la que espera, y en la medida en que los diagramas de herencia sean simples, la HM puede ser simple tambin. Sin embargo, la HM puede presentar un buen nmero de situaciones ambiguas y extraas, que se cubren en este captulo. Pero primero, es til tener algo de perspectiva sobre el asunto.
8.1. Perspectiva
Antes de C++, el lenguaje orientado a objetos ms popular era Smaltalk. Smaltalk fue creado desde cero como un lenguaje orientado a objetos. A menudo se dice que es puro, mientras que a C++ se le llama lenguaje hbrido porque soporta mltiples paradigmas de programacin, no slo el paradigma orientado a objeto. Uno de las decisiones de diseo de Smalltalk fue que todas las clases tendran solo herencia simple, empezando en una clase base (llamada Object - ese es el modelo para la jerarqua basada en objetos) 1 En Smalltalk no puede crear una nueva clase sin derivar de un clase existente, que es la razn por la que lleva cierto tiempo ser productivo con Smalltalk: debe aprender la librera de clases antes de empezar a hacer clases nuevas. La jerarqua de clases de Smalltalk es por tanto un nico rbol monoltico. Las clases de Smalltalk normalmente tienen ciertas cosas en comn, y siempre tienen algunas cosas en comn (las caractersticas y el comportamiento de Object), de modo que no suelen aparecer situaciones en las que se necesite heredad de ms de una clase base. Sin embargo, con C++ puede crear tantos rboles de herencia distintos como quiera. Por completitud lgica el lenguaje debe ser capaz de combinar ms de una clase a la vez - por eso la necesidad de herencia mltiple. No fue obvio, sin embargo, que los programadores requiriesen herencia mltiple, y haba (y sigue habiendo) mucha discrepancia sobre si es algo esencial en C++. La HM fue aadida en cfront release 2.0 de AT&T en 1989 y fue el primer cambio signicativo en el lenguaje desde la versin 1.0. 2 Desde entonces, se han aadido muchas caractersticas al Estndar C++ (las plantillas son dignas de mencin) que cambian la manera de pensar al programar y le dan a la HM un papel mucho menos importante. Puede pensar en la HM como una prestacin menor del lenguaje que raramente est involucrada en las decisiones de diseo diarias. Uno de los argumentos ms convincentes para la HM involucra a los contenedo1 2
Esto tambin ocurre en Java, y en otros lenguajes orientados a objetos. Son nmeros de versin internos de AT&T.
227 i i i i
i i
Captulo 8. Herencia mltiple res. Suponga que quiere crear un contenedor que todo el mundo pueda usar fcilmente. Una propuesta es usar void* como tipo para el contenido. La propuesta de Smalltalk, sin embargo, es hacer un contenedor que aloja Object, dado que Object es el tipo base de la jerarqua de Smalltalk. Como todo en Smalltalk est derivado de Object, un contenedor que aloja Objects puede contener cualquier cosa. Ahora considere la situacin en C++. Suponga que el fabricante A crea una jerarqua basada-en-objetos que incluye un conjunto de contenedores incluye uno que desea usar llamado Holder. Despus, se da cuenta de que la jerarqua de clases del fabricante B contiene alguna clase que tambin es importante para usted, una clase BitImage, por ejemplo, que contiene imgenes. La nica forma de hacer que un Holder de BitImage es derivar de una nueva clase que derive tambin de Object, y as poder almacenarlos en el Holder, y BitImage:
Figura 8.1: ste fue un motivo importante para la HM, y muchas libreras de clases estn hechas con este model. Sin embargo, tal como se vio en el Captulo 5, la aportacin de las plantillas ha cambiado la forma de crear contenedores, y por eso esta situacin ya no es un asunto crucial en favor de la HM. El otro motivo por el que se necesita la HM est relacionado con el diseo. Puede usar la HM intencionadamente para hacer un diseo ms exible y til (o al menos aparentarlo). Un ejemplo de esto es el diseo de la librera original iostream (que persiste hoy da, como vio en el Captulo 4.
Figura 8.2: Tanto iostream como ostream son clases tiles por si mismas, pero se pueden derivar simultneamente por una clase que combina sus caractersticas y comportamientos. La clase ios proporciona una combinacin de las dos clases, y por eso en este caso la HM es un mecanismo de FIXME:code-factoring. Sin importar lo que le motive a usar HM, debe saber que es ms difcil de usar de lo que podra parecer.
i i
8.2. Herencia de interfaces de funciones). Estas declaraciones sern funciones virtuales puras, excepto el destructor. Aqu hay un ejemplo:
//: C09:Interfaces.cpp // Multiple interface inheritance. #include <iostream> #include <sstream> #include <string> using namespace std; class Printable { public: virtual ~Printable() {} virtual void print(ostream&) const = 0; }; class Intable { public: virtual ~Intable() {} virtual int toInt() const = 0; }; class Stringable { public: virtual ~Stringable() {} virtual string toString() const = 0; }; class Able : public Printable, public Intable, public Stringable { int myData; public: Able(int x) { myData = x; } void print(ostream& os) const { os << myData; } int toInt() const { return myData; } string toString() const { ostringstream os; os << myData; return os.str(); } }; void testPrintable(const Printable& p) { p.print(cout); cout << endl; } void testIntable(const Intable& n) { cout << n.toInt() + 1 << endl; } void testStringable(const Stringable& s) { cout << s.toString() + "th" << endl; } int main() { Able a(7); testPrintable(a);
229 i i i i
i i
La clase Able implementa las interfaces Printable, Intable y Stringable dado que proporciona implementaciones para las funciones que stas declaran. Dado que Able deriva de las tres clases, los objetos Able tienen mltiples relaciones es-un. Por ejemplo, el objeto a puede actuar como un objeto Printable dado que su clase, Able, deriva pblicamente de Printable y proporciona una implementacin para print(). Las funciones de prueba no necesitan saber el tipo ms derivado de su parmetro; slo necesitan un objeto que sea substituible por el tipo de su parmetro. Como es habitual, una plantilla es una solucin ms compacta:
//: C09:Interfaces2.cpp // Implicit interface inheritance via templates. #include <iostream> #include <sstream> #include <string> using namespace std; class Able { int myData; public: Able(int x) { myData = x; } void print(ostream& os) const { os << myData; } int toInt() const { return myData; } string toString() const { ostringstream os; os << myData; return os.str(); } }; template<class Printable> void testPrintable(const Printable& p) { p.print(cout); cout << endl; } template<class Intable> void testIntable(const Intable& n) { cout << n.toInt() + 1 << endl; } template<class Stringable> void testStringable(const Stringable& s) { cout << s.toString() + "th" << endl; } int main() { Able a(7); testPrintable(a); testIntable(a); testStringable(a);
230 i i i i
i i
Los nombres Printable, Intable y Stringable ahora no son mas que parmetros de la plantilla que asume la existencia de las operaciones indicadas en sus respectivos argumentos. En otras palabras, las funciones de prueba pueden aceptar argumentos de cualquier tipo que proporciona una denicin de mtodo con la signatura y tipo de retorno correctos. Hay gente que encuentra ms cmoda la primera versin porque los nombres de tipo garantizan que las interfaces esperadas estn implementadas. Otros estn contentos con el hecho de que si las operaciones requeridas por las funciones de prueba no se satisfacen por los argumentos de la plantilla, el error puede ser capturado en la compilacin. Esta segunda es una forma de comprobacin de tipos tcnicamente ms dbil que el primer enfoque (herencia), pero el efecto para el programador (y el programa) es el mismo. Se trata de una forma de comprobacin dbil de tipo que es aceptable para muchos de los programadores C++ de hoy en da.
231 i i i i
i i
//: C09:Countable.h // A "mixin" class. #ifndef COUNTABLE_H #define COUNTABLE_H #include <cassert> class Countable { long count; protected: Countable() { count = 0; } virtual ~Countable() { assert(count == 0); } public: long attach() { return ++count; } long detach() { return (--count > 0) ? count : (delete this, 0); } long refCount() const { return count; } }; #endif // COUNTABLE_H ///:~
//: C09:DBConnection.h // Uses a "mixin" class. #ifndef DBCONNECTION_H #define DBCONNECTION_H #include <cassert> #include <string> #include "Countable.h" #include "Database.h" using std::string; class DBConnection : public Database, public Countable { DBConnection(const DBConnection&); // Disallow copy DBConnection& operator=(const DBConnection&); protected: DBConnection(const string& dbStr) throw(DatabaseError) : Database(dbStr) { open(); } ~DBConnection() { close(); } public: static DBConnection* create(const string& dbStr) throw(DatabaseError) { DBConnection* con = new DBConnection(dbStr); con->attach(); assert(con->refCount() == 1); return con; }
232 i i i i
i i
//: C09:UseDatabase2.cpp // Tests the Countable "mixin" class. #include <cassert> #include "DBConnection.h" class DBClient { DBConnection* db; public: DBClient(DBConnection* dbCon) { db = dbCon; db->attach(); } ~DBClient() { db->detach(); } // Other database requests using db... }; int main() { DBConnection* db = DBConnection::create("MyDatabase"); assert(db->refCount() == 1); DBClient c1(db); assert(db->refCount() == 2); DBClient c2(db); assert(db->refCount() == 3); // Use database, then release attach from original create db->detach(); assert(db->refCount() == 2); } ///:~
//: C09:DBConnection2.h // A parameterized mixin. #ifndef DBCONNECTION2_H #define DBCONNECTION2_H #include <cassert> #include <string> #include "Database.h" using std::string; template<class Counter> class DBConnection : public Database, public Counter { DBConnection(const DBConnection&); // Disallow copy DBConnection& operator=(const DBConnection&); protected: DBConnection(const string& dbStr) throw(DatabaseError) : Database(dbStr) { open(); } ~DBConnection() { close(); } public: static DBConnection* create(const string& dbStr) throw(DatabaseError) { DBConnection* con = new DBConnection(dbStr); con->attach();
233 i i i i
i i
//: C09:UseDatabase3.cpp // Tests a parameterized "mixin" class. #include <cassert> #include "Countable.h" #include "DBConnection2.h" class DBClient { DBConnection<Countable>* db; public: DBClient(DBConnection<Countable>* dbCon) { db = dbCon; db->attach(); } ~DBClient() { db->detach(); } }; int main() { DBConnection<Countable>* db = DBConnection<Countable>::create("MyDatabase"); assert(db->refCount() == 1); DBClient c1(db); assert(db->refCount() == 2); DBClient c2(db); assert(db->refCount() == 3); db->detach(); assert(db->refCount() == 2); } ///:~
234 i i i i
i i
int main() { cout << "sizeof(A) == " << sizeof(A) << endl; cout << "sizeof(B) == " << sizeof(B) << endl; cout << "sizeof(C) == " << sizeof(C) << endl; C c; cout << "&c == " << &c << endl; A* ap = &c; B* bp = &c; cout << "ap == " << static_cast<void*>(ap) << endl; cout << "bp == " << static_cast<void*>(bp) << endl; C* cp = static_cast<C*>(bp); cout << "cp == " << static_cast<void*>(cp) << endl; cout << "bp == cp? " << boolalpha << (bp == cp) << endl; cp = 0; bp = cp; cout << bp << endl; } /* Output: sizeof(A) == 4 sizeof(B) == 4 sizeof(C) == 12 &c == 1245052 ap == 1245052 bp == 1245056 cp == 1245052 bp == cp? true 0 */ ///:~
//: C09:Duplicate.cpp // Shows duplicate subobjects. #include <iostream> using namespace std; class Top { int x; public: Top(int n) { x = n; } }; class Left : public Top { int y; public: Left(int m, int n) : Top(m) { y = n; } }; class Right : public Top { int z; public: Right(int m, int n) : Top(m) { z = n; } }; class Bottom : public Left, public Right { int w; public:
235 i i i i
i i
236 i i i i
i i
//: C09:VirtualBase2.cpp // How NOT to implement operator<<. #include <iostream> using namespace std; class Top { int x; public: Top(int n) { x = n; } virtual ~Top() {} friend ostream& operator<<(ostream& os, const Top& t) { return os << t.x; } }; class Left : virtual public Top { int y; public: Left(int m, int n) : Top(m) { y = n; } friend ostream& operator<<(ostream& os, const Left& l) { return os << static_cast<const Top&>(l) << , << l.y; } }; class Right : virtual public Top { int z; public: Right(int m, int n) : Top(m) { z = n; } friend ostream& operator<<(ostream& os, const Right& r) { return os << static_cast<const Top&>(r) << , << r.z; } }; class Bottom : public Left, public Right { int w; public: Bottom(int i, int j, int k, int m) : Top(i), Left(0, j), Right(0, k) { w = m; }
237 i i i i
i i
//: C09:VirtualBase3.cpp // A correct stream inserter. #include <iostream> using namespace std; class Top { int x; public: Top(int n) { x = n; } virtual ~Top() {} friend ostream& operator<<(ostream& os, const Top& t) { return os << t.x; } }; class Left : virtual public Top { int y; protected: void specialPrint(ostream& os) const { // Only print Lefts part os << ,<< y; } public: Left(int m, int n) : Top(m) { y = n; } friend ostream& operator<<(ostream& os, const Left& l) { return os << static_cast<const Top&>(l) << , << l.y; } }; class Right : virtual public Top { int z; protected: void specialPrint(ostream& os) const { // Only print Rights part os << ,<< z; } public: Right(int m, int n) : Top(m) { z = n; } friend ostream& operator<<(ostream& os, const Right& r) { return os << static_cast<const Top&>(r) << , << r.z; } }; class Bottom : public Left, public Right {
238 i i i i
i i
//: C09:VirtInit.cpp // Illustrates initialization order with virtual bases. #include <iostream> #include <string> using namespace std; class M { public: M(const string& s) { cout << "M " << s << endl; } }; class A { M m; public: A(const string& s) : m("in A") { cout << "A " << s << endl; } virtual ~A() {} }; class B { M m; public: B(const string& s) : m("in B") cout << "B " << s << endl; } virtual ~B() {} }; class C { M m; public: C(const string& s) : m("in C") cout << "C " << s << endl; } virtual ~C() {} }; class D {
239 i i i i
i i
M B M C M A M E M D M F M G
G G E G F G main
240 i i i i
i i
class Top { public: virtual ~Top() {} }; class Left : virtual public Top { public: void f() {} }; class Right : virtual public Top { public: void f() {} }; class Bottom : public Left, public Right {}; int main() { Bottom b; b.f(); // Error here } ///:~
//: C09:BreakTie.cpp class Top { public: virtual ~Top() {} }; class Left : virtual public Top { public: void f() {} }; class Right : virtual public Top { public: void f() {} }; class Bottom : public Left, public Right { public: using Left::f; }; int main() { Bottom b; b.f(); // Calls Left::f() } ///:~
241 i i i i
i i
//: C09:Dominance2.cpp #include <iostream> using namespace std; class A { public: virtual ~A() {} virtual void f() { cout << "A::f\n"; } }; class B : virtual public A { public: void f() { cout << "B::f\n"; } }; class C : public B {}; class D : public C, virtual public A {}; int main() { B* p = new D; p->f(); // Calls B::f() delete p; } ///:~
242 i i i i
i i
//: C09:Vendor.cpp {O} // Assume this is compiled and unavailable to you. #include "Vendor.h" #include <iostream> using namespace std; void Vendor::v() const { cout << "Vendor::v()" << endl; } void Vendor::f() const { cout << "Vendor::f()" << endl; } Vendor::~Vendor() { cout << "~Vendor()" << endl; } void Vendor1::v() const { cout << "Vendor1::v()" << endl; } void Vendor1::f() const { cout << "Vendor1::f()" << endl; } Vendor1::~Vendor1() { cout << "~Vendor1()" << endl; } void A(const Vendor& v) { // ... v.v(); v.f(); // ... } void B(const Vendor& v) { // ... v.v(); v.f(); // ... } ///:~
243 i i i i
i i
calling f() Paste1::f() Vendor1::f() calling g() Paste1::g() calling A(p1p) Paste1::v() Vendor1::v() Vendor::f() calling B(p1p) Paste1::v() Vendor1::v() Vendor::f()
244 i i i i
i i 8.9. Resumen
delete mp ~Paste1() ~Vendor1() ~Vendor() ~MyBase()
245 i i i i
i i
i i i
i i
9: Patrones de Diseo
"...describa un problema que sucede una y otra vez en nuestro entorno, y luego describa el ncleo de la solucin a ese problema, de tal forma que pueda utilizar esa solucin un milln de veces ms, sin siquiera hacerlo dos veces de la misma manera." - Christopher Alexander Este captulo presenta el importante y an no tradicional enfoque de los patrones para el diseo de programas. El avance reciente ms importante en el diseo orientado a objetos es probablemente el movimiento de los patrones de diseo, inicialmente narrado en "Design Patterns", por Gamma, Helm, Johnson y Vlissides (Addison Wesley, 1995), que suele llamarse el libro de la "Banda de los Cuatro" (en ingls, GoF: Gang of Four). El GoF muestra 23 soluciones para clases de problemas muy particulares. En este captulo se discuten los conceptos bsicos de los patrones de diseo y se ofrecen ejemplos de cdigo que ilustran los patrones escogidos. Esto debera abrirle el apetito para leer ms acerca de los patrones de diseo, una fuente de lo que se ha convertido en vocabulario esencial, casi obligatorio, para la programacin orientada a objetos.
i i
Captulo 9. Patrones de Diseo querr prevenir que esos cambios propagen efectos colaterales por su cdigo. Si lo consigue, su cdigo no slo ser ms fcil de leer y comprender, tambin ser ms fcil de mantener, lo que a la larga, siempre redunda en menores costes. La parte ms difcil de desarrollar un diseo elegante y mantenible a menudo es descubrir lo que llamamos el "vector de cambio". (Aqu "vector" se reere al mayor gradiente tal y como se entiende en ciencias, no como la clase contenedora.) Esto implica encontrar la cosa ms importante que cambia en su sistema o, dicho de otra forma, descubrir dnde estn sus mayores costes. Una vez que descubra el vector de cambios, tendr el punto focal alrededor del cual estructurar su diseo. Por lo tanto, el objetivo de los patrones de diseo es encapsular el cambio. Si lo enfoca de esta forma, ya habr visto algunos patrones de diseo en este libro. Por ejemplo, la herencia podra verse como un patrn de diseo (aunque uno implementado por el compilador). Expresa diferencias de comportamiento (eso es lo que cambia) en objetos que tienen todos la misma interfaz (esto es lo que no cambia). La composicin tambin podra considerarse un patrn, ya que puede cambiar dinmica o estticamente los objetos que implementan su clase, y por lo tanto, la forma en la que funciona la clase. Normalmente, sin embargo, las caractersticas que los lenguajes de programacin soportan directamente no se han clasicado como patrones de diseo. Tambin ha visto ya otro patrn que aparece en el GoF: el iterador. Esta es la herramienta fundamental usada en el diseo del STL, descrito en captulos anteriores. El iterador esconde la implementacin concreta del contenedor a medida que se avanza y se seleccionan los elementos uno a uno. Los iteradores le ayudan a escribir cdigo genrico que realiza una operacin en todos los elementos de un rango sin tener en cuenta el contenedor que contiene el rango. Por lo tanto, cualquier contenedor que pueda producir iteradores puede utilizar su cdigo genrico.
i i
9.3. Simplicacin de modismos de objeto que hay y por lo tantok, no tenga que cambiarlo cuando aada un nuevo tipo de objeto. Este captulo presenta los patrones Singleton, Fbricas (Factories), y Constructor (Builder). 2. Estructural: Esto afecta a la manera en que los objetos se conectan con otros objetos para asegurar que los cambios del sistema no requieren cambiar esas conexiones. Los patrones estructurales suelen imponerlos las restricciones del proyecto. En este captulo ver el Proxy y el Adaptador (Adapter). 3. Comportacional: Objetos que manejan tipos particulares de acciones dentro de un programa. stos encapsulan procesos que quiere que se ejecuten, como interpretar un lenguaje, completar una peticin, moverse a travs de una secuencia (como en un iterador) o implementar un algoritmo. Este captulo contiene ejemplos de Comando (Command), Mtodo Plantilla (Template Method), Estado (State), Estrategia (Strategy), Cadena de Responsabilidad (Chain of Responsibility), Observador (Observer), FIXME: Despachador Mltiple (Multiple Dispatching) y Visitador (Visitor). El GoF incluye una seccin sobre cada uno de los 23 patrones, junto con uno o ms ejemplos de cada uno, tpicamente en C++ aunque a veces en SmallTalk. Este libro no repite los detalles de los patrones mostrados en GoF, ya que aqul FIXME: "stands on its own" y debera estudiarse aparte. La descripcin y los ejemplos que se dan aqu intentan darle una visin de los patrones, de forma que pueda hacerse una idea de lo que tratan y de porqu son importantes.
249 i i i i
i i
9.3.1. Mensajero
El ms trivial es el Mensajero (Messenger), [136] que empaqueta informacin en un objeto que se envia, en lugar de ir enviando todas las piezas independientemente. Ntese que sin el Mensajero, el cdigo para la funcin translate() sera mucho ms confuso:
//: C10:MessengerDemo.cpp #include <iostream> #include <string> using namespace std; class Point { // A messenger public: int x, y, z; // Since its just a carrier Point(int xi, int yi, int zi) : x(xi), y(yi), z(zi) {} Point(const Point& p) : x(p.x), y(p.y), z(p.z) {} Point& operator=(const Point& rhs) { x = rhs.x; y = rhs.y; z = rhs.z; return *this; } friend ostream& operator<<(ostream& os, const Point& p) { return os << "x=" << p.x << " y=" << p.y << " z=" << p.z; } }; class Vector { // Mathematical vector public: int magnitude, direction; Vector(int m, int d) : magnitude(m), direction(d) {} }; class Space { public: static Point translate(Point p, Vector v) { // Copy-constructor prevents modifying the original. // A dummy calculation: p.x += v.magnitude + v.direction; p.y += v.magnitude + v.direction; p.z += v.magnitude + v.direction; return p; } }; int main() { Point p1(1, 2, 3); Point p2 = Space::translate(p1, Vector(11, 47)); cout << "p1: " << p1 << " p2: " << p2 << endl; } ///:~
i i
9.3. Simplicacin de modismos Como el objetivo del Mensajero es simplemente llevar datos, dichos datos se hacen pblicos para facilitar el acceso. Sin embargo, podra tener razones para hacer estos campos privados.
El parmetro de recoleccin debe tener alguna forma de establecer o insertar valores. Ntese que por esta denicin, un Mensajero podra usarse como parmetro de recoleccin. La clave reside en que el parmetro de recoleccin se pasa y es modicado por la funcin que lo recibe. 251 i i i i
i i
9.4. Singleton
Posiblemente, el patrn de diseo ms simple del GoF es el Singleton, que es una forma de asegurar una nica instancia de una clase. El siguiente programa muestra cmo implementar un Singleton en C++:
//: C10:SingletonPattern.cpp #include <iostream> using namespace std; class Singleton { static Singleton s; int i; Singleton(int x) : i(x) { } Singleton& operator=(Singleton&); // Disallowed Singleton(const Singleton&); // Disallowed public: static Singleton& instance() { return s; } int getValue() { return i; } void setValue(int x) { i = x; } }; Singleton Singleton::s(47); int main() { Singleton& s = Singleton::instance(); cout << s.getValue() << endl; Singleton& s2 = Singleton::instance(); s2.setValue(9); cout << s.getValue() << endl; } ///:~
La clave para crear un Singleton es evitar que el programador cliente tenga control sobre el ciclo de vida del objeto. Para lograrlo, declare todos los constructores privados, y evite que el compilador genere implcitamente cualquier constructor. Fjese que el FIXME: constructor de copia? y el operador de asignacin (que intencionadamente carecen de implementacin alguna, ya que nunca van a ser llamados) estn declarados como privados, para evitar que se haga cualquier tipo de copia. Tambin debe decidir cmo va a crear el objeto. Aqu, se crea de forma esttica, pero tambin puede esperar a que el programador cliente pida uno y crearlo bajo demanda. Esto se llama "inicializacin vaga", y slo tiene sentido si resulta caro crear el objeto y no siempre se necesita. Si devuelve un puntero en lugar de una referencia, el usuario podra borrar el puntero sin darse cuenta, por lo que la implementacin citada anteriormente es ms segura (el destructor tambin podra declararse privado o protegido para solventar el problema). En cualquier caso, el objeto debera almacenarse de forma privada. Usted da acceso a travs de FIXME (funciones de miembros) pblicas. Aqu, instance() genera una referencia al objeto Singleton. El resto de la interfaz (getValue() y setValue()) es la interfaz regular de la clase. Fjese en que no est restringido a crear un nico objeto. Esta tcnica tambin soporta la creacion de un pool limitado de objetos. En este caso, sin embargo, puede enfrentarse al problema de compartir objetos del pool. Si esto supone un problema, 252 i i i i
i i 9.4. Singleton puede crear una solucin que incluya un check-out y un check-in de los objetos compartidos.
La implementacin no debe FIXME: hacerse en la misma lnea, porque eso signicara que la funcin entera, includa la denicin del objeto esttico que contiene, podra ser duplicada en cualquier unidad de traduccin donde se incluya, lo que viola la regla de nica denicin de C++. [137] Con toda seguridad, esto frustrara cualquier intento de controlar el orden de inicializacin (pero potencialmente de una forma sutil y difcil de detectar). De forma que la implementacin debe separarse:
//: C10:LogFile.cpp {O} #include "LogFile.h" std::ofstream& logfile() { static std::ofstream log("Logfile.log"); return log; } ///:~
Ahora el objeto log no se inicializar hasta la primera vez que se llame a logfile(). As que, si crea una funcin:
//: C10:UseLog1.h #ifndef USELOG1_H #define USELOG1_H void f(); #endif // USELOG1_H ///:~
i i
//: C10:UseLog1.cpp {O} #include "UseLog1.h" #include "LogFile.h" void f() { logfile() << __FILE__ << std::endl; } ///:~
el objecto log no se crea hasta la primera llamada a f(). Puede combinar fcilmente la creacin de objetos estticos dentro de una funcin miembro con la clase Singleton. SingletonPattern.cpp puede modicarse para usar esta aproximacin:[138]
//: C10:SingletonPattern2.cpp // Meyers Singleton. #include <iostream> using namespace std; class Singleton { int i; Singleton(int x) : i(x) { } void operator=(Singleton&); Singleton(const Singleton&); public: static Singleton& instance() { static Singleton s(47); return s; } int getValue() { return i; } void setValue(int x) { i = x; } }; int main() { Singleton& s = Singleton::instance(); cout << s.getValue() << endl; Singleton& s2 = Singleton::instance(); s2.setValue(9); cout << s.getValue() << endl;
254 i i i i
i i 9.4. Singleton
} ///:~
Se da un caso especialmente interesante cuando dos Singletons dependen mutuamente el uno del otro, de esta forma:
//: C10:FunctionStaticSingleton.cpp class Singleton1 { Singleton1() {} public: static Singleton1& ref() { static Singleton1 single; return single; } }; class Singleton2 { Singleton1& s1; Singleton2(Singleton1& s) : s1(s) {} public: static Singleton2& ref() { static Singleton2 single(Singleton1::ref()); return single; } Singleton1& f() { return s1; } }; int main() { Singleton1& s1 = Singleton2::ref().f(); } ///:~
Cuando se llama a Singleton2::ref(), hace que se cree su nico objeto Singleton2. En el proceso de esta creacin, se llama a Singleton1::ref(), y esto hace que se cree su objeto nico Singleton1. Como esta tcnica no se basa en el orden de linkado ni el de carga, el programador tiene mucho mayor control sobre la inicializacin, lo que redunda en menos problemas. Otra variacin del Singleton separa la unicidad de un objeto de su implementacin. Esto se logra usando el "Patrn Plantilla Curiosamente Recursivo" mencionado en el Captulo 5:
//: C10:CuriousSingleton.cpp // Separates a class from its Singleton-ness (almost). #include <iostream> using namespace std; template<class T> class Singleton { Singleton(const Singleton&); Singleton& operator=(const Singleton&); protected: Singleton() {} virtual ~Singleton() {} public: static T& instance() {
255 i i i i
i i
MyClass se convierte en Singleton: 1. Haciendo que su constructor sea private o protected. 2. Hacindose amigo de Singleton<MyClass>. 3. Derivando MyClass desde Singleton<MyClass>. La auto-referencia del paso 3 podra sonar inversmil, pero tal como se explic en el Captulo 5, funciona porque slo hay una dependencia esttica sobre el argumento plantilla de la plantilla Singleton. En otras palabras, el cdigo de la clase Singleton<MyClass> puede ser instanciado por el compilador porque no depende del tamao de MyClass. Es despus, cuando se a Singleton<MyClass>::instance(), cuando se necesita el tamao de MyClass, y para entonces MyClass ya se ha compilado y su tamao se conoce.[139] Es interesante lo intrincado que un patrn tan simple como el Singleton puede llegar a ser, y ni siquiera se han tratado todava asuntos de seguridad de hilos. Por ltimo, el patrn Singleton debera usarse lo justo y necesario. Los verdaderos objetos Singleton rara vez aparecen, y la ltima cosa para la que debe usarse un Singleton es para remplazar a una variable global. [140]
i i
9.5. Comando: elegir la operacin Este trmino se menciona en el GoF, pero no se usa. Sin embargo, el concepto de "objeto funcin" se repite en numerosos patrones del libro. Un Comando es un objeto funcin en su estado ms puro: una funcin que tiene un objeto. Al envolver una funcin en un objeto, puede pasarla a otras funciones u objetos como parmetro, para decirles que realicen esta operacin concreta mientras llevan a cabo su peticin. Se podra decir que un Comando es un Mensajero que lleva un comportamiento.
//: C10:CommandPattern.cpp #include <iostream> #include <vector> using namespace std; class Command { public: virtual void execute() = 0; }; class Hello : public Command { public: void execute() { cout << "Hello "; } }; class World : public Command { public: void execute() { cout << "World! "; } }; class IAm : public Command { public: void execute() { cout << "Im the command pattern!"; } }; // An object that holds commands: class Macro { vector<Command*> commands; public: void add(Command* c) { commands.push_back(c); } void run() { vector<Command*>::iterator it = commands.begin(); while(it != commands.end()) (*it++)->execute(); } }; int main() { Macro macro; macro.add(new Hello); macro.add(new World); macro.add(new IAm); macro.run(); } ///:~
El punto principal del Comando es permitirle dar una accin deseada a una funcin u objeto. En el ejemplo anterior, esto provee una manera de encolar un conjunto 257 i i i i
i i
Captulo 9. Patrones de Diseo de acciones que se deben ejecutar colectivamente. Aqu, puede crear dinmicamente nuevos comportamientos, algo que puede hacer normalmente escribiendo nuevo cdigo, pero en el ejemplo anterior podra hacerse interpretando un script (vea el patrn Intrprete si lo que necesita hacer se vuelve demasiado complicado). Segn el GoF, los Comandos son un sustituto orientado a objetos de las retrollamadas (callbacks). [141] Sin embargo, pensamos que la palabra "retro" es una parte esencial del concepto de retrollamada -una retrollamada retorna al creador de la misma. Por otro lado, un objeto Comando, simplemente se crea y se entrega a alguna funcin u objeto, y no se permanece conectado de por vida al objecto Comando. Un ejemplo habitual del patrn Comando es la implementacin de la funcionalidad de "deshacer" en una aplicacin. Cada vez que el usuario realiza una operacin, se coloca el correspondiente objeto Comando de deshacer en una cola. Cada objeto Comando que se ejecuta guarda el estado del programa en el paso anterior.
258 i i i i
i i
259 i i i i
i i
Aqu, el objeto Comando est representado por Tareas ejecutadas por el Singleton TaskRunner. EventSimulator crea un retraso aleatorio, de modo que si se llama peridicamente a la funcin red() el resultado cambiar de false a true en algn momento aleatorio. Los objetos EventSimulator se utilizan dentro de los Botones para simular que ocurre un evento de usuario en un momento impredecible. CheckButton es la implementacin de la Tarea que es comprobada peridicamente por todo el cdigo "normal" del progama. Puede ver cmo ocurre al nal de procedure1(), procedure2() y procedure3(). Aunque esto requiere un poco ms de razonamiento para establecerlo, ver en el Captulo 11 que utilizar hilos requiere mucho pensamiento y cuidado para prevenir las muchas dicultades inhenerentes a la programacin concurrente, por lo que la solucin ms simple puede ser preferible. Tambin puede crear un esquema de hilos muy simple moviendo las llamadas a TaskRunner::run() a un objeto temporizador multi-hilo. Al hacer esto, se elimina todo el acoplamiento entre las operaciones "normales" (los "procedures" en el ejemplo anterior) y el cdigo de eventos. 260 i i i i
i i
class Proxy : public ProxyBase { ProxyBase* implementation; public: Proxy() { implementation = new Implementation(); } ~Proxy() { delete implementation; } // Forward calls to the implementation: void f() { implementation->f(); } void g() { implementation->g(); }
261 i i i i
i i
En algunos casos, Implementation no necesita la misma interfaz que Proxy, siempre y cuando Proxy est de alguna forma hablando en nombre de la clase Implementacin y referenciando llamadas a funcin hacia ella, entonces la idea bsica se satisface (note que esta armacin est reida con la denicin de Proxy del GoF). Sin embargo, con una interfaz comn es posible realizar un reemplazo FIXME: drop-in del proxy en el cdigo del cliente -el cdigo del cliente est escrito para hablar al objeto original, y no necesita ser cambiado para aceptar el proxy (ste es probablemente el quiz principal de Proxy). Adems, se fuerza a que Implementation complete, a travs de la interfaz comn, todas las funciones que Proxy necesita llamar. La diferencia entre Proxy y Estado est en los problemas que pueden resolver. Los usos ms comunes para Proxy que describe el GoF son: 1. Proxy remoto. Representan a objetos en un espacio de direcciones distinto. Lo implementan algunas tecnologas de objetos remotos. 2. Proxy virtual. Proporciona inicializacin FIXME: vaga para crear objetos costosos bajo demanda. 3. Proxy de proteccin. Se usa cuando no se desea que el programador cliente tenga acceso completo al objecto representado. 4. Referencia inteligente. Para aadir acciones adicionales cuando se acceda al objeto representado. El conteo de referencias es un buen ejemplo: mantiene un registro del nmero de referencias que se mantienen para un objeto en particular, para implementar el FIXME: copy-on-write idiom y para prevenir el FIXME: object aliasing.
262 i i i i
i i
Sin embargo, la funcin greet(), y cualquier otra funcin que tenga que comprobar isFrog antes de realizar sus operaciones, acaban con cdigo poco elegante, especialmente cuando haya que aadir estados adicionales al sistema. Delegando las operaciones a un objeto Estado que puede cambiarse, el cdigo se simplica.
//: C10:KissingPrincess2.cpp // The State pattern. #include <iostream> #include <string> using namespace std; class Creature { class State { public: virtual string response() = 0; }; class Frog : public State { public: string response() { return "Ribbet!"; } }; class Prince : public State { public: string response() { return "Darling!"; } }; State* state; public: Creature() : state(new Frog()) {} void greet() { cout << state->response() << endl; } void kiss() { delete state; state = new Prince(); } };
263 i i i i
i i
No es necesario hacer las clases FIXME: implementadoras anidadas ni privadas, pero si lo hace, el cdigo ser ms limpio. Note que los cambios en las clases Estado se propagan automticamente por todo su cdigo, en lugar de requerir una edicin de las clases para efectuar los cambios.
9.7. Adaptador
Un Adaptador coge un tipo y genera una interfaz para algn otro tipo. Es til cuando se tiene una librera o trozo de cdigo que tiene una interfaz particular, y otra librera o trozo de cdigo que usa las mismas ideas bsicas que la primera librera, pero se expresa de forma diferente. Si se adaptan las formas de expresin entre s, se puede crear una solucin rpidamente. Suponga que tiene una clase productora que genera los nmeros de Fibonacci:
//: C10:FibonacciGenerator.h #ifndef FIBONACCIGENERATOR_H #define FIBONACCIGENERATOR_H class FibonacciGenerator { int n; int val[2]; public: FibonacciGenerator() : n(0) { val[0] = val[1] = 0; } int operator()() { int result = n > 2 ? val[0] + val[1] : n > 0 ? 1 : 0; ++n; val[0] = val[1]; val[1] = result; return result; } int count() { return n; } }; #endif // FIBONACCIGENERATOR_H ///:~
264 i i i i
i i 9.7. Adaptador
cout << f.count() << ": " << f() << endl; } ///:~
A lo mejor le gustara coger este generador y realizar operaciones de algoritmos numricos STL con l. Desafortunadamente, los algoritmos STL slo trabajan con iteradores, as que tiene dos interfaces que no casan. La solucin es crear un adaptador que coja el FibonacciGenerator y produzca un iterador para los algoritmos STL a usar. Dado que los algoritmos numricos slo necesitan un iterador de entrada, el Adaptador es bastante directo (para algo que produce un iterador STL, es decir):
//: C10:FibonacciAdapter.cpp // Adapting an interface to something you already have. #include <iostream> #include <numeric> #include "FibonacciGenerator.h" #include "../C06/PrintSequence.h" using namespace std; class FibonacciAdapter { // Produce an iterator FibonacciGenerator f; int length; public: FibonacciAdapter(int size) : length(size) {} class iterator; friend class iterator; class iterator : public std::iterator< std::input_iterator_tag, FibonacciAdapter, ptrdiff_t> { FibonacciAdapter& ap; public: typedef int value_type; iterator(FibonacciAdapter& a) : ap(a) {} bool operator==(const iterator&) const { return ap.f.count() == ap.length; } bool operator!=(const iterator& x) const { return !(*this == x); } int operator*() const { return ap.f(); } iterator& operator++() { return *this; } iterator operator++(int) { return *this; } }; iterator begin() { return iterator(*this); } iterator end() { return iterator(*this); } }; int main() { const int SZ = 20; FibonacciAdapter a1(SZ); cout << "accumulate: " << accumulate(a1.begin(), a1.end(), 0) << endl; FibonacciAdapter a2(SZ), a3(SZ); cout << "inner product: " << inner_product(a2.begin(), a2.end(), a3.begin(), 0) << endl; FibonacciAdapter a4(SZ); int r1[SZ] = {0};
265 i i i i
i i
Se inicializa un FibonacciAdapter dicindole cun largo puede ser la secuencia de Fibonacci. Cuando se crea un iterador, simplemente captura una referencia al FibonacciAdapter que lo contiene para que pueda acceder al FibonacciGenerator y la longitud. Observe que la comparacin de equivalencia ignora el valor de la derecha, porque el nico asunto importante es si el generador ha alcanzado su longitud. Adems, el operator++() no modica el iterador; la nica operacin que cambia el estado del FibonacciAdapter es llamar a la funcin operator() del generador en el FibonacciGenerator. Puede aceptarse esta versin extremadamente simple del iterador porque las restricciones de un Input Iterator son muy estrictas; concretamente, slo se puede leer cada valor de la secuencia una vez. En main(), puede verse que los cuatro tipos distintos de algoritmos numricos se testan satisfactoriamente con el FibonacciAdapter.
266 i i i i
i i
El motor que ejecuta la aplicacin es el Template Method. En una aplicacin grca, este motor sera el bucle principal de eventos. El programador cliente simplemente proporciona las deniciones para customize1() y customize2(), y la aplicacin est lista para ejecutarse.
267 i i i i
i i
Normalmente, Context::greet() sera ms complejo; es el anlogo de Template Method porque contiene el cdigo que no cambia. Pero puede ver en main() que la eleccin de la estrategia puede realizarse en tiempo de ejecucin. Llendo un paso ms all, se puede combinar esto con el patrn Estado y cambiar la Estrategia durante el tiempo de vida del objeto Contexto.
i i
9.10. Cadena de Responsabilidad: intentar una secuencia de estrategias puede crearse dinmicamente, as que podra verse como una sentencia switch ms general y construida dinmicamente. En el GoF, hay bastante discusin sobre cmo crear la cadena de responsabilidad como una lista enlazada. Sin embargo, cuando se estudia el patrn, no debera importar cmo se crea la cadena; eso es un detalle de implementacin. Como el GoF se escribi antes de que los contenedores STL estuvieran disponibles en la mayora de los compiladores de C++, las razones ms probables son (1) que no haba listas includas y por lo tanto tenan que crear una y (2) que las estructuras de datos suelen verse como una habilidad fundamental en las Escuelas (o Facultades), y a los autores del GoF no se les ocurri la idea de que las estructuras de datos fueran herramientas estndar disponibles junto con el lenguaje de programacin.. Los detalles del contenedor usado para implementar la Cadena de Responsabilidad como una cadena (una lista enlazada en el GoF) no aaden nada a la solucin, y puede implementarse usando un contenedor STL, como se muestra abajo. Aqu puede ver una Cadena de Responsabilidad que encuentra automticamente una solucin usando un mecanismo para recorrer automtica y recursivamente cada Estrategia de la cadena:
//: C10:ChainOfReponsibility.cpp // The approach of the five-year-old. #include <iostream> #include <vector> #include "../purge.h" using namespace std; enum Answer { NO, YES }; class GimmeStrategy { public: virtual Answer canIHave() = 0; virtual ~GimmeStrategy() {} }; class AskMom : public GimmeStrategy { public: Answer canIHave() { cout << "Mooom? Can I have this?" << endl; return NO; } }; class AskDad : public GimmeStrategy { public: Answer canIHave() { cout << "Dad, I really need this!" << endl; return NO; } }; class AskGrandpa : public GimmeStrategy { public: Answer canIHave() { cout << "Grandpa, is it my birthday yet?" << endl; return NO; } };
269 i i i i
i i
class AskGrandma : public GimmeStrategy { public: Answer canIHave() { cout << "Grandma, I really love you!" << endl; return YES; } }; class Gimme : public GimmeStrategy { vector<GimmeStrategy*> chain; public: Gimme() { chain.push_back(new AskMom()); chain.push_back(new AskDad()); chain.push_back(new AskGrandpa()); chain.push_back(new AskGrandma()); } Answer canIHave() { vector<GimmeStrategy*>::iterator it = chain.begin(); while(it != chain.end()) if((*it++)->canIHave() == YES) return YES; // Reached end without success... cout << "Whiiiiinnne!" << endl; return NO; } ~Gimme() { purge(chain); } }; int main() { Gimme chain; chain.canIHave(); } ///:~
Observe que la clase de Contexto Gimme y todas las clases Estrategia derivan de la misma clase base, GimmeStrategy. Si estudia la seccin sobre Cadena de Responsabilidad del GoF, ver que la estructura diere signicativamente de la que se muestra ms arriba, porque ellos se centran en crear su propia lista enlazada. Sin embargo, si mantiene en mente que la esencia de Cadena de Responsabilidad es probar muchas soluciones hasta que encuentre la que funciona, se dar cuenta de que la implementacin del mecanismo de secuenciacin no es parte esencial del patrn.
i i
9.11. Factoras: encapsular la creacin de objetos el codigo que crea objetos est distribuido por toda la aplicacin, se obtiene el mismo problema que cuando se aaden tipos -hay que localizar todos los puntos del cdigo donde el tipo tiene importancia. Lo que imoporta es la creacin del tipo, ms que el uso del mismo (de eso se encarga el polimorsmo), pero el efecto es el mismo: aadir un nuevo tipo puede causar problemas. La solucin es forzar a que la creacin de objetos se lleve a cabo a travs de una factora comn, en lugar de permitir que el cdigo creacional se disperse por el sistema. Si todo el cdigo del programa debe ir a esta factora cada vez que necesita crear uno de esos objetos, todo lo que hay que hacer para aadir un objeto es modicar la factora. Este diseo es una variacin del patrn conocido comnmente como Factory Method. Dado que todo programa orientado a objetos crea objetos, y como es probable que haya que extender el programa aadiendo nuevos tipos, las factoras pueden ser el ms til de todos los patrones de diseo. Como ejemplo, considere el ampliamente usado ejemplo de gura (Shape). Una aproximacin para implementar una factora es denir una funcin miembro esttica en la clase base:
//: C10:ShapeFactory1.cpp #include <iostream> #include <stdexcept> #include <cstddef> #include <string> #include <vector> #include "../purge.h" using namespace std; class Shape { public: virtual void draw() = 0; virtual void erase() = 0; virtual ~Shape() {} class BadShapeCreation : public logic_error { public: BadShapeCreation(string type) : logic_error("Cannot create type " + type) {} }; static Shape* factory(const string& type) throw(BadShapeCreation); }; class Circle : public Shape { Circle() {} // Private constructor friend class Shape; public: void draw() { cout << "Circle::draw" << endl; } void erase() { cout << "Circle::erase" << endl; } ~Circle() { cout << "Circle::~Circle" << endl; } }; class Square : public Shape { Square() {} friend class Shape; public: void draw() { cout << "Square::draw" << endl; } void erase() { cout << "Square::erase" << endl; } ~Square() { cout << "Square::~Square" << endl; }
271 i i i i
i i
La funcin factory() toma un argumento que le permite determinar qu tipo de gura crear. Aqu, el argumento es una cadena, pero podra ser cualquier conjunto de datos. El mtodo factory() es el nico cdigo del sistema que hay que cambiar cuando se aade un nuevo tipo de gura. (Los datos de inicializacin para los objetos vendrn supuestamente de algn sitio fuera del sistema y no sern un FIXME: hardcoded array como en el ejemplo.) Para asegurar que la creacin slo puede realizarse en factory(), los constructores de cada tipo especco de gura se hacen privados, y Shape se declara como friend de forma que factory() tiene acceso a los mismos. (Tambin se podra declarar slamente Shape::factory() como friend, pero parece razonablemente inocuo declarar la clase base entera.) Hay otra implicacin importante de este diseo -la clase base, Shape, debe conocer ahora los detalles de todas las clases derivadas -una propiedad que el diseo orientado a objetos intenta evitar. Para frameworks o cualquier librera de clases que deban poder extenderse, esto hace que se convierta rpidamente en algo difcil de manejar, ya que la clase base debe actualizarse en cuanto se aada un tipo nuevo a la jerarqua. Las factoras polimrcas, descritas en la siguiente subseccin, se pueden usar para evitar esta dependencia circular tan poco deseada.
i i
9.11. Factoras: encapsular la creacin de objetos ser del patrn Factory Method es que diferentes tipos de factoras se puedan derivar de la factora bsica. Factory Method es, de hecho, un tipo especial de factora polimrca. Esto es ShapeFactory1.cpp modicado para que los Factory Methods estn en una clase aparte como funciones virtuales.
//: C10:ShapeFactory2.cpp // Polymorphic Factory Methods. #include <iostream> #include <map> #include <string> #include <vector> #include <stdexcept> #include <cstddef> #include "../purge.h" using namespace std; class Shape { public: virtual void draw() = 0; virtual void erase() = 0; virtual ~Shape() {} }; class ShapeFactory { virtual Shape* create() = 0; static map<string, ShapeFactory*> factories; public: virtual ~ShapeFactory() {} friend class ShapeFactoryInitializer; class BadShapeCreation : public logic_error { public: BadShapeCreation(string type) : logic_error("Cannot create type " + type) {} }; static Shape* createShape(const string& id) throw(BadShapeCreation) { if(factories.find(id) != factories.end()) return factories[id]->create(); else throw BadShapeCreation(id); } }; // Define the static object: map<string, ShapeFactory*> ShapeFactory::factories; class Circle : public Shape { Circle() {} // Private constructor friend class ShapeFactoryInitializer; class Factory; friend class Factory; class Factory : public ShapeFactory { public: Shape* create() { return new Circle; } friend class ShapeFactoryInitializer; }; public: void draw() { cout << "Circle::draw" << endl; }
273 i i i i
i i
274 i i i i
i i
9.11. Factoras: encapsular la creacin de objetos Ahora, Factory Method aparece en su propia clase, ShapeFactory, como virtual create(). Es una funcin miembro privada, lo que signica que no puede ser llamada directametne, pero puede ser sobreescrita. Las subclases de Shape deben crear cada una su propias subclases de ShapeFactory y sobreescribir el mtodo create para crear un objeto de su propio tipe. Estas factoras son privadas, de forma que slo pueden ser accedidas desde el Factory Method principal. De esta forma, todo el cdigo cliente debe pasar a travs del Factory Method para crear objetos. La verdadera creacin de guras se realiza llamando a ShapeFactory::createShape( ), que es una funcin esttica que usa el mapa en ShapeFactory para encontrar la objeto factora apropiado basndose en el identicador que se le pasa. La factora crea el objeto gura directamente, pero podra imaginarse un problema ms complejo en el que el objeto factora apropiado se devuelve y luego lo usa quien lo ha llamado para crear un objeto de una manera ms sosticada. Sin embargo, parece que la mayora del tiempo no hacen falta las complejidades del Factory Method polimrco, y bastar con una nica funcin esttica en la clase base (como se muestra en ShapeFactory1.cpp). Observe que el ShapeFactory debe ser inicializado cargando su mapa con objetos factory, lo que tiene lugar en el Singleton ShapeFactoryInitializer. As que para aadir un nuevo tipo a este diseo debe denir el tipo, crear una factora, y modicar ShapeFactoryInitializer para que se inserte una instancia de su factora en el mapa. Esta complejidad extra, sugiere de nuevo el uso de un Factory Method esttico si no necesita crear objetos factora individuales.
275 i i i i
i i
276 i i i i
i i
En este entorno, los objetos Player interactan con objetos Obstacle, pero los tipos de los jugadores y los obstculos dependen del juego. El tipo de juego se determina eligiendo un GameElementFactory concreto, y luego el GameEnvironment controla la conguracin y ejecucin del juego. En este ejemplo, la conguracin y ejecucin son simples, pero dichas actividades (las condiciones iniciales y los cambios de estado) pueden determinar gran parte del resultado del juego. Aqu, GameEnvironment no est diseado para ser heredado, aunque puede tener sentido hacerlo. Este ejemplo tambin ilustra el despachado doble, que se explicar ms adelante.
277 i i i i
i i
278 i i i i
i i
279 i i i i
i i
class BicycleBuilder { protected: Bicycle* product; public: BicycleBuilder() { product = 0; } void createProduct() { product = new Bicycle; } virtual void buildFrame() = 0; virtual void buildWheel() = 0; virtual void buildSeat() = 0; virtual void buildDerailleur() = 0; virtual void buildHandlebar() = 0; virtual void buildSprocket() = 0; virtual void buildRack() = 0; virtual void buildShock() = 0; virtual std::string getBikeName() const = 0; Bicycle* getProduct() { Bicycle* temp = product; product = 0; // Relinquish product return temp; } }; class MountainBikeBuilder : public BicycleBuilder { public: void buildFrame(); void buildWheel(); void buildSeat(); void buildDerailleur(); void buildHandlebar(); void buildSprocket(); void buildRack(); void buildShock(); std::string getBikeName() const { return "MountainBike";} }; class TouringBikeBuilder : public BicycleBuilder { public: void buildFrame(); void buildWheel(); void buildSeat(); void buildDerailleur(); void buildHandlebar(); void buildSprocket(); void buildRack(); void buildShock(); std::string getBikeName() const { return "TouringBike"; } }; class RacingBikeBuilder : public BicycleBuilder { public: void buildFrame(); void buildWheel(); void buildSeat(); void buildDerailleur(); void buildHandlebar(); void buildSprocket(); void buildRack();
280 i i i i
i i
//: C10:Bicycle.cpp {O} {-mwcc} #include "Bicycle.h" #include <cassert> #include <cstddef> using namespace std; std::string BicyclePart::names[NPARTS] = { "Frame", "Wheel", "Seat", "Derailleur", "Handlebar", "Sprocket", "Rack", "Shock" }; // MountainBikeBuilder implementation void MountainBikeBuilder::buildFrame() { product->addPart(new BicyclePart(BicyclePart::FRAME)); } void MountainBikeBuilder::buildWheel() { product->addPart(new BicyclePart(BicyclePart::WHEEL)); } void MountainBikeBuilder::buildSeat() { product->addPart(new BicyclePart(BicyclePart::SEAT)); } void MountainBikeBuilder::buildDerailleur() { product->addPart( new BicyclePart(BicyclePart::DERAILLEUR)); } void MountainBikeBuilder::buildHandlebar() { product->addPart( new BicyclePart(BicyclePart::HANDLEBAR)); } void MountainBikeBuilder::buildSprocket() { product->addPart(new BicyclePart(BicyclePart::SPROCKET)); } void MountainBikeBuilder::buildRack() {} void MountainBikeBuilder::buildShock() { product->addPart(new BicyclePart(BicyclePart::SHOCK)); } // TouringBikeBuilder implementation void TouringBikeBuilder::buildFrame() { product->addPart(new BicyclePart(BicyclePart::FRAME)); } void TouringBikeBuilder::buildWheel() { product->addPart(new BicyclePart(BicyclePart::WHEEL)); }
281 i i i i
i i
282 i i i i
i i
283 i i i i
i i
9.13. Observador
//: C10:Observer.h // The Observer interface. #ifndef OBSERVER_H #define OBSERVER_H class Observable; class Argument {}; class Observer { public: // Called by the observed object, whenever // the observed object is changed: virtual void update(Observable* o, Argument* arg) = 0; virtual ~Observer() {} }; #endif // OBSERVER_H ///:~
//: C10:Observable.h // The Observable class. #ifndef OBSERVABLE_H #define OBSERVABLE_H #include <set> #include "Observer.h" class Observable { bool changed; std::set<Observer*> observers; protected: virtual void setChanged() { changed = virtual void clearChanged() { changed public: virtual void addObserver(Observer& o) observers.insert(&o); } virtual void deleteObserver(Observer&
true; } = false; } {
o) {
284 i i i i
i i 9.13. Observador
observers.erase(&o); } virtual void deleteObservers() { observers.clear(); } virtual int countObservers() { return observers.size(); } virtual bool hasChanged() { return changed; } // If this object has changed, notify all // of its observers: virtual void notifyObservers(Argument* arg = 0) { if(!hasChanged()) return; clearChanged(); // Not "changed" anymore std::set<Observer*>::iterator it; for(it = observers.begin();it != observers.end(); it++) (*it)->update(this, arg); } virtual ~Observable() {} }; #endif // OBSERVABLE_H ///:~
//: C10:InnerClassIdiom.cpp // Example of the "inner class" idiom. #include <iostream> #include <string> using namespace std; class Poingable { public: virtual void poing() = 0; }; void callPoing(Poingable& p) { p.poing(); } class Bingable { public: virtual void bing() = 0; }; void callBing(Bingable& b) { b.bing(); } class Outer { string name; // Define one inner class: class Inner1; friend class Outer::Inner1; class Inner1 : public Poingable { Outer* parent; public: Inner1(Outer* p) : parent(p) {} void poing() {
285 i i i i
i i
286 i i i i
i i 9.13. Observador
isOpen = false; closeNotifier.notifyObservers(); openNotifier.close(); } // Using the "inner class" idiom: class OpenNotifier; friend class Flower::OpenNotifier; class OpenNotifier : public Observable { Flower* parent; bool alreadyOpen; public: OpenNotifier(Flower* f) : parent(f), alreadyOpen(false) {} void notifyObservers(Argument* arg = 0) { if(parent->isOpen && !alreadyOpen) { setChanged(); Observable::notifyObservers(); alreadyOpen = true; } } void close() { alreadyOpen = false; } } openNotifier; class CloseNotifier; friend class Flower::CloseNotifier; class CloseNotifier : public Observable { Flower* parent; bool alreadyClosed; public: CloseNotifier(Flower* f) : parent(f), alreadyClosed(false) {} void notifyObservers(Argument* arg = 0) { if(!parent->isOpen && !alreadyClosed) { setChanged(); Observable::notifyObservers(); alreadyClosed = true; } } void open() { alreadyClosed = false; } } closeNotifier; }; class Bee { string name; // An "inner class" for observing openings: class OpenObserver; friend class Bee::OpenObserver; class OpenObserver : public Observer { Bee* parent; public: OpenObserver(Bee* b) : parent(b) {} void update(Observable*, Argument *) { cout << "Bee " << parent->name << "s breakfast time!" << endl; } } openObsrv; // Another "inner class" for closings: class CloseObserver; friend class Bee::CloseObserver;
287 i i i i
i i
288 i i i i
i i
289 i i i i
i i
290 i i i i
i i
291 i i i i
i i
292 i i i i
i i 9.15. Resumen
// Perform "Bee" operation on all Flowers: Bee bee; for(it = v.begin(); it != v.end(); it++) (*it)->accept(bee); purge(v); } ///:~
293 i i i i
i i
i i i
i i
10: Concurrencia
Los objetos ofrecen una forma de dividir un programa en diferentes secciones. A menudo, tambin es necesario dividir un programa, independientemente de las subtareas en ejecucin. Utilizando multihilado, un hilo de ejecucin dirige cada una esas subtareas independientes, y puedes programar como si cada hilo tuviera su propia CPU. Un mecanismo interno reparte el tiempo de CPU por ti, pero en general, no necesitas pensar acerca de eso, lo que ayuda a simplicar la programacin con mltiples hilos. Un proceso es un programa autocontenido en ejecucin con su propio espacio de direcciones. Un sistema operativo multitarea puede ejecutar ms de un proceso (programa) en el mismo tiempo, mientras ....., por medio de cambios peridicos de CPU de una tarea a otra. Un hilo es una simple ujo de control secuencial con un proceso. Un proceso puede tener de este modo mltiples hilos en ejecucin concurrentes. Puesto que los hilos se ejecutan con un proceso simple, pueden compartir memoria y otros recursos. La dicultad fundamental de escribir programas multihilados est en coordinar el uso de esos recursos entre los diferentes hilos. Hay muchas aplicaciones posibles para el multihilado, pero lo ms usual es querer usarlo cuando tienes alguna parte de tu programa vinculada a un evento o recurso particular. Para evitar bloquear el resto de tu programa, creas un hilo asociado a ese evento o recurso y le permites ejecutarse independientemente del programa principal. La programacin concurrente se como caminar en un mundo completamente nuevo y aprender un nuevo lenguaje de programacin, o por lo menos un nuevo conjunto de conceptos del lenguaje. Con la aparicin del soporte para los hilos en la mayora de los sistemas operativos para microcomputadores, han aparecido tambin en los lenguajes de programacin o libreras extensiones para los hilos. En cualquier caso, programacin hilada: 1. Parece misteriosa y requiere un esfuerzo en la forma de pensar acerca de la programacin. 2. En otros lenguajes el soporte a los hilos es similar. Cuando entiendas los hilos, comprenders una jerga comn. Comprender la programacin concurrente est al mismo nivel de dicultad que comprender el polimorsmo. Si pones un poco de esfuerzo, podrs entender el mecanismo bsico, pero generalmente necesitar de un entendimiento y estudio profundo para desarrollar una comprensin autntica sobre el tema. La meta de este captulo es darte una base slida en los principios de concurrencia para que puedas entender los conceptos y escribir programas multihilados razonables. S consciente de que puedes conarte fcilmente. Si vas a escribir algo complejo, necesitars estudiar libros especcos sobre el tema.
295 i i i i
i i
10.1. Motivacin
Una de las razones ms convincentes para usar concurrencia es crear una interfaz sensible al usuario. Considera un programa que realiza una operacin de CPU intensiva y, de esta forma, termina ignorando la entrada del usuario y comienza a no responder. El programa necesita continuar controlandor sus operaciones, y al mismo tiempo necesita devolver el control al botn de la interfaz de usuario para que el programa pueda responder al usuario. Si tienes un botn de "Salir", no querrs estar forzado a sondearlo en todas las partes de cdigo que escribas en tu programa. (Esto acoplara tu botn de salir a lo largo del programa y sera un quebradero de cabeza a la hora de mantenerlo). ..... Una funcin convencional no puede continuar realizando sus operaciones y al mismo tiempo devolver el control al resto del programa. De hecho, suena a imposible, como si la CPU estuviera en dos lugares a la vez, pero esto es precisamente la "ilusin" que la concurrencia permite (en el caso de un sistema multiprocesador, debe haber ms de una "ilusin"). Tambin puedes usar concurrencia para optimizar la carga de trabajo. Por ejemplo, podras necesitar hacer algo importante mientras ests estancado esperando la llegada de una entrada del puerto I/O. Sin hilos, la nica solucin razonable es sondear los puertos I/O, que es costoso y puede ser difcil. Si tienes una mquina multiprocesador, los mltiples hilos pueden ser distribudos a lo largo de los mltiples procesadores, pudiendo mejorar considerablemente la carga de trabajo. Este es el tpico caso de los potentes servidores web multiprocesdor, que pueden distribuir un gran nmero de peticiones de usuario por todas las CPUs en un programa que asigna un hilo por peticin. Un programa que usa hilos en una mquina monoprocesador har una cosa en un tiempo dado, por lo que es tericamente posible escribir el mismo programa sin el uso de hilos. Sin embargo, el multihilado proporciona un benecio de optimizacin importante: El diseo de un programa puede ser maravillosamente simple. Algunos tipos de problemas, como la simulacin - un video juego, por ejemplo - son difciles de resolver sin el soporte de la concurrencia. El modelo hilado es una comodidad de la programacin para simplicar el manejo de muchas operaciones al mismo tiempo con un simple programa: La CPU desapilar y dar a cada hilo algo de su tiempo. Cada hilo tiene consciencia de que tiene un tiempo constante de uso de CPU, pero el tiempo de CPU est actualmente repartido entre todo los hilos. La excepcin es un programa que se ejecuta sobre mltiples CPUs. Pero una de las cosas fabulosas que tiene el hilado es que te abstrae de esta capa, por lo que tu cdigo no necesita saber si est ejecutndose sobre una sla CPU o sobre varias.[149] De este modo, usar hilos es una manera de crear programas escalables de forma transparente - si un programa se est ejecutando demasiado despacio, puedes acelerarlo fcilmente aadiendo CPUs a tu ordenador. La multitarea y el multihilado tienden a ser las mejores opciones a utilizar en un sistema multiprocesador. El uso de hilos puede reducir la eciencia computacional un poco, pero el aumento neto en el diseo del programa, balanceo de recursos, y la comodidad del usuario a menudo es ms valorado. En general, los hilos te permiten crear diseor ms desacoplados; de lo contrario, las partes de tu cdigo estara obligadas a prestar atencin a tareas que podras manejarlas con hilos normalmente.
296 i i i i
i i
297 i i i i
i i
Captulo 10. Concurrencia la lista de archivos a compilar. Adems, asegrate de incluir el directorio includo del archivo en la ruta de bsqueda de la cabecera para tu proyecto???. Los detalles exactos variarn de compilador en compilador, por lo que necesitars estar algo familiarizado con tu conjunto de herramientas para ser capaz de utilizar esta opcin. Una vez la compilacin ha nalizado con xito, el siguiente paso es crear un proyecto que use la nueva librera compilada. Primero, permite al compilador saber donde estn localizadas las cabeceras, por lo que tu instruccin #include funcionar correctamente. Habitualmente, necesitars en tu proyecto una opcin como se muestra:
-I/path/to/installation/include
Si utilizaste el script de conguracin, la ruta de instalacin ser el prejo de la que deniste (por defecto, /usr/local). Si utilizaste uno de los archivos de proyecto en la creacin del directorio, la ruta instalacin debera ser simplemente la ruta al directorio principal del archivo ZThreads. Despus, necesitars aadir una opcin a tu proyecto que permitir al enlazador saber donde est la librera. Si usaste el script de conguracin, se parecer a lo siguiente:
-L/path/to/installation/lib ?lZThread
De nuevo, si usaste el script de conguracin, la ruta de instalacin s ser el prejo de la que denistes. Si su utilizaste un archivo del proyecto, la ruta ser la misma que la del directorio principal de ZThreads. Nota que si ests utilizando Linux, o Cygwin (www.cygwin.com) bajo Windows, no deberas necesitar modicar la ruta de include o de la librera; el proceso por defecto de instalacin tendr cuidado para hacerlo por ti, normalmente. En GNU/Linux, es posible que necesites aadir lo siguiente a tu .bashrc para que el sistema pueda encontrar la el archivo de la librera compartida LibZThreadx.x.so.0 cuando ejecute programas de este captulo.
export LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH}
(Asumiendo que utilizas el proceso de instalacin por defecto y la librera compartida acaba en /user/local/lib/; en otro caso, cambia la ruta por tu localizacin.
298 i i i i
i i
Al hacerla una clase base abstracta, Runnable es fcilmente combinable con una clase bsica u otras clases. Para denir una tarea, simplemente hereda de la clase Runnable y sobreescribe run( ) para que la tarea haga lo que quieres. Por ejecomplo, la tarea LiftOff siguiente muestra la cuenta atrs antes de despegar:
//: C11:LiftOff.h // Demonstration of the Runnable interface. #ifndef LIFTOFF_H #define LIFTOFF_H #include <iostream> #include "zthread/Runnable.h" class LiftOff : public ZThread::Runnable { int countDown; int id; public: LiftOff(int count, int ident = 0) : countDown(count), id(ident) {} ~LiftOff() { std::cout << id << " completed" << std::endl; } void run() { while(countDown--) std::cout << id << ":" << countDown << std::endl; std::cout << "Liftoff!" << std::endl; } }; #endif // LIFTOFF_H ///:~
El identicador id sirve como distincin entre multiples instancias de la tarea. Si slo quieres hacer una instancia, debes utilizar el valor por defecto para identicarla. El destructor te permitir ver que tarea est destruda correctamente. En el siguiente ejemplo, las tareas de run( ) no estn dirigidas por hilos separados; directamente es una simple llamada en main( ):
//: C11:NoThread.cpp #include "LiftOff.h" int main() { LiftOff launch(10); launch.run(); } ///:~
299 i i i i
i i
Captulo 10. Concurrencia Cuando una clase deriva de Runnable, debe tene una funcin run( ), pero no tiene nada de especial - no produce ninguna habibilidad innata en el hilo. Para llevar a cabo el funcionamiento de los hilos, debes utilizas la clase Thread.
Synchronization_Exception forma parte de la librera ZThread y la clase base para todas las excepciones de ZThread. Se lanzar si hay un error al crear o usar un hilo. Un constructor de Thread slo necesita un puntero a un objeto Runnable. Al crear un objeto Thread se efectuar la incializacin necesaria del hilo y despus se llamar a Runnable::run() Puede aadir ms hilos fcilmente para controlar ms tareas. A continuacin, puede ver cmo los hilos se ejecutan con algn otro:
//: C11:MoreBasicThreads.cpp // Adding more threads. //{L} ZThread #include <iostream> #include "LiftOff.h" #include "zthread/Thread.h" using namespace ZThread; using namespace std; int main() { const int SZ = 5; try { for(int i = 0; i < SZ; i++)
300 i i i i
i i
El segundo argumento del constructor de LiftOff identica cada tarea. Cuando ejecute el programa, ver que la ejecucin de las distintas tareas se mezclan a medida que los hilos entran y salen de su ejecucin. Este intercambio est controlado automticamente por el planicador de hilos. Si tiene mltiples procesadores en su mquina, el planicador de hilos distribuir los hilos entre los procesadores de forma transparente. El bucle for puede parecer un poco extrao a priori ya que se crea localmente dentro del bucle for e inmediatamente despus sale del mbito y es destrudo. Esto hace que parezca que el hilo propiamente dicho pueda perderse inmediatamente, pero puede ver por la salida que los hilos, en efecto, estn en ejecucin hasta su nalizacin. Cuando crea un objeto Thread, el hilo asociado se registra en el sistema de hilos, que lo mantiene vivo. A pesar de que el objeto Thread local se pierde, el hilo sigue vivo hasta que su tarea asociada termina. Aunque puede ser poco intuitivo desde el punto de vista de C++, el concepto de hilos es la excepcin de la regla: un hilo crea un hilo de ejecucin separado que persiste despus de que la llamada a funcin nalice. Esta excepcin se reeja en la persistencia del hilo subyacente despus de que el objeto desaparezca.
301 i i i i
i i
Para hacer este programa interactivo, puede ejecutar una tarea que muestre el archivo en un hilo separado. De esta forma, el hilo principal puede leer la entrada del usuario, por lo que el programa se vuelve interactivo:
//: C11:ResponsiveUI.cpp {RunByHand} // Threading for a responsive user interface. //{L} ZThread #include <iostream> #include <fstream> #include <string> #include "zthread/Thread.h" using namespace ZThread; using namespace std; class DisplayTask : public Runnable { ifstream in; string line; bool quitFlag; public: DisplayTask(const string& file) : quitFlag(false) { in.open(file.c_str()); } ~DisplayTask() { in.close(); } void run() { while(getline(in, line) && !quitFlag) { cout << line << endl; Thread::sleep(1000); } } void quit() { quitFlag = true; } }; int main() { try { cout << "Press <Enter> to quit:" << endl; DisplayTask* dt = new DisplayTask("ResponsiveUI.cpp"); Thread t(dt); cin.get(); dt->quit(); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; } cout << "Shutting down..." << endl; } ///:~
Ahora el hilo main() puede responder inmediatamente cuando pulse Return e invocar quit() sobre DisplayTask. 302 i i i i
i i
10.3. Utilizacin de los hilos Este ejemplo tambin muestra la necesidad de una comunicacin entre tareas - la tarea en el hilo main() necesita parar al DisplayTask. Dado que tenemos un puntero a DisplayTask, puede pensar que bastara con llamar al destructor de ese puntero para matar la tarea, pero esto hace que los programas sean poco ables. El problema es que la tarea podra estar en mitad de algo importante cuando lo destruye y, por lo tanto, es probable que ponga el programa en un estado inestable. En este sentido, la propia tarea decide cuando es seguro terminar. La manera ms sencilla de hacer esto es simplemente noticar a la tarea que desea detener mediante una bandera booleana. Cuando la tarea se encuentre en un punto estable puede consultar esa bandera y hacer lo que sea necesario para limpiar el estado despus de regresar de run(). Cuando la tarea vuelve de run(), Thread sabe que la tarea se ha completado. Aunque este programa es lo sucientemente simple para que no haya problemas, hay algunos pequeos defectos respecto a la comunicacin entre pilas. Es un tema importante que se cubrir ms tarde en este captulo.
Note que algunos casos un Executor individual puede ser usado para crear y gestionar todo los hilos en su sistema. Debe colocar el cdigo correspondiente a los hilos dentro de un bloque try porque el mtodo execute() de un Executor puede lanzar una Synchronization_Exception si algo va mal. Esto es vlido para cualquier funcin que implique cambiar el estado de un objeto de sincronizacin (arranque de hilos, la adquisicin de mutexes, esperas en condiciones, etc.), tal y como aprender ms adelante en este captulo. 303 i i i i
i i
Captulo 10. Concurrencia El programa nalizar cuando todas las tareas en el Executor hayan concluido. En el siguiente ejemplo, ThreadedExecutor crea un hilo para cada tarea que quiera ejecutar, pero puede cambiar fcilmente la forma en la que esas tareas son ejecutadas reemplazando el ThreadedExecutor por un tipo diferente de Executor. En este captulo, usar un ThreadedExecutor est bien, pero para cdigo en produccin puede resultar excesivamente costoso para la creacin de muchos hilos. En ese caso, puede reemplazarlo por un PoolExecutor, que utilizar un conjunto limitado de hilos para lanzar las tareas registradas en paralelo:
//: C11:PoolExecutor.cpp //{L} ZThread #include <iostream> #include "zthread/PoolExecutor.h" #include "LiftOff.h" using namespace ZThread; using namespace std; int main() { try { // Constructor argument is minimum number of threads: PoolExecutor executor(5); for(int i = 0; i < 5; i++) executor.execute(new LiftOff(10, i)); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; } } ///:~
Con PoolExecutor puede realizar una asignacin inicial de hilos costosa de una sola vez, por adelantado, y los hilos se reutilizan cuando sea posible. Esto ahorra tiempo porque no est pagando el gasto de la creacin de hilos por cada tarea individual de forma constante. Adems, en un sistema dirigido por eventos, los eventos que requieren hilos para manejarlos puede ser generados tan rpido como quiera, basta con traerlos del pool. No exceder los recursos disponibles porque PoolExecutor utiliza un nmero limitado de objetos Thread. As, aunque en este libro se utilizar ThreadedExecutors, tenga en cuenta utilizar PoolExecutor para cdigo en produccin. ConcurrentExecutor es como PoolExecutor pero con un tamao jo de hilos. Es til para cualquier cosa que quiera lanzar en otro hilo de forma continua (una tarea de larga duracin), como una tare que escucha conexiones entrantes en un socket. Tambin es til para tareas cortas que quiera lanzar en un hilo, por ejemplo, pequeas tareas que actualizar un log local o remoto, o para un hilo que atienda a eventos. Si hay ms de una tarea registrada en un ConcurrentExecutor, cada una de ellas se ejecutar completamente hasta que la siguiente empiece; todas utilizando el mismo hilo. En el ejemplo siguiente, ver que cada tarea se completa, en el orden en el que fue registrada, antes de que la siguiente comience. De esta forma, un ConcurrentExecutor serializa las tareas que le fueron asignadas.
//: C11:ConcurrentExecutor.cpp //{L} ZThread #include <iostream>
304 i i i i
i i
Como un ConcurrentExecutor, un SynchronousExecutor se usa cuando quiera una nica tarea se ejecute al mismo tiempo, en serie en lugar de concurrente. A diferencia de ConcurrentExecutor, un SynchronousExecutor no crea ni gestiona hilos sobre si mismo. Utiliza el hilo que aadi la tarea y, as, nicamente acta como un punto focal para la sincronizacin. Si tiene n tareas registradas en un SynchronousExecutor, nunca habr 2 tareas que se ejecuten a la vez. En lugar de eso, cada una se ejecutar hasta su nalizacin y la siguiente en la cola comenzar. Por ejemplo, suponga que tiene un nmero de hilos ejecutando tareas que usan un sistema de archivos, pero est escribiendo cdigo portable luego no quiere utilizar ock() u otra llamada al sistema operativo especca para bloquear un archivo. Puede lanzar esas tareas con un SynchronousExecutor para asegurar que solamente una de ellas, en un tiempo determinado, est ejecutndose desde cualquier hilo. De esta manera, no necesita preocuparse por la sincronizacin del recurso compartido (y, de paso, no se cargar el sistema de archivos). Una mejor solucin pasa por sincronizar el recurso (lo cual aprender ms adelante en este captulo), sin embargo un SynchronousExecutor le permite evitar las molestias de obtener una coordinacin adecuada para prototipar algo.
//: C11:SynchronousExecutor.cpp //{L} ZThread #include <iostream> #include "zthread/SynchronousExecutor.h" #include "LiftOff.h" using namespace ZThread; using namespace std; int main() { try { SynchronousExecutor executor; for(int i = 0; i < 5; i++) executor.execute(new LiftOff(10, i)); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; } } ///:~
Cuando ejecuta el programa ver que las tareas son lanzadas en el orden en el que fueron registradas, y cada tarea se ejecuta completamente antes de que la siguiente 305 i i i i
i i
Captulo 10. Concurrencia empiece. Qu es lo que no ve y que hace que no se creen nuevos hilos? El hilo main() se usa para cada tarea, y debido a este ejemplo, ese es el hilo que registra todas las tareas. Podra no utilizar un SynchronousExecutor en cdigo en produccin porque, principalmente, es para prototipado.
306 i i i i
i i
Puede ver que la tarea del mtodo run() es en un bucle innito en su totalidad. Utilizando yield(), la salida se equilibra bastante que en el caso en el que no se cede el paso. Pruebe a comentar la llamada a Thread::yield() para ver la diferencia. Sin embargo, en general, yield() es til en raras ocasiones, y no puede contar con ella para realizar un anamiento serio sobre su aplicacin.
10.3.4. Dormido
Otra forma con la que puede tener control sobre el comportamiento de su hilos es llamando a sleep() para cesar la ejecucin de uno de ellos durante un nmero de milisegundos dado. En el ejemplo que viene a continuacin, si cambia la llamada a yield() por una a sleep(), obtendr lo siguiente:
//: C11:SleepingTask.cpp // Calling sleep() to pause for awhile. //{L} ZThread #include <iostream> #include "zthread/Thread.h" #include "zthread/ThreadedExecutor.h" using namespace ZThread; using namespace std; class SleepingTask : public Runnable { int countDown; int id; public: SleepingTask(int ident = 0) : countDown(5), id(ident) {} ~SleepingTask() { cout << id << " completed" << endl; } friend ostream& operator<<(ostream& os, const SleepingTask& st) { return os << "#" << st.id << ": " << st.countDown; } void run() { while(true) { try { cout << *this << endl; if(--countDown == 0) return; Thread::sleep(100); } catch(Interrupted_Exception& e) { cerr << e.what() << endl; } } } }; int main() { try { ThreadedExecutor executor; for(int i = 0; i < 5; i++) executor.execute(new SleepingTask(i)); } catch(Synchronization_Exception& e) { cerr << e.what() << endl;
307 i i i i
i i
Thread::sleep() puede lanzar una Interrupted_Exception(sobre las interrupciones aprender ms adelante), y puede ver que esta excepcin se captura en run(). Sin embargo, la tarea se crea y se ejecuta dentro de un bloque try en main() que captura Interrupted_Exception (la clase base para todas las excepciones de ZThread), por lo que no sera posible ignorar la excepcin en run() y asumir que se propagar al manejador en main()?. Esto no funcionar porque las excepciones no se propagarn a lo largo de los hilos para volver hacia main(). De esta forma, debe manejar cualquier excepcin que pueda ocurrir dentro de una tarea de forma local. Notar que los hilos tienden a ejecutarse en cualquier orden, lo que quiere decir que sleep() tampoco es una forma de controlar el orden de la ejecucin de los hilos. Simplemente para la ejecucin del hilo durante un rato. La nica garanta que tiene es que el hilo se dormir durante, al menos, 100 milisegundos (en este ejemplo), pero puede que tarde ms despus de que el hilo reinicie la ejecucin ya que el planicador de hilos tiene que volver a l tras haber expirado el intervalo. Si debe tener control sobre el orden de la ejecucin de hilos, su mejor baza es el uso de controles de sincronizacin (descritos ms adelante) o, en algunos casos, no usar hilos en todo, FIXMEbut instead to write your own cooperative routines that hand control to each other in a specied order.
10.3.5. Prioridad
La prioridad de un hilo representa la importancia de ese hilo para el planicador. Pese a que el orden en que la CPU ejecuta un conjunto de hilos es indeterminado, el planicador tender a ejecutar el hilo con mayor prioridad de los que estn esperando. Sin embargo, no quiere decir que hilos con menos prioridad no se ejecutarn (es decir, no tendr bloqueo de un hilo a causa de las prioridades). Simplemente, los hilos con menos prioridad tendern a ejecutarse menos frecuentemente. Se ha modicado MoreBasicThreads.cpp para mostrar los niveles de prioridad. Las prioridades se ajustan utilizando la funcin setPriority() de Thread.
//: C11:SimplePriorities.cpp // Shows the use of thread priorities. //{L} ZThread #include <iostream> #include "zthread/Thread.h" using namespace ZThread; using namespace std; const double pi = 3.14159265358979323846; const double e = 2.7182818284590452354; class SimplePriorities : public Runnable { int countDown; volatile double d; // No optimization int id; public: SimplePriorities(int ident=0): countDown(5), id(ident) {} ~SimplePriorities() { cout << id << " completed" << endl;
308 i i i i
i i
En este ejemplo, el operador <<() se sobreescribe para mostrar el identicador, la prioridad y el valor de countDown de la tarea. Puede ver que el nivel de prioridad del hilo es el ms alto, y que el resto de hilos tienen el nivel ms bajo. No utilizamos Executor en este ejemplo porque necesitamos acceder directamente al hilo para congurar sus propiedades. Dentro de SimplePriorities::run() se ejecutan 100,000 veces un costoso conjunto de clculos en punto otante. La variable d es voltil para intentar garantizar que ningn compilador hace optimizaciones. Sin este clculo, no comprobar el efecto de la conguracin de los niveles de prioridad. (Prubelo: comente el bucle for que contiene los clculos en doble precisin.) Con el clculo puede ver que el planicador de hilos al hilo high se le da ms preferencia. (Al menos, este fue el comportamiento sobre una mquina Windows). El clculo tarda lo suciente para que el mecanismo de planicacin de hilos lo salte, cambie hilos y tome en cuenta las prioridades para que el hilo high tenga preferencia. Tambin, puede leer la prioridad de un hilo existente con getPriority() y cambiarla en cualquier momento (no slo antes de que el hilo se ejecute, como en SimplePriorities.cpp) con setPriority(). La correspondencia de las prioridades con el sistema operativo es un problema. Por ejemplo, Windows 2000 tiene siete niveles de prioridades, mientras que Solaris de Sun tiene 231. El nico enfoque portable es ceirse a los niveles discretos de prioridad, como Low, Medium y High utilizados en la librera ZThread. 309 i i i i
i i
310 i i i i
i i
Podra parecer a priori que la clase Count es excesiva, pero si nicamente n es un int (en lugar de una matriz), el compilador puede ponerlo dentro de un registro y ese almacenamiento seguir estando disponible (aunque tcnicamente es ilegal) despus de que el objeto Count salga del mbito. Es difcil detectar la violacin de memoria en este caso. Sus resultados podran variar dependiendo de su compilador y de su sistema operativo, pero pruebe a que n sea un int y ver qu ocurre. En cualquier evento, si Count contiene una matriz de ints y como antes, el compilador est obligado a ponerlo en la pila y no en un registro. Incrementer es una tarea sencilla que utiliza un objeto Count. En main(), puede ver que las tareas Incrementer se ejecutan el tiempo suciente para que el salga del mbito, por lo que la tarea intentar acceder a un objeto que no existe. Esto produce un fallo en el programa. objeto Count 311 i i i i
i i
Captulo 10. Concurrencia Para solucionar este problema, debemos garantizar que cualquiera de los objetos compartidos entre tareas estarn accesibles tanto tiempo como las tareas los necesiten. (Si los objetos no fueran compartidos, podran estar directamente dentro de las clases de las tareas y, as, unir su tiempo de vida a la tarea.) Dado que no queremos que el propio mbito esttico del programa controle el tiempo de vida del objeto, pondremos el en heap. Y para asegurar que el objeto no se destruye hasta que no haya objetos (tareas, en este caso) que lo estn utilizando, utilizaremos el conteo de referencias. El conteo de referencias se ha explicado a lo largo del volumen uno de este libro y adems se revisar en este volumen. La librera ZThread incluye una plantilla llamada CountedPtr que automticamente realiza el conteo de referencias y destruye un objeto cuando su contador de referencias vale cero. A continuacin, se ha modicado el programa para que utilice CountedPtr para evitar el fallo:
//: C11:ReferenceCounting.cpp // A CountedPtr prevents too-early destruction. //{L} ZThread #include <iostream> #include "zthread/Thread.h" #include "zthread/CountedPtr.h" using namespace ZThread; using namespace std; class Count { enum { SZ = 100 }; int n[SZ]; public: void increment() { for(int i = 0; i < SZ; i++) n[i]++; } }; class Incrementer : public Runnable { CountedPtr<Count> count; public: Incrementer(const CountedPtr<Count>& c ) : count(c) {} void run() { for(int n = 100; n > 0; n--) { Thread::sleep(250); count->increment(); } } }; int main() { CountedPtr<Count> count(new Count); try { Thread t0(new Incrementer(count)); Thread t1(new Incrementer(count)); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; } } ///:~
312 i i i i
i i
10.4. Comparicin de recursos limitados Ahora Incrementer contiene un objeto CountedPtr, que gestiona un Count. En la funcin main(), los objetos CountedPtr se pasan a los dos objetos Incrementer por valor, por lo que se llama el constructor de copia, incrementando el conteo de referencias. Mientras la tarea est ejecutndose, el contador de referencias no valdr cero, por lo que el objeto Count utilizado por CountedPtr no ser destrudo. Solamente cuando todas las tareas que utilice el Count terminen se llamar al destructor (automticamente) sobre el objeto Count por el CountedPtr. Siempre que tenga una tarea que utilice ms de un objeto, casi siempre necesitar controlar aquellos objetos utilizando la plantilla CountedPtr para evitar problemas derivados del tiempo de vida de los objetos.
313 i i i i
i i
La clase Generator presenta la clase abstracta Cancelable, que es parte de la biblioteca de ZThread. El propsito de Cancelable es proporcionar una interfaz consistente para cambiar el estado de un objeto via cancel() y ver si el objeto ha sido cancelado con la funcin isCanceled(). Aqu utilizamos el enfoque simple de una bandera de cancelacin booleana similar a quitFlag, vista previamente en ResponsiveUI.cpp. Note que en este ejemplo la clase que es Cancelable no es Runnable. En su lugar, toda tarea EvenChecker que dependa de un objeto Cancelable (el Generator) lo comprueba para ver que ha sido cancelado, como puede ver en run(). De esta manera, las tareas que comparten recursos comunes (el Cancelable Generator) estn atentos a la seal de ese recurso para terminar. Esto elimina la tambin conocida condicin de carrera, donde dos o ms tareas compiten por responder una condicin y, as, colisionar o producir resultados inconsistentes. Debe pensar sobre esto cuidadosamente y protegerse de todas las formas posible de los fallos de un sistema concurrente. Por ejemplo, una tarea no puede depender de otra porque el orden de nalizacin de las tareas no est garantizado. En este sentido, eliminamos la potencial condicin de carrera haciendo que las tareas dependan de objetos que no son tareas (que son contados referencialmente utilizando CountedPtr. En las secciones posteriores, ver que la librera ZThread contiene ms mecanismos generales para la terminacin de hilos. Debido a que muchos objetos EvenChecker podran terminar compartiendo un Generator, la plantilla CountedPtr se usa para contar las referencias de los objetos Generator. El ltimo mtodo en EvenChecker es un miembro esttico de la plantilla que congura y realiza una comprobacin de los tipos de Generator creando un CountedPtr dentro y, seguidamente, lanzar un nmero de EvenCheckers que usan ese Generator. Si el Generator provoca un fallo, test() lo reportar y volver; en otro caso, deber pulsar Control-C para nalizarlo. Las tareas EvenChecker leen constantemente y comprueban que los valores de sus Generators asociados. Vea que si generator->isCanceled() es verdadero, run() retorna, con lo que se le dice al Executor de EvenChecker::test() que la tarea se ha completado. Cualquier tarea EvenChecker puede llamar a cancel() sobre su Generator asociado, lo que causar que todos los dems EvenCheckers que utilicen 314 i i i i
i i
10.4. Comparicin de recursos limitados ese Generator nalicen con elegancia. EvenGenerator es simple - nextValue() produce el siguiente valor constante:
//: C11:EvenGenerator.cpp // When threads collide. //{L} ZThread #include <iostream> #include "EvenChecker.h" #include "zthread/ThreadedExecutor.h" using namespace ZThread; using namespace std; class EvenGenerator : public Generator { unsigned int currentEvenValue; // Unsigned cant overflow public: EvenGenerator() { currentEvenValue = 0; } ~EvenGenerator() { cout << "~EvenGenerator" << endl; } int nextValue() { ++currentEvenValue; // Danger point here! ++currentEvenValue; return currentEvenValue; } }; int main() { EvenChecker::test<EvenGenerator>(); } ///:~
Es posible que un hilo llame a nextValue() despus de el primer incremento de currentEvenValue y antes del segundo (en el lugar "Danger point here!" del cdigo comentado), que pone el valor en un estado "incorrecto". Para probar que esto puede ocurrir, EventChecker::test() crea un grupo de objetos EventChecker para leer continuamente la salida de un EvenGenerator y ver si cada valor es constante. Si no es as, el error se reporta y el programa naliza. Este programa podra no detectar el problema hasta que EvenGenerator ha completado varios ciclos, dependiendo de las particuliaridades de su sistema operativo y otros detalles de implementacin. Si quiere ver que falla mucho ms rpido, pruebe a poner una llamada a yield() entre el primero y segundo incremento. En algn evento, fallar puntualmente a causa de que los hilos EvenChecker pueden acceder a la informacin en EvenGenerator mientras se encuentra en un estado "incorrecto".
i i
Captulo 10. Concurrencia necesitar alguna forma de evitar que dos hilos accedan al mismo recurso, al menos durante perodos crticos. Para prevenir este tipo de colisiones existe una manera sencilla que consiste en poner un bloqueo sobre un recursos cuando un hilo trata de usarlo. El primer hilo que accede al recursos lo bloquea y, as, otro hilo no puede acceder al recurso hasta que no sea desbloqueado, momento en el que este hilo lo vuelve a bloquear y lo vuelve a usar, y as sucesivamente. De esta forma, tenemos que ser capaces de evitar cualquier tarea de acceso a memoria mientras ese almacenamiento no est en un estado adecuado. Esto es, necesitamos tener un mecanismo que excluya una segunda tarea sobre el acceso a memoria cuando una primera tarea ya est usndola. Esta idea es fundamental para todo sistema multihilado y se conoce como exclusin mutua; abreviado como mutex. La biblioteca ZThread tiene un mecanismo de mutex en el chero de cabecera Mutex.h. Para solucionar el problema en el programa anterior, identicaremos las secciones crticas donde debe aplicarse la exclusin mutua; posteriormente, antes de entrar en la seccin crtica adquiriremos el mutex y lo liberaremos cuando nalice la seccin crtica. nicamente un hilo podr adquirir el mutex al mismo tiempo, por lo que se logra exclusin mutua:
//: C11:MutexEvenGenerator.cpp {RunByHand} // Preventing thread collisions with mutexes. //{L} ZThread #include <iostream> #include "EvenChecker.h" #include "zthread/ThreadedExecutor.h" #include "zthread/Mutex.h" using namespace ZThread; using namespace std; class MutexEvenGenerator : public Generator { unsigned int currentEvenValue; Mutex lock; public: MutexEvenGenerator() { currentEvenValue = 0; } ~MutexEvenGenerator() { cout << "~MutexEvenGenerator" << endl; } int nextValue() { lock.acquire(); ++currentEvenValue; Thread::yield(); // Cause failure faster ++currentEvenValue; int rval = currentEvenValue; lock.release(); return rval; } }; int main() { EvenChecker::test<MutexEvenGenerator>(); } ///:~
i i
10.4. Comparicin de recursos limitados lease() para crear una seccin crtica con nextValue(). Adems, se ha insertado una llamada a Thread::yield() entre los dos incrementos, para aumentar la probabilidad de que haya un cambio de contexto mientras currentEvenValue se encuentra en un estado extrao. Este hecho no producir un fallo ya que el mutex evita que ms de un hilo est en la seccin crtica al mismo tiempo, pero llamar a yield() es una buena forma de provocar un fallo si este ocurriera. Note que nextValue() debe capturar el valor de retorno dentro de la seccin crtica porque si lo devolviera dentro de la seccin critica no liberara lock y as evitar que fuera adquirido. (Normalmente, esto conllevara un interbloqueo, de lo cual aprender sobre ello al nal de este captulo.) El primer hilo que entre en nextValue() adquirir lock y cualquier otro hilo que intente adquirirlo ser bloqueado hasta que el primer hilo libere lock. En ese momento, el mecanismo de planicacin selecciona otro hilo que est esperando en lock. De esta manera, solo un hilo puede pasar a travs del cdigo custodiado por el mutex al mismo tiempo.
317 i i i i
i i
Note que el valor de retorno temporal ya no es necesario en nextValue(). En general, hay menos cdigo que escribir y la probabilidad de errores por parte del usuario se reduce en gran medida. Una caracterstica interesante de la plantilla Guard es que puede ser usada para manipular otros elementos de seguridad. Por ejemplo, un segundo Guard puede ser utilizado temporalmente para desbloquear un elemento de seguridad:
//: C11:TemporaryUnlocking.cpp // Temporarily unlocking another guard. //{L} ZThread #include "zthread/Thread.h" #include "zthread/Mutex.h" #include "zthread/Guard.h" using namespace ZThread; class TemporaryUnlocking { Mutex lock; public: void f() { Guard<Mutex> g(lock); // lock is acquired // ... { Guard<Mutex, UnlockedScope> h(g); // lock is released // ... // lock is acquired } // ... // lock is released } }; int main() { TemporaryUnlocking t; t.f(); } ///:~
Un Guard tambin puede utilizarse para adquirir un lock durante un determinado tiempo y, despus, liberarlo:
//: C11:TimedLocking.cpp
318 i i i i
i i
En este ejemplo, se lanzar una Timeout_Exception si el lock no puede ser adquirido en 500 milisegundos. Sincronizacin de clases completas La librera ZThread tambin proporciona la plantilla GuardedClass para crear automticamente un recubrimiento de sincronizacin para toda una clase. Esto quiere decir que cualquier mtodo de una clase estar automticamente protegido:
//: C11:SynchronizedClass.cpp {-dmc} //{L} ZThread #include "zthread/GuardedClass.h" using namespace ZThread; class MyClass { public: void func1() {} void func2() {} }; int main() { MyClass a; a.func1(); // Not synchronized a.func2(); // Not synchronized GuardedClass<MyClass> b(new MyClass); // Synchronized calls, only one thread at a time allowed: b->func1(); b->func2(); } ///:~
El objeto a no est sincronizado, por lo que func1() y func2() pueden ser llamadas en cualquier momento por cualquier nmero de hilos. El objeto b est protegido por el recubrimiento GuardedClass, as que cada mtodo se sincroniza automticamente y solo se puede llamar a una funcin por objeto en cualquier instante. 319 i i i i
i i
Captulo 10. Concurrencia El recubrimiento bloquea un tipo de nivel de granularidad, que podra afectar al rendimiento.[151] Si una clase contiene funciones no vinculadas, puede ser mejor sincronizarlas internamente con 2 locks diferentes. Sin embargo, si se encuentra haciendo esto, signica que la clase contiene grupos de datos que puede no estar fuertemente asociados. Considere dividir la clase en dos. Proteger todos los mtodos de una clase con un mutex no hace que esa clase sea segura automticamente cuando se utilicen hilos. Debe tener cuidado con estas cuestiones para garantizar la seguridad cuando se usan hilos.
320 i i i i
i i
Cuando crea un objeto ThreadLocal instanciando la plantilla, nicamente puede acceder al contenido del objeto utilizando los mtodos set() y get(). El mtodo get() devuelve una copia del objeto que est asociado a ese hilo, y set() inserta su argumento dentro del objeto almacenado para ese hilo, devolviendo el objeto antiguo que se encontraba almacenado. Puede comprobar que esto se utiliza en increment() y get() de ThreadLocalVariables. Ya que tlv se comparte en mltiples objetos Accessor, est escrito como un Cancelable, por lo que los Accessors puede recibir seales cuando queramos parar el sistema. Cuando ejecute este programa se evidenciar que se reserva para cada hilo su propio almacenamiento.
i i
Captulo 10. Concurrencia nalizacin sino que, adems, es un ejemplo adicional de comparicin de recursos. Para mostrar el ejemplo, primero necesitaremos resolver el problema de la colisin de iostream.
De esta manera, predenimos la funcin estandar operator<<() y el objeto puede ser construido en memoria utilizando operadores habituales de ostream. Cuando una tarea quiere mostrar una salida, crea un objeto ostringstream temporal que utiliza FIXME. Cuando llama a output(), el mutex evita que varios hilos escriban a este objeto Display. (Debe usar solo un objeto Display en su programa, tal y como ver en los siguientes ejemplos.) Todo esto muestra la idea bsica pero, si es necesario, puede construir un entorno ms elaborado. Por ejemplo, podra forzar el requisito de que solo haya un objeto Display en un programa hacindolo Singleton. (La librera ZThread tiene una plantilla Singleton para dar soporte a Singletons). 322 i i i i
i i
323 i i i i
i i
324 i i i i
i i
Count es la clase que conserva el contador principal de los visitantes del jardn. El objeto nico Count denido en main() como contador FIXME is held como un CountedPtr en Entrance y, as, se comparte entre todos los objetos Entrance. En este ejemplo, se utiliza un FastMutex llamado lock en vez de un Mutex ordinario ya que un FastMutex usa el mutex nativo del sistema operativo y, por ello, aportar resultados ms interesantes. Se utiliza un Guard con bloqueo en increment() para sincronizar el acceso a count. Esta funcin usa rand() para realizar una carga de trabajo alta (mediante yield()) FIXME la mitad del tiempo, .... La clase Entrance tambin mantiene una variable local numbre con el nmero de visitantes que han pasado a travs de una entrada concreta. Esto proporciona un chequeo doble contra el objeto count para asegurar que el verdadero nmero de visitantes es el que se est almacenando. Entrance::run() simplemente incrementa number y el objeto count y se duerme durante 100 milisegundos. En main, se carga un vector<Entrance*> con cada Entrance que se crean. Despus de que el usuario pulse Enter, el vector se utiliza para iterar sobre el valor de cada Entrance y calcular el total. FIXMEThis program goes to quite a bit of extra trouble to shut everything down in a stable fashion. Toda la comunicacin entre los objetos Entrance ocurre a travs de un nico objeto Count. Cuando el usuario pulsa Enter, main() manda el mensaje pause() a count. Como cada Entrance::run() est vigilando a que el objeto count est pausado, esto hace que cada Entrance se mueva al estado waitingForCancel, donde no se cuenta ms, pero an sigue vivo. Esto es esencial porque main() debe poder seguir iterando de forma segura sobre los objetos del vector<Entrace*>. Note que debido a que existe una FIXMEpequea posibilidad que la iteracin pueda ocurrir antes de que un Entrance haya terminado de contar y haya ido al estado de waitingForCancel, la funcin getValue() itera a lo largo de las llamadas a sleep() hasta que el objeto vaya al estado de waitingForCancel. (Esta es una forma, que se conoce como espera activa, y es indeseable. Ver un enfoque ms apropiado utilizando wait(), ms adelante en el captulo). Una vez que main() completa una iteracin a lo largo del vector<Entrance*>, se manda el mensaje de cancel() al objeto count, y de nuevo todos los objetos Entrance esperan a este cambio de estado. En ese instante, imprimen un mensaje de nalizacin y salen de run(), por lo que el mecanismo de hilado destruye cada tarea. 325 i i i i
i i
Captulo 10. Concurrencia Tal y como este programa se ejecuta, ver que la cuenta total y la de cada una de las entradas se muestran a la vez que la gente pasa a travs de un FIXMEturnstile. Si comenta el objeto Guard en Count::increment(), se dar cuenta que el nmero total de personas no es el que espera que sea. El nmero de personas contadas por cada FIXMEturnstile ser diferente del valor de count. Tan pronto como haya un Mutex para sincronizar el acceso al Counter, las cosas funcionarn correctamente. Tenga en cuenta que Count::increment() exagera la situacin potencial de fallo que supone utilizar temp y yield(). En problemas reales de hilado, la probabilidad de fallo puede ser estadsticamente menor, por lo que puede caer fcilmente en la trampa de creer que las cosas funcionan correctamente. Tal y como muestra el problema anterior, existen FIXMElikely problemas ocultos que no le han ocurrido, por lo que debe ser excepcionalmente diligente cuando revise cdigo concurrente.
Operaciones atmicas
Note que Count::value() devuelve el valor de count utilizando un objeto Guard para la sincronizacin. Esto ofrece un aspecto interesante porque este cdigo probablemente funcionar bien con la mayora de los compiladores y sistemas sin sincronizacin. El motivo es que, en general, una operacin simple como devolver un int ser una operacin atmica, que quiere decir que probablemente se llevar a cabo con una nica instruccin de microprocesador y no ser interrumpida. (El mecanismo de multihilado no puede parar un hilo en mitad de una instruccin de microprocesador.) Esto es, las operaciones atmicas no son interrumpibles por el mecanismo de hilado y, as, no necesitan ser protegidas.[152] De hecho, si eliminramos la asignacin de count en temp y quitramos yield(), y en su lugar simplemente incrementramos count directamente, probablemente no necesitaramos un lock ya que la operacin de incremento es, normalmente, atmica. [153] El problema es que el estndar de C++ no garantiza la atomicidad para ninguna de esas operaciones. Sin embargo, pese a que operaciones como devolver un int e incrementar un int son atmicas en la mayora de las mquinas no hay garantas. Y puesto que no hay garanta, debe asumir lo peor. En algunas ocasiones podra investigar el funcionamiento de la atomicidad para una mquina en particular (normalmente mirando el lenguaje ensamblador) y escribir cdigo basado en esas asunciones. Esto es siempre peligroso y FIXMEill-advised. Es muy fcil que esta informacin se pierda o est oculta, y la siguiente persona que venga podra asumir que el cdigo puede ser portado a otra mquina y, por ello, volverse loco siguiendo la pista al FIXMEoccsional glitch provocado por la colisin de hilos. Por ello, aunque quitar el guarda en Count::value() parezca que funciona no es FIXMEairtight y, as, en algunas mquinas puede ver un comportamiento aberrante.
326 i i i i
i i
10.5. Finalizacin de tareas inicializacin. En este momento se convierte en FIXMEcandidato para recibir tiempo de CPU. A continuacin, el planicador llevar a este hilo al estado de ejecucin o de bloqueo. 2. Ejecutable: Esto signica que un hilo puede ser ejecutado cuando el mecanismo de fraccionador de tiempo tenga ciclos de CPU disponibles para el hilo. As, el hilo podra o no ejecutarse en cualquier momento, pero no hay nada que evite FIXME 3. Bloqueado: El hilo pudo ser ejecutado, pero algo lo impidi. (Podra estar esperando a que se complete una operacin de entrada/salida, por ejemplo.) Mientras un hilo est en el estado de bloqueo, el planicador simplemente lo ignorar y no le dar tiempo de CPU. Hasta que un hilo no vuelva a entrar en el estado de ejecucin, no ejecutar ninguna operacin. 4. FIXMEMuerte: Un hilo en el estado de muerto no ser planicable y no recibir tiempo de CPU. Sus tareas han nalizado, y no ser ejecutable nunca ms. La forma normal que un hilo tiene para morir es volviendo de su funcin run(). Un hilo est bloqueado cuando no puede continuar su ejecucin. Un hilo puede bloquearse debido a los siguientes motivos: Puso el hilo a dormir llamando a sleep(milisegundos), en cuyo caso no ser ejecutado durante el tiempo especicado. Suspendi la ejecucin del hilo con wait(). No volver a ser ejecutable hasta que el hilo no obtenga el mensaje signal() o broadcast(). Estudiaremos esto en una seccin ms adelante. El hilo est esperando a que una operacin de entrada/salida nalice. El hilo est intentando entrar en un bloque de cdigo controlado por un mutex, y el mutex ha sido ya adquirido por otro hilo. El problema que tenemos ahora es el siguiente: algunas veces quiere terminar un hilo que est en el estado de bloqueo. Si no puede esperar a que el hilo llegue a un punto en el cdigo donde pueda comprobar el valor del estado y decidir si terminar por sus propios medios, debe forzar a que el hilo salga de su estado de bloqueo.
10.5.4. Interrupcin
Tal y como podra imaginar, es mucho ms FIXMEmessier salir de forma brusca en mitad de la funcin Runnable::run() que si espera a que esa funcin llegue al test de isCanceled() (o a algn otro lugar donde el programador est preparado para salir de la funcin). Cuando sale de una tarea bloqueada, podra necesitar destruir objetos y liberar recursos. Debido a esto, salir en mitad de un run() de una tarea, ms que otra cosa, consiste en lanzar una excepcin, por lo que en ZThreads, las excepciones se utilizan para este tipo de terminacin. (Esto roza el lmite de un uso inapropiado de las excepciones, porque signica que las utiliza para el control de ujo.)[154] Para volver de esta manera a un buen estado conocido a la hora de terminar una tarea, tenga en cuenta cuidadosamente los caminos de ejecucin de su cdigo y libere todo correctamente dentro de los bloques catch. Veremos esta tcnica en la presente seccin. Para nalizar un hilo bloqueado, la librera ZThread proporciona la funcin Thread::interrupted(). Esta congura el estado de interrupcin para ese hilo. Un hilo con su estado de interrupcin congurado lanzar una Interrupted_Exception si est bloqueado o si espera una operacin bloqueante. El estado de interrupcin ser restaurado cuando se haya lanzado la excepcin o si la tarea llama a Thread::interrupted(). Como puede ver, Thread::interrupted() proporciona otra forma de salir de su bucle 327 i i i i
i i
Captulo 10. Concurrencia run(), sin lanzar una excepcin. A continuacin, un ejemplo que ilustra las bases de interrupt():
//: C11:Interrupting.cpp // Interrupting a blocked thread. //{L} ZThread #include <iostream> #include "zthread/Thread.h" using namespace ZThread; using namespace std; class Blocked : public Runnable { public: void run() { try { Thread::sleep(1000); cout << "Waiting for get() in run():"; cin.get(); } catch(Interrupted_Exception&) { cout << "Caught Interrupted_Exception" << endl; // Exit the task } } }; int main(int argc, char* argv[]) { try { Thread t(new Blocked); if(argc > 1) Thread::sleep(1100); t.interrupt(); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; } } ///:~
Puede ver que, adems de la insercin de cout, run() tiene dos puntos donde puede ocurrir el bloqueo: la llamada a Thread::sleep(1000) y la llamada a cin.get(). Dando cualquier argumento por lnea de comandos al programa, dir a main() que se duerma lo suciente para que la tarea nalice su sleep() y llame a cin.get().[155] Si no le da un argumento, el sleep() de main() se ignora. Ahora, la llamada a interrupt() ocurrir mientras la tarea est dormida, y ver que esto provoca que una Interrupted_Exception se lance. Si le da un argumento por lnea de comandos al programa, descubrir que la tarea no puede ser interrumpida si est bloqueada en la entrada/salida. Esto es, puede interrumpir cualquier operacin bloqueante a excepcin de una entrada/salida.[156] Esto es un poco desconcertante si est creando un hilo que ejecuta entrada/salida porque quiere decir que la entrada/salida tiene posibilidades de bloquear su programa multihilado. El problema es que, de nuevo, C++ no fue diseado con el sistema de hilos en mente; muy al contrario, FIXMEpresupone que el hilado no existe. Por ello, la librera iostream no ses thread-friendly. Si el nuevo estndar de C++ decide aadir soporte a hilos, la librera iostream podra necesitar ser reconsiderada en el proceso. Bloqueo debido a un mutex. 328 i i i i
i i
10.5. Finalizacin de tareas Si intenta llamar a una funcin cuyo mutes ha sido adquirido, la tarea que llama ser suspendida hasta que el mutex est accesible. El siguiente ejemplo comprueba si este tipo de bloqueo es interrumpible:
//: C11:Interrupting2.cpp // Interrupting a thread blocked // with a synchronization guard. //{L} ZThread #include <iostream> #include "zthread/Thread.h" #include "zthread/Mutex.h" #include "zthread/Guard.h" using namespace ZThread; using namespace std; class BlockedMutex { Mutex lock; public: BlockedMutex() { lock.acquire(); } void f() { Guard<Mutex> g(lock); // This will never be available } }; class Blocked2 : public Runnable { BlockedMutex blocked; public: void run() { try { cout << "Waiting for f() in BlockedMutex" << endl; blocked.f(); } catch(Interrupted_Exception& e) { cerr << e.what() << endl; // Exit the task } } }; int main(int argc, char* argv[]) { try { Thread t(new Blocked2); t.interrupt(); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; } } ///:~
La clase BlockedMutex tiene un constructor que adquiere su propio objeto Mutex y nunca lo libera. Por esa razn, si intenta llamara a f(), siempre ser bloqueado porque el Mutex no puede ser adquirido. En Blocked2, la funcin run() se parar en la llamada blocked.f(). Cuando ejecute el programa ver que, a diferencia de la llamada a iostream, interrupt() puede salir de una llamada que est bloqueada por un mutex.[157] Comprobacin de una una interrupcin. 329 i i i i
i i
Captulo 10. Concurrencia Note que cuando llama a interrupt() sobre un hilo, la nica vez que ocurre la interrupcin es cuando la tarea entra, o ya est dentro, de una operacin bloqueante (a excepcin, como ya ha visto, del caso de la entrada/salida, donde simplemente
//: C11:Interrupting3.cpp {RunByHand} // General idiom for interrupting a task. //{L} ZThread #include <iostream> #include "zthread/Thread.h" using namespace ZThread; using namespace std; const double PI = 3.14159265358979323846; const double E = 2.7182818284590452354; class NeedsCleanup { int id; public: NeedsCleanup(int ident) : id(ident) { cout << "NeedsCleanup " << id << endl; } ~NeedsCleanup() { cout << "~NeedsCleanup " << id << endl; } }; class Blocked3 : public Runnable { volatile double d; public: Blocked3() : d(0.0) {} void run() { try { while(!Thread::interrupted()) { point1: NeedsCleanup n1(1); cout << "Sleeping" << endl; Thread::sleep(1000); point2: NeedsCleanup n2(2); cout << "Calculating" << endl; // A time-consuming, non-blocking operation: for(int i = 1; i < 100000; i++) d = d + (PI + E) / (double)i; } cout << "Exiting via while() test" << endl; } catch(Interrupted_Exception&) { cout << "Exiting via Interrupted_Exception" << endl; } } }; int main(int argc, char* argv[]) { if(argc != 2) { cerr << "usage: " << argv[0] << " delay-in-milliseconds" << endl; exit(1); } int delay = atoi(argv[1]);
330 i i i i
i i
331 i i i i
i i
332 i i i i
i i
333 i i i i
i i
334 i i i i
i i
//: C11:TestTQueue.cpp {RunByHand} //{L} ZThread #include <string> #include <iostream> #include "TQueue.h" #include "zthread/Thread.h" #include "LiftOff.h" using namespace ZThread; using namespace std; class LiftOffRunner : public Runnable { TQueue<LiftOff*> rockets;
335 i i i i
i i
//: C11:ToastOMaticMarkII.cpp {RunByHand} // Solving the problems using TQueues. //{L} ZThread #include <iostream> #include <string> #include <cstdlib> #include <ctime> #include "zthread/Thread.h" #include "zthread/Mutex.h" #include "zthread/Guard.h" #include "zthread/Condition.h" #include "zthread/ThreadedExecutor.h" #include "TQueue.h" using namespace ZThread; using namespace std; class Toast { enum Status { DRY, BUTTERED, JAMMED }; Status status; int id; public: Toast(int idn) : status(DRY), id(idn) {} #ifdef __DMC__ // Incorrectly requires default Toast() { assert(0); } // Should never be called #endif void butter() { status = BUTTERED; } void jam() { status = JAMMED; } string getStatus() const {
336 i i i i
i i
337 i i i i
i i
338 i i i i
i i
10.6.4. Broadcast
//: C11:CarBuilder.cpp {RunByHand} // How broadcast() works. //{L} ZThread #include <iostream> #include <string> #include "zthread/Thread.h" #include "zthread/Mutex.h" #include "zthread/Guard.h" #include "zthread/Condition.h" #include "zthread/ThreadedExecutor.h" #include "TQueue.h" using namespace ZThread; using namespace std; class Car { int id; bool engine, driveTrain, wheels; public: Car(int idn) : id(idn), engine(false), driveTrain(false), wheels(false) {} // Empty Car object: Car() : id(-1), engine(false), driveTrain(false), wheels(false) {} // Unsynchronized -- assumes atomic bool operations: int getId() { return id; } void addEngine() { engine = true; } bool engineInstalled() { return engine; } void addDriveTrain() { driveTrain = true; } bool driveTrainInstalled() { return driveTrain; } void addWheels() { wheels = true; } bool wheelsInstalled() { return wheels; } friend ostream& operator<<(ostream& os, const Car& c) { return os << "Car " << c.id << " [" << " engine: " << c.engine << " driveTrain: " << c.driveTrain << " wheels: " << c.wheels << " ]"; } }; typedef CountedPtr< TQueue<Car> > CarQueue; class ChassisBuilder : public Runnable { CarQueue carQueue; int counter; public: ChassisBuilder(CarQueue& cq) : carQueue(cq),counter(0) {} void run() {
339 i i i i
i i
340 i i i i
i i
341 i i i i
i i
342 i i i i
343 i i i i
i i
//: C11:DeadlockingDiningPhilosophers.cpp {RunByHand} // Dining Philosophers with Deadlock. //{L} ZThread #include <ctime> #include "DiningPhilosophers.h" #include "zthread/ThreadedExecutor.h"
344 i i i i
//: C11:FixedDiningPhilosophers.cpp {RunByHand} // Dining Philosophers without Deadlock. //{L} ZThread #include <ctime> #include "DiningPhilosophers.h" #include "zthread/ThreadedExecutor.h" using namespace ZThread; using namespace std; int main(int argc, char* argv[]) { srand(time(0)); // Seed the random number generator int ponder = argc > 1 ? atoi(argv[1]) : 5; cout << "Press <ENTER> to quit" << endl; enum { SZ = 5 }; try { CountedPtr<Display> d(new Display); ThreadedExecutor executor; Chopstick c[SZ]; for(int i = 0; i < SZ; i++) { if(i < (SZ-1)) executor.execute( new Philosopher(c[i], c[i + 1], d, i, ponder)); else executor.execute( new Philosopher(c[0], c[i], d, i, ponder)); } cin.get(); executor.interrupt(); executor.wait(); } catch(Synchronization_Exception& e) { cerr << e.what() << endl; }
345 i i i i
i i
346 i i i i