advertisement

estructura de datos(code12312)

25 %
75 %
advertisement
Information about estructura de datos(code12312)
Books

Published on March 9, 2014

Author: DebateInformaticaMaterias

Source: slideshare.net

advertisement

PROGRAMACI~N N c E Metodología, algoritmos y estructura de datos . as ,>' . L Ignacio Zahonero Martinez Departamento de Lenguajes y Sistemas Informáticos e Ingeniería del Software Facultad de Informática/Escuela Universitaria de Informática Universidad Pontificia de Salamanca. Cumpus Madrid MADRID BUEN,OS AIRES CARACAS -,GUATEMALA. LISBOA MÉXICO NUEVA YORK PANAMA SAN JUAN SANTAFE DE BOGOTA SANTIAGO SA0 PA,ULO AUCKLAND HAMBURG0 LONDRES MILAN MONTREAL NUEVA DELHI PARIS SAN FRANCISCO SIDNEY SINGAPUR ST. LOUIS TOKIO *TORONTO '. .

CONTENIDO Prólogo , . .... .... ... ... ..... ... ... ..... .. .. .. ... ..... .. ....... .. .. ....... ..... ...... xv PARTE I. METODOLOGíA DE LA PROGRAMACIÓN ................ Capítulo 1. Introducción a la ciencia de la computación y a la programación . . . . . .. 1.1. ¿Qué es una computadora? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2. Organización física de una computadora (hardware) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.1. Dispositivos de EntradafSalida (E/S) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.2. La memoria central (interna) . ........................................... . .. ... .. . 1.2.3. La Unidad Central de Proceso (UCP) . . . . . 1.2.4. El microprocesador . . . . . . . . . . . . . . . . . . . 1.2.5. Memoria auxiliar (externa) . . . . . . . . . . . . . 1.2.6. Proceso de ejecución de un programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.7. Comunicaciones: módems, redes, telefonía RDSI y ADSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.8. La computadora personal multimedia ideal para 1 1.3. Concepto de algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . 1.3.1. Características de los algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4. El software (los programas) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5. Los lenguajes de programación 1.5.4. Lenguajes de alto nivel ................................................. .............................. ... ..... . 2 4 4 5 6 9 10 10 12 12 13 15 16 17 19 20 20 21 22 22 23 23 23 25 25 1.6. El lenguaje C: historia y características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.1. Ventajas de C .................................... 1.6.2. Características ...................... 1.6.3. Versiones actu ..................................................................... 26 27 ...................... Capítulo 2. Fundamentos de programación . . . . . .. 2.1. Fases en la resolución de problemas . 2.1.1. Análisis del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.2. Diseño del algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.3. Herramientas de la programación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ................................... 2.1.4. Codificación de un programa . . . . . 28 30 31 32 33 36 26

vi Contenido 2.1.7. Documentación y 2.2. Programación modular . . . . . 2.3. Programación estructura 2.3.1. Recursos abstractos . . . . . . . . . . . ................... .......... tructurada: estru . ...... .. .........._...... ........... .................. ............_... ......_.......... ................. 2.6.8. Iteración y e 2.7. Métodos formales de verificación de programas ..._............. 2.7.1. Aserciones . . . . . . . . . ................................... ................ ........... ......._..... 2.8. Factores en la calidad del software . . . . ............. ........ 37 38 38 49 40 40 40 41 42 42 43 52 53 54 55 55 56 56 57 57 57 58 58 59 60 60 62 63 64 65 65 66 PARTE II. FUNDAMENTOS DE PROGRAMACI~NEN c Capítulo 3. El lenguaje C: elementos bá 3.1. Estructura general de un programa en 3.1.1. Directivas del prepro 3.1.2. Declaraciones global 3.1.3. Función main ( ) . . . 3.1.4. Funciones definidas PO 3.1.5. Comentarios . . . . . . . . . . . . . . . 3.2, Creación de un programa . . . . . . . . . . . . . . . . 3.3. El proceso de ejecución de 3.4. Depuración de un program ........._...... .......,._... ................ ................ ..._............... 82 3.4.2. Errores lógicos . . . 3.4.5. Errores en tiempo de .................................... .................. .......... .................. ............. ...... .... 90 90 90

Contenido 3.7. 3.8. 3.9. 3.10. 3.11. 3.12. 3.13. 3.14. 3.6.5. Signos de puntuación y separadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.6. Archivos de cabecera ................................. ....... Tipos de datos en C . . ..... ............... 3.7.1. E n t e r o s ( i n t ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.7.2. Tipos de coma flotante ( f 1oat 3.7.3. Caracteres (char) . . . . . . . . . . . . . . . . El tipo de dato LÓGICO . . . . . . . . . . 3.8.1. Escritura de valores lógicos ....... Constantes ............... ............. es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.2. Constantes definidas (simbólicas) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.3. Constantes enumeradas . . ......... ........ 3.9.4. Constantes declaradas con latile... . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ., 3.10.1. Declaracion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.10.2. Inicialización de variables .. .... ..... .... 3.10.3. Declaración o definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Duracióndeunavariable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.11.1. Variables locales . ...... ..... .... 3.11.2. Variables globales ................................ 3.11.3. Variables dinámicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entradas y salidas ........ 3.12.1. Salida . . . ........ 3.12.2. Entrada . . ........................................ 3.12.3. Salida de cadenas de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.12.4. Entrada de cadenas de caracteres . . . .... ..... ....... Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Capítulo 4. Operadores y expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1. Operadores y expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2. Operador de asignación . . .... ....... 4.3. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.1. Asociatividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.2. Uso de paréntesis ........................................................ 4.4. Operadores de increment n y decrementación 4.5. Operadores relacionales . . . . . . . . . . . . . . . . . . . . 4.6. Operadores lógicos .......................................................... 4.6.1. Evaluación en cortocircuito . . . . . . ..... 4.6.2. Asignaciones booleatias (lógicas) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7. Operadores de manipulación de bits ....................... 4.7.1. Operadores de asignación adic ... ..... 4.7.2. Operadores de desplazamiento de bits (», «) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7.3. Operadores de direcciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8. Operador condicional ....... 4.9. Operador coma . . . . . ......... 4.10. Operadores especiales 4.10.1. El operador ( ) 4.10.2. El operador [ ] 4.11. El operador SIZEOF . 4.12. Conversiones de tipos 4.12.1. Conversión im ......... ........ 4.12.2. Reglas . . . . . . ......... ........ 4.12.3. Conversión explícita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13. Prioridad y asociatividad . ... 4.14. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vi¡ 92 92 92 93 97 98 101 103 105 105 106 106 106 107 111 112 112 113 113 114 1 16 116 117 119 120 125 127 128 129 130 131 131 132 136 136 137

vi¡¡ Contenido 4.15. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.16. Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Capítulo 5. Estructuras de selección: sentencias if y switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1. Estructuras de control .................. 5.2. Lasentencia if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3. Sentencia i f de dos alternativas: i f - e1se . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4. Sentencias i f - el se anidadas ....................................... 5.4.1. Sangría en las sentencias i 5.4.2. Comparación de sentencias 5.5. Sentencia de control switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5.1. Caso particular de case .................................. 5.5.2. Uso de sentencias swit c ........................ 5.6. Expresiones condicionales: el operador ? : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7. Evaluación en cortocircuito de expresiones lógicas ................................... 5.8. Puesta a punto de programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.9. Errores frecuentes de programación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.10. Resumen . . . . . . ........ 5.11. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.12. Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 139 142 144 150 154 159 161 164 167 Capítulo 6. Estructuras de control: bucles 6.1. La sentencia whi 1e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.1. Operadores de inc 6.1.2. Terminaciones anormales de un ciclo ........ 6.1.3. Diseño eficiente d 6.1.4. Bucles while con cero iteraciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.5. Bucles controlados por centinelas ....... 6.1.6. Bucles controlados por indicadores (banderas) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.7. La sentencia break en 6.1.8. Bucles while (true) ................................................. 6.2. Repetición: el bucle €or . . . . . 6.2.1. Diferentes usos de bucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3. Precauciones en el uso de for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.1. Bucles infinitos . . . . . . . . . . . . . 6.3.2. Los bucles for vacíos . . . . . . . 6.3.3. Sentencias nulas en bucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.4. Sentencias break y continue . . . . . . . . . . . 6.4. Repetición: el bucle do . . .whi le . . . . . . . . . . . . . . ............................. 6.4.1. Diferencias entre while y do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5. Comparación de bucles while,for y do-whi le 6.6. Diseño de bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.1. Bucles para diseño de sumas y productos . . . 6.6.2. Fin de un bucle ............................................. 6.6.3. Otras técnicas d ..... .... 6.6.4. Bucles f o r vacíos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7. Bucles anidados ...................................... 6.8. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.9. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.10. Problemas ............................................... 6.11. Proyectos d 203 206 Capítulo7. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1. Conceptodefunción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2. Estructuradeunafunción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1. Nombre de una función . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 210 211 213 174 174 175 178 184 185 188 188 190 191 194 196 196 197

Contenido .......................... 7.2.2. Tipo de dato de retorno . . . . . . . . . . . . . . . . . . . . ............................... 7.2.3. Resultados de una función . . . . . . . . . . . . . .. ... ... 7.2.4. Llamada a una función . . . . .................... 7.3. Prototipos de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .~.............~.... 7.3.1. Prototipos con un número no 7.4. Parámetros de una función . . . . . . .......................... I 7.4.3. Diferencias entre paso de variables por valor y por referencia . . . . . . . . . . 7.4.4. Parámetros cons t de una función . . . . . . . . . . . . . . . .......................... ................................ ...... .. 7.6. Ámbito (alcance) . . . . . . . . .................... 7.6.1. Ambito del programa . . . . . . . . . . . . . . . . . . . . . . . . 7.6.2. Ambito del archivo fuente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........ 7.6.3. Ambito de una función . . . . . . . .......................... .................... 7.6.4. Ambito de bloque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.6.5. Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7. Clases de almacenamiento . . . . . . . ........................ ...................... 7.7.1. Variables automáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7.2. Variables externas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........................... 7.7.3. Variables registro . . . . . . . . . . . . . . . . . . . . 7.7.4. Variables estáticas . . ........................... _............... 7.8. Concepto y uso de funcione a ............... ...................... 7.9. Funciones de carácter . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...................... ........................ ...... . 7.9.1. Comprobación alfabética y de dígitos ...................... 7.9.2. Funciones de prueba de caracteres espe ...................... 7.9.3. Funciones de conversión de caracteres . . . . . . . . . . ....... 7.10. Funciones numéricas . . . . . . ........................ ...................... 7.10.1. Funciones matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . ................. 7.10.2. Funciones trigonométricas . . . . . . . . . . . . . . . . . . 7.10.3. Funciones logm’tmicas y exponenciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ................ 7.10.4. Funciones aleatorias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.13. Visibilidad de una función . . 7.13.1. Variables locales fren ............................ 7.13.2. Variables estáticas y automáticas . . . . . . . . ............................. .......... 7.14. Compilación separada . . . . . 7.17. Resumen . . . . . . . . . . . . . . . 7.19. Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........................ ............................. Capítulo 8. Arrays (listas y tablas) . . . . ....................................... ............ .................... .......................... ............... Subíndices de un array s arrays . . . . . . . . . . . Almacenamiento en me .................... ....................... El tamaño de los arrays . . . . . . . . . . . . Verificación del rango ................. 8.2. Iniciaiización de un array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... .. .. ....................... 8.3. Arrays de caracteres y cadenas de 8.4. Arrays multidimensionales . . . . . 8.4.1. Inicialización de arrays mu 8.1.2. 8.1.3. 8.1.4. 8.1.5. 229 230 230 230 23 1 23 1 23 1 23 1 232 232 234 234 235 236 236 237 237 238 238 239 240 243 244 245 247 249 250 25 I 254 258 260 260 26 1 262 263 264 264 266 269 270

X Contenido 8.5. 8.6. 8.7. 8.8. 8.9. 8.10. Acceso a los elementos de los arrays bidimensionales ........................ Lectura y escritura de arrays bidimensionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Acceso a elementos mediante bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arrays de más de dos dimensiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .......... Una aplicación práctica . . . . . . . . . . . . . . . . . . . . . . . . . . . . ............... Utilización de arrays como parámetros . . . . . . . . . . . .............................. 8.5.1. Precauciones . . . . . . . .................................. 8.5.2. Paso de cadenas como parámetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ordenación de listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ............. 8.6.1. Algoritmo de la burbuja . . . . . . . . . . . . . . . . . . . . . . . . . . . ................... Búsqueda en listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........................ 8.7.1. Búsqueda secuencia1 . . . . . . . . . . . . . . . . ............................. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . ............................. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . ........................ ............................. Problemas . . . . . . . . . . . . . . ............. 8.4.2. 8.4.3. 8.4.4. 8.4.5. 8.4.6. Capítulo 9. Estructuras y uniones ......................... ........................ 9.1. Estructuras ............................. ....................... de una estructura . . . . . . . . ............................ 9.1.2. Definición de variables de estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.3. Uso de estructuras en asignaciones . . . . . . . . . . . . . . . . . . . . . . . . .............. 9.1.4. Inicialización de una declaración de estructuras . . . . . . . . . ....................... 9.1.5. El tamaño de una estructura . . . . . . . . . . . . ............................ 9.2. Acceso a estructuras . . . . . . . . . . . . . . . . . . . . . . . ........ .............. .................... 9.3.1. Ejemplo de estructuras anidadas . . . . . . 9.4. Arrays de estructuras . . . . . . . . . . . . ........................... 9.6. Uniones . . . . . . . ............................. 9.7. Enumeraciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.8. Campos de bit . . . . . . . 9.9. Resumen . ............................ ......................... ......... ............. ................... ........ .............. .............. ............ Capítulo 10. Punteros (apuntadores) ............................ ...................... 10.1. Direcciones en memoria . . . . . . . . . . . . . . . . . . . . . . . . ........................... 10.2. Concepto de puntero (apuntador) . . . . . . . . . . . . . . . . ................... 10.2.1. Declaración de punteros . . . . . . . . . . . . ........................ 10.2.2. Inicialización (iniciación ............. 10.2.3. Indirección de punteros 10.2.4. Punteros y verificación d 10.3. Punteros n u l l y v o i d . . . . . . 10.4. Punteros a punteros . . . . . ........ 10.5. Punteros y arrays . . . . . . . . ........ 10.5.1. Nombres de arrays nteros . . . . . . . . . . . . . . . ....................... 10.5.2. Ventajas de los punteros . . . . . . . . . . . . . . . . . . 10.6. Arrays de punteros . . . . . . . . . . . . . . . . . . . . . . . . 10.6.1. Inicialización de u ........ 10.7. Punteros de cadenas . . . . . . . . . . . . . ....................... ............ 10.7.1. Punteros versus arrays ....................... 271 272 274 274 276 282 282 284 28.5 291 294 296 297 297 298 299 300 300 300 302 302 303 304 307 308 309 3 10 31 1 314 314 315 319 320 32 1 322 324 327 331 332 332 33.5 33.5

Contenido Xi 10.8. Aritmética de punteros . . .......................................... 10.8.1. Una aplicación de ón de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........ 10.9. Punteros constantes frente a punteros a constantes . . . . . . . . . . 10.9.1. Punteros constantes .............................................. 10.9.2. Punteros a constantes . . . . . ................................. .......... 336 338 339 339 339 340 ....... 343 10.11.1. Inicialización de u ................................... ................. 10.13. Resumen . . . . . . . . 10.14. Ejercicios . . . . . . . . . . . . . . . . . . . . . . 348 349 ............................... ......... 352 353 Capítulo 11. Asignación dinámica de memoria . . ................................... 11.1. Gestión dinámica de la memoria . . . . . . . . . . . . . . . . . . . . . . . . . . ....... 11.1.1. Almacén libre (free store) ................................ 11.2. Función malloc ( ) . . . . . . . . . . . . . . . . . ................................ 11.2.1. Asignación de memoria de un tamaño desconocido ................ 11.2.2. Uso de m a l loc ( ) para arrays multidimensionales . . . . . . . . . . . . . . . . 11.3. Liberación de memoria, función free ( ) ........................... 11.4. Funciones de asignación de memoria call í ) y realloc í ) . . . . . . . . . . . . . . . . . . . . . . . 11.4.1. Función calloc ( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...... 11.4.2. Función realloc ( ) ............................................ 11.5. Asignación de memoria para array .......................... 11.5.1. Asignación de memoria interactivamente . . . . . . . . . . . . . . . . . . . . . 11.5.2. Asignación de memoria para un array de estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.6. Arrays dinámicos . . . . . . . . . . . . . . . . . . . . . . . . 11.7. Reglas de funcionamiento de la asignaci 11.8. Resumen . . . . . . . . . . ................................................ 11.9. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . ................................. 11.10. Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ................ 354 356 357 357 361 Capítulo 12. Cadenas . . . . . . . . . . . . . . . . . . ....................................... 12.1. Conceptodecadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ................. 12.1.1. Declaración de variables de cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1.2. Inicialización de variables de cadena 378 380 12.2.2. Función putchar ( ) .................................... 12.2.3. Función puts ( ) . . . . . . . . . . . . . . . . . . . . . 12.5. Asignación de cadenas 12.5.1. La función s t ............................... ......... ............................................... .......... .............................. adenas . . . . . . . . . . . . . . . . . . . . . . . . . . ....... 12.6.2. Las funciones strcat ( ) y strncat ( ) ........................... 12.7. Comparación de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 364 365 368 369 371 376 376 377 385 389 389 391 391 392 393

xi¡ Contenido 12.7.3. La función strncmp ( ) . . . . . . . . . . . . 12.7.4. La función strnicmp ( ) . . . . . . . . . . . 12.8. Inversión de cadenas . . . . . . . . . . . 12.9.2. Función strlwr () .................... ......................... ........................ .. 12.10. Conversión de cadenas a números . . . . . . . . . . . . . . . . . . . . . . ................. 12.10.1. Función atoi ( ) . . . . . . . . . . . . . . . . ............................ 12.10.2. Función atof ( ) . . ............................ 12.10.3. Función ato1 ( 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .............. 12.10.4. Entrada de números y cadenas . . . . . . . . . . . . . . . . ........................... 12.11. Búsqueda de caracteres y cadenas . . . . . . 12.11.2. 12.11.3. 12.11.4. 12.11.5. 12.11.6. 12.11.7. Función Función Función Función Función Función strrchr ( ) strspn ( ) strcspn ( ) strpbrk ( ) strstr ( 1 strtok ( ) 396 .................... ...... .................... 399 399 400 402 .................................... . . . . . . . 403 ................... .................... 403 ........ ........................................ 12.12. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 12.13. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.14. Problemas . . . . . . . . . . . . . . . . . . . . . . ................................... PARTE Ill. ESTRUCTURA DE DATOS Capítulo 13. Entradas y salidas por archivos . . . . . . . . . . . . . . . . . . . . ...................... ................................. 13.1. Flujos . . . . . . . . . . . . . . . . . . . . . . . . . . 13.2. Puntero F I L E ................................... ................. 13.3. Apertura de un .................................. ................. 13.3.1. Modos de apertura de un archivo . . . .............................. ................................... 13.3.2. NULL y EOF . . . . . . . . . . . . .. 13.3.3. Cierre de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .............. 13.4. Creación de un archivo secuencia1 . . . . . . . . . . . . . ........................ 410 412 412 413 414 415 415 416 . . . . . . . . . . . . . 417 ....................... 13.5.2. Función de lectura f read () ...................... 421 . . . . . . . . . 423 . . . . . . . . . . . . . . . . . . . 424 .......................... 426 13.6. Funciones para acceso aleatorio . . . . . . . . . . . 13.6.1. Función f seek ( ) . . 13.6.2. Función ftell ( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .................. 13.7. Datos externos al programa co ................................... 13.8. Resumen . . . . . . . . . . . . . . . . ........ ................... 13.10. Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . ............................. 434 435 436 Capítulo 14. Listas enlazadas ............................ ........... 14.1. Fundamentos teóricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..................... 14.2. Clasificación de las listas enlazadas . . . . . . ............................... 14.3. Operaciones en listas enlazadas . . . ........... 14.3.1. Declaración de un nodo . . . . . . . . . . . . . . . . . . . . . . . . . . . . .................... 438 440 441 442 442 431

Contenido 14.4. 14.5. 14.6. 14.7. 14.8. Puntero de cabecera y cola .............................. .......... El puntero nulo . . . . . . . . . ......................... El operador - > de selecció ......................... Construcción de una lista . . . . . . . . . . . . . . . . . . . ........................... ........................ Insertar un elemento en una lista . . . . . Búsqueda de un elemento . ............................ ........ Supresión de un nodo en una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lista doblemente enlazada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.1. Declaración de una lista doblemente enlazada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.2. Insertar un elemento en una lista doblemente enlazada ....................... ......... 14.4.3. Supresión de un elemento en una lista doblemente enlazada . . . . . . . . . . . . Listas circulares . . . . . . .................................. .................. 14.5.1. Insertar un elem en una lista circular . . . . . . . . . ....................... 14.5.2. Supresión de un elemento en una lista circular . . ........................... ....................... Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ejercicios . . . . . . . . . . . . . . . . . . . . . ............................... ....... Problemas . . . . . . . . . . . . . .................................................. 14.3.2. 14.3.3. 14.3.4. 14.3.5. 14.3.6. 14.3.7. 14.3.8. ....... Capítulo 15. Pilas y colas . . . . . . . . . . . . . . . . . ................................. ......................... 15.1. Concepto de pila . . . . . . . . . . . ............... 15.1.1. Especificaciones de una ........................ ........................ 15.2. El tipo pila implementado con arrays . . . . . 15.2.1. Especificación del tipo p i 1a . . . . . ........................ 15.2.2. Implementación de las operaciones sobre pilas .......................... 15.2.3. Operaciones de verificación del estado de la pila . . . . . . . . . . . . . . . . . . . . . 15.3. Colas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4. El tipo cola implementada con arrays . . . . . . . . . . . . . . . . . . ......................... ....................... 15.4.1. Definición de la especificación de una cola 15.4.2. Especificación del tipo c o l a . . . . ................................ 15.4.3. Implementación del tipo c o l a . . . . . . . . . . . . . . . . . .... ................. 15.4.4. Operaciones de la cola ........................ ......................... ......................... 15.5. Realización de una cola con una lista enlazada . . . . . . . . . . 15.5.1. Declaración del tipo c o l a con listas . . . . .................................... eraciones del tipo c o 1 con listas . . . . . . . . . . . . . . a 15.5.2. Codificación de 1 ........ 15.6. Resumen . . . . . . . . . . . . .......................................... 15.7. Ejercicios . . . . . . . . . . . . ....................................................... 15.8. Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........................... Capítulo 16. Árboles ..................... 16.1. Árboles generales . . . . . . . . xiii 443 444 445 445 447 453 454 456 459 462 462 463 467 468 468 470 472 473 473 475 477 478 48 1 483 483 483 484 486 487 488 489 492 493 494 ....................... .............................. 16.3.1. Equilibrio . . . . . . . . . . . . . 16.3.2. Árboles binarios completos 504 ...................... 16.4. Estructura de un árbol binario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.4.1. Diferentes ti . . . . . . . . . . . . . . . . . . 511 ........................... e expresión . . . . . . . . 16.7.2. Recomdo enorden . . . . . . 16.7.3. Recomdo postorden . . . . . ..................... ...................... .......................... ...... ........ ................... 521 522 525

xiv Contenido ...................... ............ 528 528 ............................ ............................ .................. ................ 531 535 535 536 16.9.1. Búsqueda . . . . .............................. 16.9.2. Insertar un nodo . . . . 16.9.5. Recorridos de un árbol . . . . . . . . . . . . . . . . . . .................................. 16.13. Problemas . . . . . ................................ ................. ....... ............................ ....................... Apéndice C. Palabras reservadas de C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Apéndice D. Guía de sintaxis ANSIASO estándar C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Apéndice E. Biblioteca de funciones ANSI C . . . . . . . .................................. Apéndice F. Recursos (Libros/Revistas/URL de Interne ............................ ÍNDICE . . . . . . . . . . . . . . . . . . . . . . . . . .............................. ........ 540 542 545 575 713 727

PRÓLOGO INTRODUCCIÓN i Por qué un libro de C al principio del siglo X X I ? A pesar de haber cumplido ya sus bodas de plata (25 años de vida), C viaja con toda salud hacia los 30 años de edad que cumplirá el próximo año. Sigue siendo una de las mejores opciones para la programación de los sistemas actuales y el medio más eficiente de aprendizaje para emigrar a los lenguajes reina, por excelencia, en el mundo orientado a objetos y componentes y el mundo Web (C++, Java,. ..) que dominan el campo informático y de la computación. i Cuáles son las características que hacen tan popular a este lenguaje de programación e idóneo como primer lenguaje de programación en las carreras profesionales de programador (de aplicaciones y de sistemas) y del ingeniero de software? Podemos citar algunas muy sobresalientes: Es muy portable (transportable entre un gran número de plataformas hardware y plataformas sofware, sistemas operativos). Existen numerosos compiladores para todo tipo de plataformas sobre los que corrren los mismos programas fuentes o con ligeras modificaciones. Es versátil y de bajo nivel, por lo que es idóneo para tareas relativas a la programación del sistema. A pesar de ser un excelente lenguaje para programación de sistemas, es también un eficiente y potente lenguaje para aplicaciones de propósito general. Es un lenguaje pequeño, por lo que es relativamente fácil construir compiladores de C y además es también fácil de aprender. Todos los compiladores suelen incluir potentes y excelentes bibliotecas de funciones compatibles con el estándar ANSI. Los diferentes fabricantes suelen añadir a sus compiladores funcionalidades diversas que aumentan la eficiencia y potencia de los mismos y constituye una notable ventaja respecto a otros lenguajes. El lenguaje presenta una interjGaz excelente para los sistemas operativos Unix y Windows, junto con el ya acreditado Linux. Es un lenguaje muy utilizado para la construcción de: sistemas operativos, ensambladores, programas de comunicaciones, intérpretes de lenguajes, compiladores de lenguajes, editores de textos, bases de datos, utilidades, controladores de red, etc. Por todas estas razones y nuestra experiencia docente, decidimos escribir esta obra que, por otra parte, pudiera completar nuestras otras obras de programación escritas para C++, Java, Turbo Pascal y Visual Basic. Basados en estas premisas este libro se ha escrito pensando en que pudiera servir de xv

xvi prólogo referencia y guía de estudio para un primer curso de introducción a la programación, con una segunda parte que, a su vez, sirviera como continuación, y de introducción a las estructuras de datos todo ello utilizando C, y en particular la versión estándar ANSI C, como lenguaje de programación. El objetivo final que busca es, no sólo describir la sintaxis de C, sino y, sobre todo, mostrar las características más sobresalientes del lenguaje, a la vez que se enseñan técnicas de programación estructurada. Así pues, los objetivos fundamentales del libro son: Énfasis fuerte en el análisis, construcción y diseño de programas. Un medio de resolución de problemas mediante técnicas de programación. Una introducción a la informática y a las ciencias de la computación usando una herramienta de programación denominada C (ANSI C). Enseñanza de las reglas de sintaxis más frecuentes y eficientes del lenguaje C. En resumen, éste es un libro diseñado para enseñar a programar utilizando C, no un libro diseñado para enseñar C, aunque también pretende conseguirlo. No obstante, confiamos que los estudiantes que utilicen este libro se conviertan de un modo razonable en acérrimos seguidores y adeptos de C, al igual que nos ocurre a casi todos los programadores que comenzamos a trabajar con este lenguaje. Así se tratará de enseñar las técnicas clásicas y avanzadas de programación estructurada. LA EVOLUCI~N E c: c++ D C es un lenguaje de programación de propósito general que ha estado y sigue estando asociado con el sistema operativo UNIX. El advenimiento de nuevos sistemas operativos como Windows (95,98, NT, 2000 o el recientemente anunciado XP sobre la plataforma. NET) o el ya muy popular Linux, la versión abierta, gratuita de Unix que junto con el entorno Gnome está comenzando a revolucionar el mundo de la programación. Esta revolución, paradójicamente, proporciona fuerza al lenguaje de programación de sistemas C. Todavía y durante muchos años C seguirá siendo uno de los lenguajes lideres en la enseñanza de la programación tanto a nivel profesional como universitario. Como reconocen sus autores Kernighan y Ritchie, en El Lenguaje de Programación C, 2.” edición, C, aunque es un lenguaje idóneo para escribir compiladores y sistemas operativos, sigue siendo, sobre todo, un lenguaje para escribir aplicaciones en numerosas disciplinas. Ésta es la razón por la que a algo más de un año para cumplir los 30 años de vida, C sigue siendo el lenguaje más empleado en Facultades y Escuelas de Ciencias e Ingeniería, y en los centros de enseñanza de formación profesional, y en particular los innovadores ciclos de grado superior, así como en centros de enseñanza media y secundaria, para el aprendizaje de legiones de promociones (generaciones) de estudiantes y profesionales. Las ideas fundamentales de C provienen del lenguaje BCPL, desarrollado por Martin Richards. La influencia de BCPL sobre C continuó, indirectamente, a través del lenguaje B, escrito por Ken Thompson en 1979 para escribir el primer sistema UNIX de la computadora DEC de Digital PDP-7. BCPL y B son lenguajes «sin tipos» en contraste con C que posee una variedad de tipos de datos. En 1975 se publica Pascal User Manual and Report la especificación del joven lenguaje Pascal (Wirth, Jensen 75) cuya suerte corre en paralelo con C, aunque al contrario que el compilador de Pascal construido por la casa Borland, que prácticamente no se comercializa, C sigue siendo uno de los reyes de la iniciación a la programación. En I978 se publicó la primera edición de la obra The C Programming Language de Kernighan y Ritchie, conocido por K&R. En 1983 el American National Standards Institute (ANSI) nombró un comité para conseguir una definición estándar de C. La definición resultante se llamó ANSI C, que se presentó a finales de 1988 y se aprobó definitivamente por ANSI en 1989 y en 1990 se aprobó por ISO. La segunda edición The C Programming Language se considera también el manual del estándar ANSI C. Por esta razón la especificación estándar se suele conocer como ANSVISO C. Los compiladores modernos soportan todas las características definidas en ese estándar.

i r prólogo xvii Conviviendo con C se encuentra el lenguaje C++, una evolución lógica suya, y que es tal el estado de simbiosis y sinergia existente entre ambos lenguajes que en muchas ocasiones se habla de C/C++ para definir a los compiladores que siguen estas normas, dado que C++ se considera un superconjunto de C. C++ tiene sus orígenes en C, y, sin lugar a dudas, Kemighan y Ritchie -inventores de C,- son «padres espirituales» de C++. Así lo manifiesta Bjarne Stroustrup -inventor de C++- en el prólogo de su afamada obra The C++ Programming Lunguage. C se ha conservado así como un subconjunto de C++ y es, a su vez, extensión directa de su predecesor BCPL de Richards. Pero C++, tuvo muchas más fuentes de inspiración; además de los autores antes citados, cabe destacar de modo especial, Simula 67 de Dah1 que fue su principal inspirador; el concepto de clase, clase derivada yfunciones virtuales se tomaron de Simula; otra fuente importante de referencia fue Algol 68 del que se adoptó el concepto de sobrecarga de operadores y la libertad de situar una declaración en cualquier lugar en el que pueda aparecer una sentencia. Otras aportaciones importantes de C++ como son las plantillas (templates) y la genericidad (tipos genéricos) se tomaron de Ada, Clu y ML. C++ se comenzó a utilizar como un «C con clases» y fue a principios de los ochenta cuando comenzó la revolución C++, aunque su primer uso comercial, fuera de una organización de investigación, comenzó en julio de 1983. Como Stroustrup cuenta en el prólogo de la 3." edición de su citada obra, C++ nació con la idea de que el autor y sus colegas no tuvieran que programar en ensamblador ni en otros lenguajes al uso (léase Pascal, BASIC, FORTRAN,...). La explosión del lenguaje en la comunidad informática hizo inevitable la estandarización. proceso que comenzó en 1987 [Stroustrup 941. Así nació una primera fuente de estandarización The Annotated C++ Reference Manual [Ellis 891'. En diciembre de 1989 se reunió el comité X3J16 de ANSI, bajo el auspicio de Hewlett-Packard y en junio de 1991 pasó el primer esfuerzo de estandarización internacional de la mano de ISO, y así comenzó a nacer el estándar ANSVISO C++. En 1995 se publicó un borrador estándar para su examen público y en noviembre de 1997 fue finalmente aprobado el estandar C++ internacional, aunque ha sido en 1998 cuando el proceso se ha podido dar por terminado (ANSIASO C++ Draft Standard). El libro definitivo y referencia obligada para conocer y dominar C++ es la 3.a edición de la obra de Stroustrup [Stroustrup 971 y actualizada en la Special Edition [Stroustrup 2000]*. OBJETIVOS DEL LIBRO C++ es un superconjunto de C y su mejor extensión. Éste es un tópico conocido por toda la comunidad de programadores del mundo. Cabe preguntarse como hacen muchos autores, profesores, alumnos y profesionales ¿se debe aprender primero C y luego C++? Stroustrup y una gran mayoría de programadores, contestan así: «No sólo es innecesario aprenderprimero C, sino que además es una mala idea». Nosotros no somos tan radicales y pensamos que se puede llegar a C++ procediendo de ambos caminos, aunque es lógico la consideración citada anteriormente, ya que efectivamente los hábitos de programación estructurada de C pueden retrasar la adquisición de los conceptos clave de C++, pero también es cierto que en muchos casos ayuda considerablemente en el aprendizaje. Este libro supone que el lector no es programador de C, ni de ningún otro lenguaje, aunque también somos conscientes que el lector que haya seguido un primer curso de programación en algoritmos o en algún lenguaje estructurado, llámese Pascal o cualquier otro, éste le ayudará favorablemente al correcto y rápido aprendizaje de la programación en C y obtendrá el máximo rendimiento de esta obra. Sin embargo, si ya conoce C++, naturalmente no tendrá ningún problema, en su aprendizaje, muy al contrario, bastará que lea con detalle las diferencias esenciales de los apéndices C y D de modo que irá ' Traducida al español por el autor de este libro junto con el profesor Miguel Katnb, de la Universidad de la Habana [Ellis 941 Esta obra qe encuentra en proceso de traducción al español por un equipo de profesores de vanas universidades españolas coordinadas por el autor de esta obra

xviii Prólogo integrando gradualmente los nuevos conceptos que irá encontrando a medida que avance en la obra con los conceptos clásicos de C++. El libro pretende enseñar a programar utilizando dos conceptos fundamentale s : 1. Algoritmos (conjunto de instrucciones programadas para resolver una tarea específica). 2. Datos (una colección de datos que se proporcionan a los algoritmos que se han de ejecutar para encontrar una solución: los datos se organizarán en estructuras de datos). Los dos primeros aspectos, algoritmos y datos, han permanecido invariables a lo largo de la corta historia de la informáticdcomputación, pero la interrelación entre ellos sí que ha variado y continuará haciéndolo. Esta interrelación se conoce como paradigma de programación. En el paradigma de programación procedimental @rocedural o por procedimientos) un problema se modela directamente mediante un conjunto de algoritmos. Un problema cualquiera, la nómina de una empresa o la gestión de ventas de un almacén, se representan como una serie de procedimientos que manipulan datos. Los datos se almacenan separadamente y se accede a ellos o bien mediante una posición global o mediante parámetros en los procedimientos. Tres lenguajes de programación clásicos, FORTRAN, Pascal y C, han representado el arquetipo de la programación procedimental, también relacionada estrechamente y - veces- conocida como programación estructurada. La programación a con soporte en C++, proporciona el paradigma procedimental con un énfasis en funciones, plantillas de funciones y algoritmos genéricos. En la década de los setenta, el enfoque del diseño de programas se desplazó desde el paradigma procedimental al orientado a objetos apoyado en los tipos abstractos de datos (TAD). En este paradigma un problema modela un conjunto de abstracciones de datos. En C++ estas abstracciones se conocen como clases. Las clases contienen un conjunto de instancias o ejemplares de la misma que se denominan objetos, de modo que un programa actúa como un conjunto de objetos que se relacionan entre sí. La gran diferencia entre ambos paradigmas reside en el hecho de que los algoritmos asociados con cada clase se conocen como interfaz pública de la clase y los datos se almacenan privadamente dentro de cada objeto de modo que el acceso a los datos está oculto al programa general y se gestionan a través de la interfaz. Así pues, en resumen, los objetivos fundamentales de esta obra son: introducción a la programación estructurada y estructuras de datos con el lenguaje estándar C de ANSVISO; otros objetivo complementario es preparar al lector para su emigración a C++, para lo cual se han escrito dos apéndices completos C y D que presentan una amplia referencia de palabras reservadas y una guía de sintaxis de C++ con el objeto de que el lector pueda convertir programas escritos en C a C++ (con la excepción de las propiedades de orientación a objetos que se salen fuera del ámbito de esta obra). EL LIBRO COMO HERRAMIENTA DOCENTE La experiencia de los autores desde hace muchos años con obras muy implantadas en el mundo universitario como Programación en C++, Programación en Turbo Pascal (en su 3." edición), estructura de datos, Fundamentos de programación (en su 2." edición y en preparación la 3." edición) y Programación en BASIC (que alcanzó tres ediciones y numerosísimas reimpresiones en la década de los ochenta), nos ha llevado a mantener la estructura de estas obras, actualizándola a los contenidos que se prevén para los estudiantes del futuro siglo XXI. Por ello en el contenido de la obra hemos tenido en cuenta no sólo las directrices de los planes de estudio españoles de ingeniería informática e ingeniería técnica informática (antiguas licenciaturas y diplomaturas en informática) y licenciaturas en ciencias de la computación, sino también de ingenierías tales como industriales, telecomunicaciones, agrónomos o minas, o las más recientes incorporadas, en España, como ingeniería en geodesia. Asímismo, en el diseño de la obra se han tenido en cuenta las directrices oficiales vigentes en España para la Formación Profesional de Grado Superior; por ello se ha tratado de que el contenido de la obra contemple los programas propuestos para el ciclo de desarrollo de Aplicaciones Informáticas en el módulo de Programación en Lenguaje Estructurado; también se ha tratado en la medida de lo posible de que pueda servir de

Prólogo xix referencia al ciclo de Administración de Sistemas Informúticos en el módulo de Fundamentos de Programación. Nuestro conocimiento del mundo educativo latinoamericano nos ha llevado a pensar también en las carreras de ingeniería de sistemas computacionales y las licenciaturas en informática y en sistemas de información, carreras hermanas de las citadas anteriormente. Por todo lo anterior, el contenido del libro intenta seguir un programa estándar de un primer curso de introducción a la programación y, según situaciones, un segundo curso de programación de nivel medio en asignaturas tales como Metodología de la Programación, Fundamentos de Programación, Introducción a la Programación, ... Asimismo, se ha buscado seguir las directrices emanadas de la ACM-IEEE para los cursos CS 1 y CS8 en los planes recomendados en los Computing Curricula de 1991 y las recomendaciones de los actuales Computing Curricula 2001 en las áreas de conocimiento Programming Fundamentals [PF,10] y Programming Languages [PL, 1 11, así como las vigentes en universidades latinoamericanas que conocemos, y con las que tenemos relaciones profesionales. El contenido del libro abarca los citados programas y comienza con la introducción a los algoritmos y a laprogramación, para llegar a estructuras de datos. Por esta circunstancia la estructura del curso no ha de ser secuencia1en su totalidad sino que el profesor/maestro y el alumno/lector podrán estudiar sus materias en el orden que consideren más oportuno. Ésta es la razón principal por la cual el libro se ha organizado en tres partes y en seis apéndices. Se trata de describir el paradigma más popular en el mundo de la programación: el procedimental y preparar al lector para su inmersión en el ya implantado paradigma orientado a objetos. Los cursos de programación en sus niveles inicial y medio están evolucionando para aprovechar las ventajas de nuevas y futuras tendencias en ingeniería de software y en diseño de lenguajes de programación, específicamente diseño y programación orientada a objetos. Algunas facultades y escuelas de ingenieros, junto con la nueva formación profesional (ciclos formativos de nivel superior) en España y en Latinoamérica, están introduciendo a sus alumnos en la programación orientada a objetos, inmediatamente después del conocimiento de la programación estructurada, e incluso +n ocasiones antes-. Por esta razón, una metodología que se podría seguir sería impartir un curso defindamentos de programación seguido de estructuras de datos y luego seguir con un segundo nivel de programación avanzada que constituyen las tres partes del libro. Pensando en aquellos alumnos que deseen continuar su formación estudiando C++ se han escrito los apéndices C y D, que les permita adaptarse fácilmente a las particularidades básicas de C++ y poder continuar sin esfuerzo la parte primera y avanzar con mayor rapidez a las siguientes partes del libro. CARACTER~STICAS IMPORTANTES DEL LIBRO Programación en C , utiliza los siguientes elementos clave para conseguir obtener el mayor rendimiento del material incluido en sus diferentes capítulos: Contenido. Enumera los apartados descritos en el capítulo. Introducción. Abre el capítulo con una breve revisión de los puntos y objetivos más importantes que se tratarán y todo aquello que se puede esperar del mismo. Conceptos clave. Enumera los términos informáticos y de programación más notables que se tratarán en el capítulo. Descripción del capítulo. Explicación usual de los apartados correspondientes del capítulo. En cada capítulo se incluyen ejemplos y ejercicios resueltos. Los listados de los programas completos o parciales se escriben en letra courier con la finalidad principal de que puedan ser identificados fácilmente por el lector. Resumen del capítulo. Revisa los temas importantes que los estudiantes y lectores deben comprender y recordar. Busca también ayudar a reforzar los conceptos clave que se han aprendido en el capítulo.

XX Prólogo Ejercicios. Al final de cada capítulo se proporciona a los lectores una lista de ejercicios sencillos de modo que le sirvan de oportunidad para que puedan medir el avance experimentado mientras las explicaciones del profesor relativas al capítulo. leen y siguen - e n su casProblemas. Después del apartado Ejercicios, se añaden una serie de actividades y proyectos de programación que se le proponen al lector como tarea complementaria de los ejercicios y de un nivel de dificultad algo mayor. A lo largo de todo el libro se incluyen una serie de recuadros -sombreados o n o - que ofrecen al lector consejos, advertencias y reglas de uso del lenguaje y de técnicas de programación, con la finalidad de que puedan ir asimilando conceptos prácticos de interés que les ayuden en el aprendizaje y construcción de programas eficientes y de fácil lectura. 0 0 Recuadro. Conceptos importantes que el lector debe considerar durante el desarrollo del capítulo. Consejo. Ideas, sugerencias, recomendaciones, ... al lector, con el objetivo de obtener el mayor rendimiento posible del lenguaje y de la programación. Precaución. Advertencia al lector para que tenga cuidado al hacer uso de los conceptos incluidos en el recuadro adjunto. Reglas. Normas o ideas que el lector debe seguir preferentemente en el diseño y construcción de sus programas. ORGANIZACI~N DEL LIBRO El libro se divide en tres partes que unidas constituyen un curso completo de programación en C. Dado que el conocimiento es acumulativo, los primeros capítulos proporcionan el fundamento conceptual para la comprensión y aprendizaje de C y una guía a los estudiantes a través de ejemplos y ejercicios sencillos y los capítulos posteriores presentan de modo progresivo la programación en C en detalle, en el paradigma procedimental. Los apéndices contienen un conjunto de temas importantes que incluyen desde guías de sintaxis de ANSYISO C, hasta o una biblioteca de funciones y clases, junto con una extensa bibliografía de algoritmos, estructura de datos, programación orientada a objetos y una amplia lista de sitios de Internet (URLs) donde el lector podrá complementar, ampliar y profundizar en el mundo de la programación y en la introducción a la ingeniería de software. PARTE I. METODOLOGÍA DE LA PROGRAMACI~N Esta parte es un primer curso de programación para alumnos principiantes en asignaturas de introducción a la programación en lenguajes estructurados. Esta parte sirve tanto para cursos de C como de C++ (en este caso con la ayuda de los apéndices C y D). Esta parte comienza con una introducción a la informática y a las ciencias de la computación como a la programación. Describe los elementos básicos constitutivos de un programa y las herramientas de programación utilizadas tales como algoritmos, diagramas de flujo, etc. Asimismo se incluye un curso del lenguaje C y técnicas de programación que deberá emplear el lector en su aprendizaje de programación. La obra se estructura en tres partes: Metodologia de programación (conceptos básicos para el análisis, diseño y construcción de programas), Fundamentos de programación en C (sintaxis, reglas y criterios de construcción del lenguaje de programación C junto con temas específicos de C como punteros, arrays, cadenas,...), Estructura de datos (en esta parte se analizan los archivos y las estructuras dinámicas de datos tales como listas enlazadas, pilas, colas y árboles ). Completa la obra una serie de apéndices que buscan esencialmente proporcionar información complementaria de utilidad para el lector en su período de aprendizaje en programación en C, así como un pequeño curso de C++ en forma de palabras reservadas y guía de referencia de sintaxis que permita al lector emigrar al lenguaje C++ facilitándole para ello las reglas y normas necesarias para convertir programas escritos en C a programas escritos en C++.

Prólogo xxi Capítulo 1. Introducción a la ciencia de la computación y a la programación. Proporciona una revi- sión de las características más importantes necesarias para seguir bien un curso de programación básico y avanzado en C. Para ello se describe la organización física de una computadora junto con los conceptos de algoritmo y de programa. Asimismo se explican los diferentes tipos de lenguajes de programación y una breve historia del lenguaje C. Capítulo 2. Fundamentos de programación. En este capítulo se describen las fases de resolución de un problema y los diferentes tipos de programación (modular y estructurada). Se explican también las herramientas de programación y representaciones gráficas utilizadas más frecuentemente en el mundo de la programación. PARTE 11. FUNDAMENTOS DE PROGRAMACI~N c EN Capítulo 3. El lenguaje C: Elementos básicos. Enseña la estructura general de un programa en C junto con las operaciones básicas de creación, ejecución y depuración de un programa. Se describen también los elementos clave de un programa (palabras reservadas, comentarios, tipos de datos, constantes y variables,...) junto con los métodos para efectuar entrada y salida de datos a la computadora. Capítulo 4. Operadores y expresiones. Se describen los conceptos y tipos de operadores y expresiones, conversiones y precedencias. Se destacan operadores especiales tales como manipulación de bits, condicional, sizeof, ( ) , [ I , : : , coma,etc. Capítulo 5. Estmcturas de selección: sentencias if y swí tch Introduce al concepto de estructura de control y, en particular, estructuras de selección, tales como if , if -else, case y switch. Expresiones condicionales con el operador ? : , evaluación en cortocircuito de expresiones lógicas, errores frecuentes de programación y puesta a punto de programas. Capítulo 6. Estructuras repetitivas: bucles (for, while y do-while). El capítulo introduce las e. estructuras repetitivas (for, while y do-whi l ) Examina la repetición (iteración) de sentencias en detalle y compara los bucles controlados por centinela, bandera, etc. Explica precauciones y reglas de uso de diseño de bucles. Compara los tres diferentes tipos de bucles, así como el concepto de bucles anidados. Capítulo 7. Funciones. Examina el diseño y construcción de módulos de programas mediante funciones. Se define la estructura de una función, prototipos y parámetros. El concepto de funciones en línea (inline) Uso de bibliotecas de funciones, clases de almacenamiento, ámbitos, visibilidad de una . función. Asimismo se introduce el concepto de recursividad y plantillas de funciones. Capítulo 8. Arrays (listas y tablas). Examina la estructuración de los datos en arrays o grupos de elementos dato del mismo tipo. El capítulo presenta numerosos ejemplos de arays de uno, dos o múltiples índices. Se realiza una introducción a los algoritmos de ordenación y búsqueda de elementos en una lista. Capítulo 9. Estructuras y uniones. Conceptos de estructuras, declaración, definición, iniciación, uso y tamaño. Acceso a estructuras, arrays de estructuras y estructuras anidadas. Uniones y enumeraciones. Capítulo 10. Punteros (apuntadores). Presenta una de las características más potentes y eficientes del lenguaje C, los punteros. Este capítulo proporciona explicación detallada de los punteros, arrays de punteros, punteros de cadena, aritmética de punteros, punteros constantes, punteros como argumentos de funciones, punteros a funciones y a estructuras.

xxii Prólogo Capítulo 11. Asignación dinámica de memoria. En este capítulo se describe la gestión dinámica de la memoria y las funciones asociadas para esas tareas : mal loc ( ) , free ( ) , cal loc ( ) , realloc ( ) . Se dan reglas de funcionamiento de esas funciones y para asignación y liberación de memoria. También se describe el concepto de arrays dinámicos y asignación de memoria para arrays. Capítulo 12. Cadenas. Se examina el concepto de cadena (string) así como las relaciones entre punteros, arrays y cadenas en C. Se introducen conceptos básicos de manipulación de cadenas junto con operaciones básicas tales como longitud, concatenación, comparación, conversión y búsqueda de caracteres y cadenas. Se describen las funciones más notables de la biblioteca string.h. PARTE 111. ESTRUCTURA DE DATOS Esta parte es clave en el aprendizaje de técnicas de programación. Tal es su importancia que los planes de estudio de cualquier carrera de ingeniería informática o de ciencias de la computación incluyen una asignatura troncal denominada Estructura de datos. Capítulo 13. Archivos. El concepto de archivo junto con su definición e implementación es motivo de estudio en este capítulo. Las operaciones usuales se estudian con detenimiento. Capítulo 14. Listas enlazadas. Una lista enlazada es una estructura de datos que mantiene una colección de elementos, pero el número de ellos no se conoce por anticipado o varía en un amplio rango. La lista enlazada se compone de elementos que contienen un valor y un puntero. El capítulo describe los fundamentos teóricos y las operaciones que se pueden realizar en la lista enlazada. También se describen los distintos tipos de listas enlazadas. Capítulo 15. Pilas y colas. Colas de prioridades. Las ideas abstractas de pila y cola se describen en el capítulo. Pilas y colas se pueden implementar de diferentes maneras, bien con vectores (arrays) o con listas enlazadas. Capítulo 16. Árboles. Los árboles son otro tipo de estructura de datos dinámica y no lineal. Las operaciones básicas en los árboles junto con sus operaciones fundamentales se estudian en el Capítulo 2 1. APÉNDICES En todos los libros dedicados a la enseñanza y aprendizaje de técnicas de programación es frecuente incluir apéndices de temas complementarios a los explicados en los capítulos anteriores. Estos apéndices sirven de guía y referencia de elementos importantes del lenguaje y de la programación de computadoras. Apéndice A. Lenguaje ANSI C. G u h de referencia. Descripción detallada de los elementos fundamentales del estándar C. Apéndice B. Códigos de caracteres ASCZZ. Listado del juego de caracteres del código ASCII utilizado en la actualidad en la mayoría de las computadoras. Apéndice C. Palabras reservadas de C++. Listado por orden alfabético de las palabras reservadas en ANSIíiSO C++, al estilo de diccionario. Definición y uso de cada palabra reservada, con ejemplos sencillos de aplicación. Apéndice D. G u h de sintuxis ANSUISO estándar C++. Referencia completa de sintaxis de C++ para que junto con las palabras reservadas facilite la migración de programas C a C++ y permita al lector convertir programas estructurados escritos en C a C++.

prólogo xxi ii Apéndice E. Biblioteca de funciones estándar ANSI C. Diccionario en orden alfabético de las funciones estándar de la biblioteca estándar de ANSIASO C++, con indicación de la sintaxis del prototipo de cada función, una descripción de su misión junto con algunos ejemplos sencillos de la misma. Apéndice E Recursos de C (Libros, Revistas, URLS de Internet). Enumeración de los libros más sobresalientes empleados por los autores en la escritura de esta obra, así como otras obras importantes com- plementarias que ayuden al lector

Add a comment

Related presentations

Related pages

estructura de datos(code12312) - Education

1. PROGRAMACI~N N c E Metodología, algoritmos y estructura de datos . as,>'.L Ignacio Zahonero Martinez Departamento de Lenguajes y Sistemas Informáticos…
Read more