ANTOLOGIA Programacion C

Licenciaturas Ejecutivas L S C A
A N T O L O G A
ALGORITMICA Y PRINCIPIOS DE PROGRAMACIN PROFESOR: JOEL PREZ GONZLEZ
29 / OCT / 2010
Introduccin
El presente documento es de carcter educativo nicamente, respetando y reconociendo la autora del contenido de quienes lo escribieron. El documento trata los temas de algortmica y principios de programacin para que los alumnos lo tomen como referencia en la materia de Algortmica y principios de programacin cuyo objetivo general es El estudiante aplicar correctamente el concepto de algortmica, para el diseo de diversos sistemas, y donde los temas por unidad a tratar son: 1. 2. 3. 4. 5. 6. Introduccin a la algortmica Instrucciones y datos Instrucciones estructuradas Tipos de datos estructurados Modularidad Apuntadores
Estos temas son cubiertos de manera directa o indirecta a travs de los captulos presentados a lo largo del documento ALGORITMICA PARA PROGRAMACION, haciendo nfasis en los conceptos de Algoritmo y diagramas de flujo en el capitulo de ALGORITMOS Y PROGRAMAS a partir de la pgina 33, las instrucciones y datos son presentados en TIPOS DE DATOS pag. 23. las instrucciones estructuradas se plantean en ESTRUCTURAS DE PROGRAMACIN pag. 38, los tipos de datos estructurados, como subrango, enumerado, registros, arreglos, estructuras, etc. Son mostrados en TIPOS DEFINIDOS POR EL USUARIO pag. 27 y ARREGLOS pag. 147, el tema de Modularidad est implcito en todo el documento y en especial en el tema de FUNCIONES pag. 147, al tratar la programacin estructurada y modular, se considera programacin estructurada a la programacin que se hace por mdulos, el tema de apuntadores est incluido en el Apndice B y Apndice C. El apndice A es un concentrado de varios temas. Esperando que sea de gran utilidad para los alumnos ponemos a su disposicin esta Antologa.
CONTENIDO
ALGORITMICA PARA PROGRAMACION
INTRODUCCIN ...................................................................................................................................... OBJETIVOS Y CONTENIDO .................................................................................................................. PARA QUE SIRVE LA PROGRAMACIN............................................................................................ QUE ES LA PROGRAMACIN .............................................................................................................. QUE ES UN LENGUAJE DE PROGRAMACIN ................................................................................. NIVELES DE LOS LENGUAJES.............................................................................................................. TIPOS DE PROGRAMACIN................................................................................................................. EL SECRETO DE PROGRAMAR EST EN LA ESTRUCTURACIN............................................ ELEMENTOS BSICOS DE UN PROGRAMA..................................................................................... ELEMENTOS BSICOS DE UN PROGRAMA EN C ..........................................................................
MAIN() .............................................................................................................................................................. LA DIRECTIVA #INCLUDE:................................................................................................................................. DEFINICIN DE VARIABLES: ............................................................................................................................. VARIABLES GLOBALES:...................................................................................................................................... VARIABLES LOCALES:........................................................................................................................................ PROTOTIPO DE FUNCIN: .................................................................................................................................. ENUNCIADOS DEL PROGRAMA:........................................................................................................................... DEFINICIN DE FUNCIN:.................................................................................................................................. COMENTARIOS:................................................................................................................................................. FLUJO DE SENTENCIAS......................................................................................................................................
3 5 6 7 8 9 10 11 12 13
14 14 15 15 15 16 16 17 17 18
ESTRUCTURAS ESTTICAS DE DATOS............................................................................................... 22 TIPOS DE DATOS ...................................................................................................................................... 23 PREDEFINIDOS POR LOS LENGUAJES ................................................................................ 23
TIPOS DE DATOS ENTEROS....................................................................................................................... TIPOS DE DATOS REALES.......................................................................................................................... TIPOS DE DATOS CHAR............................................................................................................................... TIPOS DE DATOS STRING........................................................................................................................... TIPOS DE DATOS BOOLEAN....................................................................................................................... 23 24 24 25 26
TIPOS DEFINIDOS POR EL USUARIO: ................................................................................... 27

DATOS DE TIPO SUBRANGO:..................................................................................................................... 27 DATOS DE TIPO ENUMERADO.................................................................................................................. 27
ALGORITMOS Y PROGRAMAS................................................................................................................ DISEO DE PROGRAMAS:......................................................................................................... DIAGRAMAS DE FLUJO ............................................................................................................. REGLAS DE PROGRAMACIN:................................................................................................. PROGRAMACIN ESTRUCTURADA........................................................................................ ESTRUCTURAS DE PROGRAMACIN................................................................................................... ESTRUCTURA DE ASIGNACIN ..............................................................................................
33 33 34 36 36 38 38
Expresiones simples.......................................................................................................................... 38 Expresiones complejas...................................................................................................................... 39
ESTRUCTURA DE DECISIN .................................................................................................... 65

Estructura Sencilla:.......................................................................................................................... Operadores de Relacin: .................................................................................................................. Operadores Lgicos: ........................................................................................................................ Estructuras de decisin anidadas:.................................................................................................... Ejercicios Aplicando Estructuras de Decisin................................................................................. Ciclos con control antes.................................................................................................................... Ciclos con control despus: ............................................................................................................. Estructuras cclicas anidadas: ........................................................................................................ Estructura cclica FOR-ENDFOR................................................................................................... 65 65 66 67 68 97 97 98 99
ESTRUCTURAS CCLICAS.......................................................................................................... 97
ESTRUCTURA DE SELECCIN MULTIPLE ........................................................................... 133
FUNCIONES................................................................................................................................................ 136 DEFINICIN...................................................................................................................................... 136 ARGUMENTOS DE LAS FUNCIONES ................................................................................................... 139 Llamadas por valor........................................................................................................... 140 Llamadas por referencia .................................................................................................. 140 CREACIN DE BIBLIOTECAS PROPIAS: ............................................................................................ 143 FUNCIONES RECURSIVAS Y ALGORITMOS RECURSIVOS.................................................................... 145 ARREGLOS................................................................................................................................................... 147 DEFINICIN...................................................................................................................................... 147 ARREGLOS UNIDIMENSIONALES ...................................................................................................... 147 TIPO_DE_DATO NOMBRE_VARIABLE [TAMAO] ........................................................................... 148 ARREGLOS BIDIMENSIONALES........................................................................................................... 150 ARREGLOS MULTIDIMENSIONALES................................................................................................... 151 INICIALIZACIN DE ARREGLOS CON TAMAO ................................................................................... 152 INICIALIZACIN DE ARREGLOS SIN TAMAO .................................................................................... 153
APENDICE A ...................................................................................................... A-1 INTRODUCCIN A LA PROGRAMACIN ESTRUCTURADA

4.1. Tcnicas de programacin ............................................................................................... A-1 4.2. Programacin modular ...................................................................................................... A-1 4.3. Programacin estructurada ............................................................................................. A-3 4.4. Estructura secuencial ................................................................................................... A-4 4.5. Estructura selectiva .......................................................................................................... A-5 4.6. Estructura repetitiva ......................................................................................................... A-9 4.7. Estructura de decisin anidada ..................................................................................... A-10 4.8. Estructura repetitivas anidadas ..................................................................................... A-11 4.9. La instruccin ir_a (goto) ................................................................................................. A-12
APENDICE B........................................................................................................ B-1 APUNTADORES EN C y C++

1. Introduccin ............................................................................................................................ 2. Definicin de apuntador ...................................................................................................... 3. Referenciacin ...................................................................................................................... 4. Declaracin de apuntadores ............................................................................................. 5. Asignacin de apuntadores ............................................................................................... 6. Desreferenciacin de apuntadores ................................................................................. 7. Verificacin de tipos en apuntadores ............................................................................. 8. Direcciones invlidas y la direccin NULL .................................................................. 9. Apuntadores a apuntadores ............................................................................................... 10. Apuntadores constantes y apuntadores a constantes ............................................. 11. Apuntadores, arreglos y aritmtica de apuntadores ................................................ 12. Apuntadores para paso de parmetros por referencia ............................................ 13. Asignacin dinmica de memoria ................................................................................ 13.1. Asignacin dinmica de memoria al estilo de C ..................................... 13.2. Asignacin dinmica de memoria al estilo de C++ ................................ B-1 B-1 B-1 B-2 B-2 B-2 B-3 B-3 B-4 B-5 B-5 B-6 B-7 B-7 B-8
APENDICE C......................................................................................................... C-1 TUTORIAL SOBRE APUNTADORES Y ARREGLOS EN C

Prefacio ........................................................................................................................... C-2 Introduccin .................................................................................................................... C-3 Captulo 1: Qu es un Apuntador? .............................................................................. C-4 Captulo 2: Tipos de Apuntadores y Arreglos............................................................... C-9 Captulo 3: Apuntadores y Cadenas. ............................................................................ C-13 Captulo 4: Ms sobre Cadenas. ................................................................................... C-17 Captulo 5: Apuntadores y Estructuras. ....................................................................... C-19 Captulo 6: Ms sobre Cadenas y Arreglos de Cadenas. ........................................... C-23 Captulo 7: Ms sobre Arreglos Multidimensionales................................................... C-27 Captulo 8: Apuntadores a Arreglos.............................................................................. C-29 Captulo 9: Apuntadores y Gestin Dinmica de Memoria. ....................................... C-31 Captulo 10: Apuntadores a Funciones ........................................................................ C-38 Eplogo ............................................................................................................................ C-49
Ing. Yamil Armando Cerquera Rojas
MODULO POR
: ALGORITMICA PARA PROGRAMACION : YAMIL ARMANDO CERQUERA ROJAS

DOCENTE UNIVERSIDAD SURCOLOMBIANA
Neiva Huila - Colombia 2001 Nota: Este mdulo se encuentra a disposicin de todos aquellos que estn interesados en aprender a resolver problemas bsicos haciendo uso de las herramientas que nos da los diferentes lenguajes de programacin para ello. Conocidas como Estructuras de programacin (Asignacin, Decisin, Cclicas y de Seleccin Mltiple). Cualquier sugerencia o critica la podrn dirigir a yacerque@usco.edu.co.
Agradecimientos especiales al personal de monografas.com por el LINK.
CONTENIDO
INTRODUCCIN ..................................................................................................................................... 3 OBJETIVOS Y CONTENIDO .................................................................................................................. 5 PARA QUE SIRVE LA PROGRAMACIN ............................................................................................ 6 QUE ES LA PROGRAMACIN .............................................................................................................. 7 QUE ES UN LENGUAJE DE PROGRAMACIN .................................................................................. 8 NIVELES DE LOS LENGUAJES ............................................................................................................. 9 TIPOS DE PROGRAMACIN................................................................................................................10 EL SECRETO DE PROGRAMAR EST EN LA ESTRUCTURACIN ..............................................11 ELEMENTOS BSICOS DE UN PROGRAMA ....................................................................................12 ELEMENTOS BSICOS DE UN PROGRAMA EN C ..........................................................................13
MAIN() .................................................................................................................................................................... 14 LA DIRECTIVA #INCLUDE:......................................................................................................................................... 14 DEFINICIN DE VARIABLES: ...................................................................................................................................... 15 VARIABLES GLOBALES:............................................................................................................................................... 15 VARIABLES LOCALES:................................................................................................................................................ 15 PROTOTIPO DE FUNCIN: .......................................................................................................................................... 16 ENUNCIADOS DEL PROGRAMA:.................................................................................................................................... 16
DEFINICIN DE FUNCIN:.......................................................................................................................................... 17 COMENTARIOS:......................................................................................................................................................... 17 FLUJO DE SENTENCIAS ............................................................................................................................................... 18
ESTRUCTURAS ESTTICAS DE DATOS ...............................................................................................22 TIPOS DE DATOS ....................................................................................................................................23 PREDEFINIDOS POR LOS LENGUAJES ............................................................................................23
TIPOS DE DATOS ENTEROS............................................................................................................................ 23 TIPOS DE DATOS REALES.............................................................................................................................. 24 TIPOS DE DATOS CHAR.................................................................................................................................. 24 TIPOS DE DATOS STRING............................................................................................................................... 25 TIPOS DE DATOS BOOLEAN........................................................................................................................... 26
TIPOS DEFINIDOS POR EL USUARIO: ................................................................................................27

DATOS DE TIPO SUBRANGO:......................................................................................................................... 27 DATOS DE TIPO ENUMERADO....................................................................................................................... 27
ALGORITMOS Y PROGRAMAS...............................................................................................................33 DISEO DE PROGRAMAS: ...................................................................................................................33 DIAGRAMAS DE FLUJO .......................................................................................................................34
UNIVERSIDAD SURCOLOMBIANA
1 de 154
REGLAS DE PROGRAMACIN:............................................................................................................36 PROGRAMACIN ESTRUCTURADA ....................................................................................................36 ESTRUCTURAS DE PROGRAMACIN ..................................................................................................38 ESTRUCTURA DE ASIGNACIN ..........................................................................................................38
Expresiones simples........................................................................................................................................... 38 Expresiones complejas....................................................................................................................................... 39
ESTRUCTURA DE DECISIN ...............................................................................................................65

Estructura Sencilla:........................................................................................................................................... 65 Operadores de Relacin: ................................................................................................................................... 65 Operadores Lgicos: ......................................................................................................................................... 66 Estructuras de decisin anidadas:...................................................................................................................... 67 Ejercicios Aplicando Estructuras de Decisin..................................................................................................... 68
ESTRUCTURAS CCLICAS ....................................................................................................................97

Ciclos con control antes..................................................................................................................................... 97 Ciclos con control despus: ............................................................................................................................... 97 Estructuras cclicas anidadas: ........................................................................................................................... 98 Estructura cclica FOR-ENDFOR ...................................................................................................................... 99
ESTRUCTURA DE SELECCIN MULTIPLE .......................................................................................133 FUNCIONES...........................................................................................................................................136 DEFINICIN ...........................................................................................................................................136 ARGUMENTOS DE LAS FUNCIONES ............................................................................................................139 Llamadas por valor..........................................................................................................................140 Llamadas por referencia ..................................................................................................................140 CREACIN DE BIBLIOTECAS PROPIAS: ......................................................................................................143 FUNCIONES RECURSIVAS Y ALGORITMOS RECURSIVOS ................................................................................145 ARREGLOS .............................................................................................................................................147 DEFINICIN ...........................................................................................................................................147 ARREGLOS UNIDIMENSIONALES ...............................................................................................................147 TIPO_DE_DATO NOMBRE_VARIABLE [TAMAO] ...................................................................................148 ARREGLOS BIDIMENSIONALES ...................................................................................................................150 ARREGLOS MULTIDIMENSIONALES ............................................................................................................151 INICIALIZACIN DE ARREGLOS CON TAMAO .............................................................................................152 INICIALIZACIN DE ARREGLOS SIN TAMAO ...............................................................................................153
2 de 154
INTRODUCCIN
EL lenguaje C es el resultado de un proceso de desarrollo que inici con un lenguaje denominado BCPL. Este influenci a otro llamado B (inventado por Ken Thompson). En los aos 70; ste lenguaje llev a la aparicin del C. Con la popularidad de las microcomputadoras muchas compaas comenzaron a implementar su propio C por lo cual surgieron discrepancias entre s. Por esta razn ANSI (American National Standars Institute, por sus siglas en ingls), estableci un comit en 1983 para crear una definicin no ambigua del lenguaje C e independiente de la mquina que pudiera utilizarse en todos los tipos de C. Algunos de las C existentes son: Quick C C++ Turbo C Turbo C ++ Borland C Microsoft C Visual C C Builder
Los cdigos presentados en este libro estn basados en el C y Turbo pascal estndar los cuales pueden utilizarse en todos los tipos de C y Pascal existentes en el mercado. C es un lenguaje de programacin de nivel medio ya que combina los elementos del lenguaje de alto nivel con la funcionalidad del ensamblador. Su caracterstica principal es ser portable, es decir, es posible adaptar los programas escritos para un tipo de computadora en otra. Otra de sus caractersticas principales es el ser estructurado, es decir, el programa se divide en mdulos (funciones) independientes entre s. El lenguaje C inicialmente fue creado para la programacin de: Sistemas operativos
3 de 154
Intrpretes Editores Ensambladores Compiladores Administradores de bases de datos.
Actualmente, debido a sus caractersticas, puede ser utilizado para todo tipo de programas. Como principal objetivo, este libro trata de vulgarizar el lenguaje C colocndolo al alcance de todos los estudiosos de cualquier nivel o profesionales de la programacin con conocimientos mnimos informticos. Para ello, a lo largo de los diferentes captulos, se trata al lenguaje no como algo aislado en si mismo, sino relacionado especficamente con la Metodologa de la Programacin y la Estructura de Datos, fuentes indispensables del conocimiento profundo de cualquier lenguaje de programacin. El trmino vulgarizar, que aqu se utiliza, no significa en modo alguno eliminar la teora del lenguaje y descender al terreno prctico olvidando la misma, si no completamente teora y practica mediante la inclusin de todos los ejemplos oportunos y las aclaraciones necesarias aunque estas puedan parecer, a veces, superfluas e incluso dadas por sabidas.
4 de 154
OBJETIVOS Y CONTENIDO
Este libro tiene un objetivo fundamental: Introducir y explicar los conceptos fundamentales de las estructuras de programacin utilizadas en los diferentes de lenguajes de programacin de microcomputadoras. Esta diseado para ser utilizado de diversas formas: Como libro de texto, libro complementario, libro de problemas de programacin, libro de anlisis numrico o bien como libro de introduccin a la programacin de computadoras. El seguimiento de este libro no requiere ningn conocimiento previo de programacin de computadoras, aunque, si se utiliza como libro de problemas puede complementarse con algn libro de mayor contenido terico relativo a algoritmos, estructuras de datos o bien lenguajes de programacin. El libro esta dividido en varios captulos que abarcan los conceptos esenciales de las estructuras de programacin en los diferentes lenguajes comnmente utilizados en la programacin de computadoras. En la primera parte se trata lo relacionado con los smbolos utilizados en la diagramacin o solucin de problemas a nivel simblico (Diagramas de flujo). En la segunda parte se desarrollarn algunos ejercicios donde se muestra de manera prctica la utilizacin de dichos smbolos Una tercera parte donde se analizan las estructuras de asignacin Una cuarta parte donde se analizan las estructuras de decisin Una quinta parte donde se analizan las estructuras repetitivas o cclicas Una sexta parte donde se analizan las estructuras de seleccin mltiple. Cada uno de los captulos esta diseado de tal forma que el lector entienda de manera clara y sencilla el uso de cada uno de las estructuras mencionadas anteriormente. De igual forma cada uno de los captulos estar soportado con una buena cantidad de ejercicios resueltos que aclaran la forma correcta de utilizacin de dichas estructuras. A cada uno de los ejercicios que se plantean en el presente libro, se le har un anlisis de su solucin de manera mecnica, se llevar a un anlisis simblico y luego se desarrollar el algoritmo al nivel de diagramas de flujo, Seudo lenguajes, Seudo cdigos y Cdigos. Para esta ltima parte se codificar cada ejercicio en Turbo Pascal y Lenguaje C.
5 de 154
PARA QUE SIRVE LA PROGRAMACIN

Una persona piensa y se comporta obedeciendo a un secuencial lgico. Un computador realiza tareas y maneja datos en memoria obedeciendo a una secuencia de pasos lgicos para lo cual ha sido programado. Programacin de computadoras es la ciencia que permite a una persona programar una computadora para que resuelva tareas de manera rpida. Un Programa de computadora se puede definir como una secuencia de instrucciones que indica las acciones o tareas que han de ejecutarse para dar solucin a un problema determinado. Programar computadoras es indispensable en cualquier rea de la ingeniera, ya que diferentes problemas que se puedan presentar tardan tiempo resolverlos de manera manual. La computadora resuelve problemas de acuerdo como se le haya programado de manera rpida.
6 de 154
QUE ES LA PROGRAMACIN
La definicin anterior deja muchas cosas que decir. Para llegar a tener una secuencia de instrucciones que den solucin a un problema es necesario ejecutar varias etapas. Etapa de anlisis: En esta etapa el programador debe entender claramente el problema. Saber que es lo que se quiere resolver. (analizar) Etapa de Solucin general: Escribir la serie de pasos que sean necesarios para dar solucin al problema. Estos pasos se pueden desarrollar a travs de un Diagrama de flujo (Utilizando smbolos) a travs de un seudo lenguaje (Utilizando Lenguaje comn). A lo anterior es lo que se conoce con el nombre de Algoritmo. Etapa de prueba: Consiste en chequear el algoritmo paso a paso para estar seguro si la solucin da solucin verdaderamente el problema. (Prueba de escritorio). Etapa de implementacin especfica: Consiste en traducir el algoritmo a un lenguaje de programacin. (Codificar). Etapa de prueba: Consiste en ejecutar el programa en un computador y revisar los datos arrojados para ver si son correctos y hacer los ajustes necesarios. (Implementar). Etapa de uso: Consiste en instalar el programa de manera definitiva para el uso por parte del usuario.
7 de 154
QUE ES UN LENGUAJE DE PROGRAMACIN

Se puede definir un lenguaje de programacin como un conjunto de reglas normas, smbolos y palabras especiales utilizadas para construir un programa y con l, darle solucin a un problema determinado. El lenguaje de programacin es el encargado de que la computadora realice paso a paso las tareas que el programador a diseado en el algoritmo. Se puede decir que un lenguaje de programacin es el intermediario entre la mquina y el usuario para que este ltimo pueda resolver problemas a travs de la computadora haciendo uso de palabras (funciones) que le traducen dicho programa a la computadora para la realizacin de dicho trabajo.
8 de 154
NIVELES DE LOS LENGUAJES

Desde que se desarrollaron las mquinas programables se han desarrollado lenguajes con los cuales las personas puedan dar rdenes a stas. En su orden los lenguajes de programacin se pueden clasificar as: Lenguaje de mquina: Las primeras computadoras se programaban en cdigo de mquina. Se puede decir que los programas eran diseados en cdigo binario. Eran difciles de leer, difciles de entender y por su puesto difciles de corregir. Los programas se caracterizaban por ser pequeos. Lenguajes de Bajo Nivel: Para dar solucin a lo difcil que era programar en cdigo mquina, se desarroll un lenguaje conocido como lenguaje ensamblador. Este lenguaje era encargado de tomar algunas palabras comunes a una persona y traducirlas al cdigo mquina. Lo anterior facilitara un poco la escritura de programas. Lenguajes de alto nivel: Como las personas resuelven problemas y se comunican en lenguajes naturales (espaol, ingles, francs, etc.), se desarrollaron lenguajes de programacin que estuvieran mas cerca de sta manera de resolver problemas. De los lenguajes de alto nivel se puede citar el Basic, Cobol, Fortran, Pascal, Turbo Pascal, C, Modula, Ada. Como se hace necesario traducir el programa a lenguaje de mquina, en los lenguajes de alto nivel esa operacin la realiza algo que se conoce con el nombre de Compilador.
9 de 154
TIPOS DE PROGRAMACIN
Dependiendo del lenguaje de programacin que se elija, se puede hablar del tipo de programacin que se va a realizar. Secuencial : Se considera programacin secuencial a los programas que se disean con instrucciones que van unas detrs de otras. Las lneas se ejecutan una a una en secuencia. Ejemplos tales como Basic, Cobol. Estructurada: Se considera programacin estructurada a la programacin que se hace por mdulos. Cada mdulo realiza alguna tarea especfica y cuando se necesite esa tarea simplemente se hace el llamado a ese mdulo independiente de que se tengan que ejecutar los dems. Ejemplos tales como: Turbo PASCAL, C, Modula, Ada. Orientada a Objetos: Se considera programacin orientada a objetos aquellos lenguajes que permiten la utilizacin de objetos dentro del diseo del programa y el usuario puede pegar a cada objeto cdigo de programa. Ejemplos de estos lenguajes se pueden mencionar el Visual Basic de la Microsoft, C Builder de la Borland Internacional, Java, Xml entre otros. Lgica o de lenguaje natural: son aquellos programas que se disean con interfaces tal que la persona o usuario puede ordenar a la mquina tareas en un lenguaje natural. Pueden interactuar como una persona pero nunca llegan a producir conocimiento. Ejemplo como Prolog (Programming Logic). Estos lenguajes se desarrollaron con base en las estructuras de sus antecesores. Recorren o navegan las bases de datos obedeciendo a reglas. Inteligencia Artificial: Los programas de inteligencia artificial Son programas que se acercan a la inteligencia humana. Estos programas son capaces de desarrollar conocimiento. Este tipo de lenguajes trabajan similar a la mente humana.
10 de 154
EL SECRETO DE PROGRAMAR EST EN LA ESTRUCTURACIN

Turbo Pascal y C por su diseo son lenguajes estructurados. C y Turbo PASCAL no permiten al programador enlazar sentencias de cualquier manera. Existe una estructura bsica que cada programa debe seguir (Estructura de un programa) y el compilador es estricto a la hora de hacer cumplir estas reglas. Un programa ha de ser codificado en varias partes y cada una de ellas debe ir en el lugar que le corresponde. La idea fundamental del lenguaje C y Turbo Pascal es crear programas que sean comprendidos sin necesidad de emplear docenas de pginas de diagramas de flujo y miles de explicaciones. Esta manera de realizar los programas es a lo que denomina como "PROGRAMACIN ESTRUCTURADA". Aunque se pueda llegar a realizar programas que aparentan tener una estructura (ser estructurados), Turbo Pascal y C son lenguajes que exige su utilizacin. La programacin estructurada le permite realizar pequeas rutinas especficas para cada tarea que se quiera realizar, y a cada una de esas rutinas se les da un nombre (Identificador) para cuando el programador la requiera slo la llame con su nombre y automticamente se ejecutar.
11 de 154
ELEMENTOS BSICOS DE UN PROGRAMA

En el mbito general, un programa codificado o escrito bajo cualquier lenguaje de programacin estructurado consta bsicamente de dos secciones: Seccin encabezado Seccin cuerpo de programa
La seccin de encabezado es usada para declarar, mencionar o identificar las variables con sus respectivos tipos y/o las constantes que se vayan a utilizar en el desarrollo del programa, as como tambin el nombre de las funciones y/o los procedimientos que ejecutarn las instrucciones de los diferentes algoritmos que va a tener dicho programa. Adems en esta seccin se declaran los archivos de inclusin (Archivos con extensin .h) que permiten el uso de algunas funciones que son necesarias para el desarrollo en si del programa. Igualmente se especifican las estructuras de datos complejas que se vayan a manejar. En la seccin cuerpo de programa realmente se describen todos los procedimientos y/o funciones que se van a ejecutar dentro del programa as como tambin el cdigo del programa principal. Como cuerpo de programa es indispensable que haya parte principal mientras que los procedimientos y/o funciones son opcionales.
12 de 154
ELEMENTOS BSICOS DE UN PROGRAMA EN C

El siguiente ejemplo ilustra algunos de los componentes que con mayor frecuencia se usan cuando se trata de codificar programas utilizando el lenguaje de programacin C. Cada una de las lneas es numerada para efectos de explicacin posterior. En el momento de probarlo en el lenguaje de programacin no es necesario la numeracin. 1. /* Programa para calcular el producto de dos nmeros ingresados por teclado */ 2. #include stdio.h 3. int a,b,c; 4. int producto(int x, int y); 5. main() 6. { 7. /* pide el primer numero */ 8. printf(digite un numero entre 1 y 100); 9. scanf(%d,&a); 10. 11. /* pide el segundo numero */ 12. printf(digite un numero entre 1 y 100); 13. scanf(%d,&b); 14. 15. /* calcula y despliega el producto */ 16. c = producto(a,b); 17. printf(\n%d por %d = %d, a, b, c); 18. } 19. 20. /* funcin que calcula y regresa el producto de sus dos argumentos */ 21. int producto(int x, int y) 22. { 23. return(x*y); previamente
13 de 154
24. } Aunque cada uno de los programas son distintos, todos tienen caractersticas comunes. Los elementos bsicos de un programa codificado en lenguaje C son los siguientes tomando el ejemplo anteriormente descrito: La funcin main() (lnea 5 y desarrollada de la 6 18) La directiva #include (lnea 2) Definicin de variables (lnea 3) Prototipo de funcin (lnea 4) Enunciados del programa (lnea 8,9,12,13,16,17,23) Definicin de funcin (lnea 21 24) Comentarios (Lnea 1,7,11,15,20)
Veamos en que consiste cada uno: main() En C, todo el cdigo est basado en funciones. El programa principal no es la excepcin. main() indica el comienzo de la funcin principal del programa la cual se delimita con llaves. . Este componente es obligatorio en cualquier programa que se compile con lenguaje C. En su forma simple la funcin main consiste en la palabra main seguida de parntesis () y las instrucciones que ejecutan se encuentran demarcadas por las dos llaves {}. Sin embargo no todos los programas tienen esta tradicional funcin; los programas de Windows escritos en C y C++ disponen de una funcin de inicio llamada winmain() en lugar de la tradicional main(): Nota: La seccin main o funcin main es la primera seccin de cdigo que se ejecuta cuando se le d la orden de ejecutar el cdigo. Desde aqu se har el respectivo enlace con las dems funciones que posea el programa. La directiva #Include: La directiva #include da instrucciones al compilador C para que aada el contenido de un archivo de inclusin al programa durante la compilacin. Un
14 de 154
archivo de inclusin es un archivo de disco separado que contiene informacin necesaria para el compilador. Varios de estos archivos (Algunas veces llamados archivos de encabezado) se proporcionan con el compilador. Nunca se necesita modificar la informacin de estos archivos y esta es la razn por la cual se mantienen separados del cdigo fuente. Todos los archivos de inclusin deben tener la extensin (.h) (por ejemplo stdio.h). Se usa la directiva #include para darle instrucciones al compilador que aada un archivo especfico al programa durante la compilacin. La directiva #include, en este programa de ejemplo, significa aada el contenido del archivo stdio.h . Nota: La mayora de los programas codificados en lenguaje C requieren uno o ms archivos de inclusin. Depende del tipo de funciones que se estn utilizando: Ejemplo de ellas printf(), scanf(), clrscr(); gotoxy()..... Definicin de variables: Una variable es un nombre asignado a una posicin de almacenamiento de datos. El programa utiliza variables para guardar varios tipos de datos durante la ejecucin del programa. En C, una variable debe ser definida antes de que pueda ser usada. Una definicin de variable le informa al compilador el nombre de la variable y el tipo de datos que va a guardar. En el programa de ejemplo la definicin de la lnea 3, "int a,b,c" define tres variables, llamadas a, b, y c que guardar cada una un valor de tipo entero. Las variables se pueden declarar en la zona de encabezado de un programa o al inicio de una funcin o un procedimiento. Variables globales: Las variables globales son aquellas variables que se definen o declaran en la zona de encabezado de cualquier programa en C. Estas variables pueden ser utilizadas en cualquier parte del programa, igualmente puede ser modificado su valor desde cualquier instruccin. Variables Locales: Las variables son consideradas como locales cuando su declaracin se hace al inicio de una funcin o un procedimiento. Las variables que hayan sido declaradas como locales solo podrn ser reconocidas por el procedimiento o funcin donde se haya declarado. En ninguna otra parte del programa se puede hacer uso de ellas.
15 de 154
Un reciente cambio de regla de aproximacin del comit de ANSI de C++ afecta la visibilidad de una variable que se declara en una instruccin como for. El siguiente cdigo generar un error de compilador. Int index; For (int i=1;I<10;I++) { cout <<I; } index=I; Prototipo de funcin: Un prototipo de funcin proporciona al compilador C el nombre y los argumentos de una funcin contenida en el programa, y debe aparecer antes de que la funcin sea usada. Un prototipo de funcin es diferente de una definicin de funcin que contiene las instrucciones actuales que hacen a la funcin. El prototipo de funcin debe llevar (;). Nota: Un prototipo de funcin debe llevar (;) en la seccin de encabezado. Cuando se desarrolla en el cuerpo del programa no debe llevar (;) Enunciados del programa: El trabajo real de un programa C es hecho por sus enunciados. Los enunciados de C despliegan informacin en la pantalla, leen entradas desde el teclado, ejecutan operaciones matemticas, llaman funciones, leen archivos de disco y hacen todas las otras operaciones que un programa necesita ejecutar. printf(): El enunciado printf() es una funcin de biblioteca que despliega informacin en la pantalla. El enunciado printf puede desplegar un simple mensaje de texto o un mensaje y el valor de una o ms variables del programa. Ej: printf(este es un simple comentario); printf(El cuadrado de %d es igual a %d,a,a*a); scanf():
16 de 154
El enunciado scanf() es otra funcin de biblioteca. Ella lee datos desde el teclado y asigna los datos a una o ms variables del programa. Ej: scanf(%d,&a); scanf(%d %d,&a,&b); En el primer ejemplo se lee un valor entero y este es asignado a la direccin de la variable a. En el caso del segundo ejemplo se leen dos datos enteros y cada valor es almacenado en las variable a y b respectivamente. Definicin de funcin: Una funcin es una seccin de cdigo independiente y auto contenida que es escrita para ejecutar determinada tarea. Cada funcin tiene un nombre y el cdigo de cada funcin es ejecutado incluyendo el nombre de la funcin, en una instruccin de programa. A esto se le llama llamado de la funcin. La funcin denominada producto, es una funcin definida por el usuario. Tal como lo indica su nombre las funciones definidas por el usuario son escritas por el programador durante el desarrollo del programa. Esta funcin es simple, ya que todo lo que hace es multiplicar dos valores y regresar el resultado de dicha multiplicacin al programa que la llam. El C tambin incluye funciones de biblioteca que son parte del paquete del compilador C. Las funciones de biblioteca ejecutan la mayora de las tareas comunes (como la entrada /salida de la pantalla el teclado y disco) que necesita el programa. En el programa de ejemplo printf y scanf son funciones de biblioteca. Comentarios: Se identifican porque van entre diagonales y asterisco. Nos sirve para escribir informacin que nos referencie al programa pero que no forme parte de l. Por ejemplo especificar que hace el programa, quien lo elabor, en que fecha, que versin es, etc. El compilador ignora lo que haya como comentario en el momento de hacer la compilacin del programa. Ej: /* Este es un comentario */ En el caso de otra interfaces como MatLab los comentarios simplemente se declaran iniciando la lnea con un %
17 de 154
Flujo de sentencias: Es la declaracin de todas las instrucciones que conforman un programa. Todas las sentencias van separadas por (;), en renglones separados o de manera seguida. Definicin de funciones creadas por el programador utilizadas en main(): Finalmente, se procede a definir el contenido de las funciones utilizadas dentro de main(). Estas contienen los mismos elementos que la funcin principal. Importante: Despus de cada asignacin o funcin es imprescindible colocar un punto y coma (;) ya que ste es un terminador de proposiciones. En caso de que no se escriba, se marcar un error a la hora de compilar el programa. En C, los comandos, palabras reservadas o funciones deben ser escritos con letras minsculas, tal como se hizo en el programa de ejemplo. En el lenguaje Turbo Pascal no interesa de que modo se escriban. En el caso de las variables o las funciones definidas por el usuario la situacin es similar para el caso del lenguaje C, no es lo mismo: Apellido - apellido APELLIDO Aunque para nosotros es lo mismo, el compilador de C, los toma como tres nombres distintos. Por tanto, asegrese de mandar llamar las variables o funciones exactamente de la misma forma en que las declar. En el caso del los lenguajes Turbo Pascal y Basic no diferencian entre maysculas y minsculas o sea que para dichos lenguajes lo mismo es "A" que "a". Ejemplos: a) En el siguiente ejemplo se despliega o muestra un mensaje de bienvenida en la posicin 20 sobre el eje X (Horizontal) y 10 sobre el eje Y (Vertical) de la pantalla y se espera 2.5 segundos aproximadamente mientras el usuario observa dicho mensaje.
#include<stdio.h> #include<conio.h> main()
18 de 154
clrscr(); gotoxy(20,10); printf("BIENVENIDO AL CURSO DE C ESTNDAR"); delay(2500); }
La funcin delay en el ejemplo anterior permite indicarle a la maquina cuando ejecute dicha funcin que se espere 2.5 segundos aproximadamente mientras el usuario lee lo que esta presentado en la pantalla. Pasado los dos segundos el compilador continuara la ejecucin de la siguiente lnea. b) El siguiente programa le pregunta por su nombre y los aos que tienes. Al final da como respuesta el nmero de das vividos y le coloca un mensaje para que termine el programa. Por la forma que se detiene el programa (getch()) hasta que no se pulse una tecla la computadora no terminara la ejecucin del programa.
#include<stdio.h> #include<conio.h> main() { char nombre[50]; int edad; clrscr(); gotoxy(10,5); printf("Cmo te llamas?\n "); scanf("%s",&nombre); gotoxy(10,6); printf("Cuntos aos tienes?\n"); scanf("%i",&edad); edad = edad * 365; gotoxy(10,8); printf("%s, has vivido %d das",nombre,edad); gotoxy(40,22); printf("Pulsa cualquier tecla para terminar..."); getch(); } Los parmetros %s y %d corresponden a los tipos de datos que se leen o escriben. En la seccin de tipos de datos podr encontrar los diferentes tipos de datos as como sus parmetros.
19 de 154
c)
El siguiente ejemplo permite la captura por teclado de 3 nmeros cada uno de ellos almacenados en un nombre de variable diferente y al final se entrega el promedio de dichos valores.
#include<stdio.h> #include<conio.h> main() { float numero; float promedio=0; clrscr(); gotoxy(10,5); printf("Dame el primer nmero: "); scanf("%f",&numero); promedio+=numero; gotoxy(10,6); printf("Dame el segundo nmero: "); scanf("%f",&numero); promedio+=numero; gotoxy(10,7); printf("Dame el tercer nmero: "); scanf("%f",&numero); promedio += numero; promedio = promedio/3; gotoxy(10,8); getch(); } Si el ejemplo anterior lo desea correr bajo MatLab tiene que guardarlo en un archivo tipo m en el directorio Work de Matlab o en el directorio donde haya configurado en Set Path de la Opcin de men File. Una vez guardado bajo cualquier nombre, entonces simplemente en el prompt del matlab lo ejecuta llamando el archivo por el nombre guardado. promedio=0; n=input('Dame el 1 nmero:'); promedio=promedio+n; n=input('Dame el 2 nmero: '); promedio=promedio+n; n=input('Dame el 3 nmero: '); promedio = promedio+ n; printf("El promedio es %f",promedio); gotoxy(40,22); printf("Presione cualquier tecla para terminar...");
20 de 154
promedio = promedio/3; fprintf('El promedio es %f \n',promedio); fprintf('Presione tecla para terminar...\n'); pause d) El siguiente ejemplo convierte un nmero capturado por teclado en sistema numrico decimal al sistema octal utilizando parmetros que ofrece el lenguaje C para dicha conversin.
#include<stdio.h> #include<conio.h> main() { int numero; clrscr(); gotoxy(10,5); gotoxy(10,6); getch(); } printf("Digite un nmero entero en decimal: "); printf("\n\n Su representacin en octal es %o"); scanf("%i", &numero); gotoxy(40,22); printf("Presione cualquier tecla para terminar...");
e)
El siguiente ejemplo escribe un mensaje de advertencia sobre algo al usuario y lo mezcla con algunos sonidos que son familiares.
#include <dos.h> #include<conio.h> int main(void) { clrscr(); gotoxy(28,11); printf(" P E L I G R O ! "); sound(250); delay(600); sound(80); delay(600); delay(600); nosound(); return 0;
21 de 154
ESTRUCTURAS ESTTICAS DE DATOS

Se denominan estticas las estructuras de datos simples, o complejas, que una vez definidas dentro de un programa, permanecen inalteradas durante la ejecucin del mismo, sin poder variar, por tanto, su posicin en memoria, ni su longitud en bytes, declarada al especificar el tipo de la misma. En este sentido, y de menor a mayor complejidad, son estructuras estticas tradicionales de datos: Las variables de carcter Las variables numricas enteras Las variables numricas de punto flotante o reales Las variables de tipo cadena (string) Las matrices (arrays), formadas por elementos contiguos en memoria de los tipos citados anteriormente Los registros y archivos
Tradicionalmente se han definido como dinmicas las estructuras de cola, pila y rbol por permitir la variacin del nmero de sus elementos, dentro de ciertos lmites, durante la ejecucin del programa. Por lo complejo que resulta el manejo de todo tipo de estructuras, en este libro se menciona tan solo los tipos de estructuras simples que son los mas manejados para la solucin de problemas comunes a las Ingenieras.
22 de 154
TIPOS DE DATOS
En el presente captulo se har un recuento del tipo de datos usados en los lenguajes de programacin con el fin de que el usuario pueda en un momento dado entender el tipo de datos utilizado en la mayor parte de ejercicios solucionados en el presente libro. Se visualizara para cada lenguaje en particular el tipo de dato que maneja al igual que sus rangos. Se dar cuenta que la mayora maneja los datos con la misma filosofa y la variacin de unos a otros esta dado solo por la sintaxis que se use para hacer referencia a ellos. La gran variedad de datos que trae consigo un lenguaje de programacin hace que el programador escoja el tipo mas adecuado para la aplicacin que est desarrollando. El rango de datos que maneja cada tipo, indica al usuario que escoger. Los datos se pueden agrupar en los siguientes tipos. PREDEFINIDOS POR LOS LENGUAJES: ENTEROS DECIMALES DE CADENA BOLANOS DEFINIDOS POR EL USUARIO SUBRANGO ENUMERADOS PREDEFINIDOS POR LOS LENGUAJES TIPOS DE DATOS ENTEROS Los tipos enteros largos son ms precisos, pero los enteros cortos son ms simples, rpidos y ocupan menos memoria. El valor extremo del rango de cada uno de los enteros est dado por el espacio que ocupa dicho entero en memoria, veamos. Un byte de memoria esta formado por 8 bits. Cada uno de estos bit pueden ser un bit 0 o un bit 1. las combinaciones que podemos tener en un byte (8 bit) podran ir desde:
23 de 154
0 0 0 0 (8 bits ceros)
1 1 1 1 1 1 1 1 (8 bits unos)
Si se pasa el conjunto de bits (Sistema Binario) a Sistema decimal tenemos que el rango que se maneja ahora ir desde: 0 (decimal correspondiente a los 8 bits ceros) a 255 (decimal correspondiente a los 8 bits unos)
Como el rango anterior est utilizando todos los ocho bits del byte para almacenamiento de datos, slo toma datos enteros positivos, no hay forma de reservar ningn campo bit para el signo. En el caso del entero corto, por utilizar siete bits para almacenamiento de datos, el octavo es usado para signar datos (signo mas o menos). Por tanto solo dispone en memoria de 7 bit para almacenar (bits unos) o (bits ceros). El rango manejado en sistema binario con siete (7) bit ir desde 0000000 hasta el 1111111, que en sistema decimal corresponde al rango de 0 al 127, o sea 128 datos enteros positivos. Como se deja un bit reservado para manejo de signo, entonces los datos negativos sern 128 tambin que irn en rango desde el -1 al -128. El rango definitivo de enteros positivos y negativos para el tipo de dato entero corto ser desde -128 al 127. TIPOS DE DATOS REALES Los nmeros reales son aquellos datos que tienen parte decimal. Un real se caracteriza porque siempre tiene dgitos antes y despus del punto. Cada uno de los lenguajes de programacin tiene un grupo para este tipo de datos. Al igual que los enteros, los reales se diferencian unos de otros por el rango que cada uno de ellos maneja. Vea tabla de tipos de datos. TIPOS DE DATOS CHAR Se define como Char a cualquier caracter o smbolo que conforman la tabla denominada ASCII. Una variable que se defina como tipo Char puede almacenar un solo caracter especificado entre apstrofes. {'A'}. Cada caracter se almacena en memoria RAM como un byte o dicho de otra manera cada caracter se almacena en una posicin de memoria. Por ser un solo byte, el nmero de caracteres diferentes que se pueden almacenar es de 256.
24 de 154
correspondiendo a los valores que van de 0 a 255 (en decimal) o 00000000 a 11111111 (en binario). El conjunto de caracteres de la tabla ASCII se agrupan en dos bloques as: El primer bloque conformado por los caracteres de control. Corresponden a ste bloque los caracteres del cdigo ASCII que van de 1 a 31. El segundo bloque conformado por los caracteres bsicos o caracteres imprimibles. Van del cdigo ASCII 32 al 126, se introducen directamente por el teclado El tercer bloque conformado por caracteres del cdigo ASCII ampliado. Para hacer referencia a ellos en turbo PASCAL se preceden del signo #. Para asignar cualquier caracter ASCII a una variable de tipo Char existen varias formas as: A := 'g'; {Se asigna el caracter g a la variable A} B := A; {Se asigna el valor de A, a la variable B} C := #65; {Se asigna el caracter numero 65 de la tabla ASCII a la variable C} TIPOS DE DATOS STRING Los tipos de datos cadena {String} son secuencia de caracteres que puede llegar a tener una longitud mxima de 255. cada caracter de esta cadena ocupa un byte en memoria, y la cadena ocupa tantos Bytes como caracteres le hayan asignado. Las cadenas se pueden definir del tamao que se necesite. El comportamiento de los String es similar al de los arreglos. Nombre := 'Pedro Prez'; La anterior cadena tiene 11 caracteres, por tanto va a ser una variable que ocupa 11 Bytes en memoria. Una variable de tipo cadena al ser definida en la seccin de variables se le est asignando un tamao fijo en cuanto al nmero mximo de caracteres que puede almacenar en un momento determinado. Ejemplo para lenguaje pascal: VAR Nom : String[20]; Dir : String;
25 de 154
Ejemplo para lenguaje C Char nom[10]; Cuando se define de tipo String y se restringe el nmero de caracteres, en el caso de nom tan solo a 20, se esta indicando al compilador que dentro del programa, mximo se le debe asignar una cadena de 20 caracteres o menos. Si un usuario asigna mas de lo que se estableci, simplemente se desechan los caracteres que sobren a la derecha. En el caso de la segunda definicin (Dir), no se est restringiendo su tamao por tanto es una variable que puede almacenar el mximo de caracteres para variables de este tipo (255); Vale anotar que durante la ejecucin de un programa se puede modificar la longitud de la variable tipo String. Algunas funciones de Turbo Pascal aplicadas a cadenas son las siguientes: Fillchar: Funcin que llena el buffers de la variable de una caracter determinado. Si en un momento determinado se quisiera llenar la variable Nom con letras 'A' en lugar de hacer la asignacin Nom:='AAAAAAAAAAAAAAAAAAAA', se puede realizar as: Fillchar(Nom,20,'A'); Se le est diciendo que llene la variable Nom con 20 caracteres 'A'. si no se conoce el tamao de la variable entonces se puede utilizar as: Fillchar(Nom,sizeof(Nom),'A'); Se utiliza la funcin Sizeof para indicar que llene totalmente la variable Nom con el caracter 'A'. TIPOS DE DATOS BOOLEAN Algunos lenguajes de programacin poseen este tipo de dato. El tipo boolean slo tiene dos valores posibles: False (00) True(01). Una variable que se declare de tipo boolean tendr asignado siempre uno de los dos valores, o verdadero o falso, y ocupa un solo byte de memoria RAM. Program lgica; Var op : boolean; Begin op := 2<3; {toma el valor de True} If op then Write('verdadero! 2 es menor que tres')
26 de 154
else End; write('El computador est loco!');
En el ejemplo anterior se le asigna a Op un valor lgico que depende de la evaluacin que se haga de ver si 2 es menor que 3. Como efectivamente es menor entonces se le asigna el valor de TRUE a op, y al evaluarlo en el si condicional (If) ejecuta la sentencia que est del lado del entonces (then en algunos lenguajes), de lo contrario algo raro andar pasando con su computador. TIPOS DEFINIDOS POR EL USUARIO: DATOS DE TIPO SUBRANGO: La estructura ms sencilla de definir es un subconjunto de datos tipo ordinal, esta estructura recibe el nombre de subrango. Si se escogen dos valores vlidos, estos dos valores ms todos los que queden entre los dos, forman el subrango de datos. Los datos que queden entre los datos definidos como inicio y final, corresponden a los datos que estn entre esos dos valores en la tabla ascii. Por ejemplo los siguientes son datos tipo subrango. Type Maysculas = 'A' .. 'Z'; Minsculas = 'a' .. 'z'; NumLiteral = '0' .. '9' NumDigito = 0 .. 9
En el caso anterior, se est definiendo una estructura Maysculas que tiene definidos caracteres que son A, B, C, D, E....Z; otra estructura Minsculas que tiene definidos caracteres que son a, b, c, d, e, f, g, h.....z y as sucesivamente. Cuando se declaran subrangos con apstrofes, se est indicando que se trata de caracteres (Char), si se quitan los apstrofes se tratar de nmeros, caso del tipo NumDigito. DATOS DE TIPO ENUMERADO Un tipo enumerado se puede considerar como un tipo ordinal definido por el programador. Consiste en una lista de datos cuyos nombres no se pueden repetir. En el caso anterior es fcil declarar rangos porque ya estn predefinidos en un cdigo llamado ASCII, pero cuando se trate de otro tipo de datos, se hace necesaria su enumeracin. Ej.: resulta difcil declarar una variable para que tome
27 de 154
como valores las frutas que estn entre Mora .. Tomate; realmente no se podra. Para ste caso se hace necesario enumerar todos los valores que puede tomar esa variable. Type fruta = (anon, mango, meln, mora, fresa, limn, naranja); color= (rojo, naranja, amarillo, verde, violeta, azul, negro);
La lista que forma un tipo enumerado se da siempre entre parntesis LENGUAJE C++ Posibles combinaciones de los tipos bsicos de datos en lenguaje C y los modificadores con los tamaos y rango de bits comunes se muestran en la siguiente tabla. Los tipos bsicos de datos en lenguaje son: Char, int, float, double bool y void. Algunos de ellos pueden ser modificados por los Modificadores Short, signed, unsigned, long. Si se utiliza un modificador Short se antepone al modificar %h, Si se utiliza el modificador long %l, Para el unsigned el modificador %u. Tipo Char Unsigned char Signed char Int Unsigned int Short int Unsigned short int Long int Unsigned long int Float Double Long double bool Tam en Bits 8 8 8 16 16 16 16 32 32 32 64 80 1 Rango -128..127 0..255 -128..127 -32768..32767 0..65535 -32768..32767 0..65535 -2,147,483,648..2,147,483,647 0..4,294,967,295 3.4E-38..3.4E+38 1.7E-308..1.7E+308 3.4E-4932..1.1E+4932 True o false Modificador Lect %c Escr %c
%d %i %hd
%d %i %hd
%lu %f %lf %Lf
%lu %f %Lf
Solo los tipos de datos double y float aceptan nmeros con punto flotante (nmeros con fracciones decimales), en tanto que los otros tipos manejan nicamente enteros. Aunque es valido asignar un valor que contenga una fraccin
28 de 154
decimal a un dato de tipo entero, dicha fraccin se elimina y solo se asigna la parte entera. Ejemplos de declaracin de variables son: int x,y; unsigned short int y,k,a; long double x,y; int w=10; Se puede al momento de declarar una variable asignarle un valor cualquiera. Las variables en lenguaje C se declaran como locales a procedimientos o funciones y globales en el encabezado del programa. LENGUAJE TURBO PASCAL DATOS ENTEROS NOMBRE Integer Word Shortint Byte Longint RANGO (desde - hasta) -32.768..32.767 0..65.535 128..127 0..255 -2.147.483.648..2.147.483.647 TAM (Byte) 2 2 1 1 4 Entero Entero Entero Entero Entero FORMATO con signo sin signo corto con signo corto sin signo largo con signo
DATOS REALES NOMBRE Real Single *Double *Extended *Comp RANGO (desde - hasta) 2.9 e 39 1.7 e 38 1.5 e 45 3.4 e 38 5.0 e 324 1.7 e 308 1.9 e 4851 1.1 e 4932 -9.2 e 18 9.2 e 18 TAM Bytes 6 4 8 10 8 CIFRAS SIGNIFICATIVAS 11-12 7-8 15-16 19-20 18-19
* Solo disponible con un coprocesador matemtico 80x87 o en nivel de coprocesador simulado.
29 de 154
Los tipos de datos reales diferentes al real, solo se pueden usar cuando existe u coprocesador matemtico o una emulacin del mismo mediante el uso de las directivas $N+ y $E-. Lo anterior gracias a que Turbo Pascal a partir de la versin 5.0 emula en software el chip coprocesador matemtico permitiendo utilizar los diferentes tipos de datos reales para ejecutar aplicaciones en mquinas que no posean este chip coprocesador. Ejemplos de la forma como se declaran los datos en Turbo pascal. Var X Y A B,c D E :char; :string(10); :byte; :integer; :double; :extended;
VISUAL BASIC: Posibles combinaciones de los tipos bsicos de datos en basic y todos sus sucesores hasta visual basic y los modificadores con los tamaos y rango de bits comunes. Los tipos bsicos de datos en lenguaje son: Integer, long, single, double, currency, string, byte, boolean, date, object y variant
Tipo Tam byte
Rango
0..255 -32768..32767 -2147483648..2147483647 -3.4E+38..3.4E+38 -1.79E-308..1.79E+308 -22337203685477.58..922337203685477.58 0..65535 True o False 1/enero/100 .. 31/diciembre/9999 cualquier referencia a objeto 16 con nmeros, 22 con caracteres
Tipo Carac
Byte Integer Long Single Double Currency String Boolean Date Object Variant
1 2 4 4 8 1 2 2 8 4
% &
30 de 154
Ejemplos de declaracin de variables son: Dim X as integer Dim X as byte Dim X as double, Y as string La declaracin de variables en las versiones de Visual Basic se hacen locales a Objetos, generales a Formas o Globales a Proyectos. Las variables globales comparten variables entre formas diferentes que contenga el proyecto. En las dems versiones de Basic anteriores se declaran generales a todo el programa que se desarrolle. En Matlab se manejan casi los mismo datos que manejan en el lenguaje c. Para saber que tipo de formato vasta simplemente con digitar en el prompt del MatLab la instruccin help format y enter (). Se mostrar una pantalla con informacin sobre formatos utilizados en MatLab. help format FORMAT Set output format. All computations in MATLAB are done in double precision. FORMAT puede ser usado para escoger entre diferentes formatos de salida como sigue; Por defecto, es lo mismo que short. SHORT formato de punto fijo con 5 dgitos. ans = 3.1416 LONG formato de punto fijo con 15 digitos. ans = 3.14159265358979 SHORT E formato de punto flotante con 5 dgitos. ans = 3.1416e+000 LONG E formato de punto flotante con 15 dgitos ans = 3.141592653589793e+000 SHORT G Best of fixed or floating point format con 5 digitos. ans = 3.1416 LONG G Best of fixed or floating point format con 15 digitos. ans = 3.14159265358979 HEX formato Hexadecimal ans = 400921fb54442d18 + los smbolos +, - y blank son impresos para elementos positivos, negativos y zero. Partes imaginarias son ignoradas. FORMAT BANK formato fijo para dolares y centavos. FORMAT FORMAT pi FORMAT pi FORMAT pi FORMAT pi FORMAT pi FORMAT pi FORMAT pi FORMAT
31 de 154
pi ans = 3.14 FORMAT RAT Approximation by ratio of small integers. pi ans = 355/113 El format RAT da el fraccionario mas aproximado al valor expuesto. En este caso el valor de PI. No olvide que a pesar de que ac se escribe en maysculas cuando use el MatLab deber escribir las funciones en minscula. Spacing: FORMAT COMPACT Suppress extra line-feeds. FORMAT LOOSE Puts the extra line-feeds back in.
32 de 154
ALGORITMOS Y PROGRAMAS
La principal razn para que las personas aprendan lenguajes de programacin es utilizar la computadora como una herramienta para la resolucin de problemas. Dos fases pueden ser identificadas en este proceso. 1. Fase de resolucin del problema 2. Fase de implementacin en una microcomputadora El resultado de la primera fase es el diseo de un algoritmo para resolver el problema. Un algoritmo se puede considerar como el conjunto de instrucciones que conducen a la solucin de un problema determinado. Dichas instrucciones deben tener una secuencia lgica para poder llegar a la solucin real. El algoritmo se puede expresar de diversas maneras. Mediante smbolos, utilizando un lenguaje determinado para hablar la solucin, describir sintticamente dicha solucin o simplemente escribindolo en cualquier cdigo valido para algn lenguaje de programacin. La ltima forma de describir el algoritmo es a lo que se le denomina PROGRAMA. DISEO DE PROGRAMAS: El diseo de programas no es tarea difcil. Un programa se construye teniendo en cuenta dos cosas que me facilitan cualquier lenguaje de programacin: Las Estructuras de Programacin y las Estructuras de Datos. La utilizacin eficiente de cada una de las estructuras antes mencionadas permiten dar solucin a cualquier problema que se desee resolver. En este libro se tratar con profundidad las estructuras de programacin y se utilizara algunas estructuras de datos que sean necesarias para la solucin de los ejemplos que se resuelvan. (Bsicamente tienen que ver con variables simples y arreglos) En la fase de resolucin de cada uno de los ejemplos se incluyen etapas as: 1. Anlisis del problema 2. Diseo del algoritmo Diagrama de flujo Seudo lenguaje Cdigo Pascal Lenguaje C++ 3. Verificacin o prueba de escritorio
33 de 154
DIAGRAMAS DE FLUJO Un diagrama de flujo es un dibujo que utiliza smbolos estndar de diagramacin de algoritmos para computador, en el que cada paso del algoritmo se visualiza dentro del smbolo adecuado y el orden en que estos pasos se ejecutan. Se indica su secuencia conectndolos con flechas llamadas lneas de flujo porque indican el flujo lgico del algoritmo. En esencia el diagrama de flujo es un medio de Presentacin visual y grfica de flujo de datos, a travs de un algoritmo, las operaciones ejecutadas dentro del sistema y la secuencia en que se ejecutan. Los smbolos utilizados en los diagramas han sido normalizados por las organizaciones ANSI (American National Institute) y por ISO (International Standard Organization) aunque el uso de esos Estndar es voluntario.
34 de 154
SMBOLOS UTILIZADOS EN LA CONSTRUCCIN DE DIAGRAMAS DE FLUJO
Para iniciar y Terminar un algoritmo
Para representar un proceso
Para toma de decisiones: Smbolo utilizado tanto en decisiones como en estructuras cclicas Para representar entrada de datos
Para representar salidas de datos
Indican la direccin de flujo en un diagrama, adems conecta todos los smbolos del diagrama
Conector entre diagramas Conector dentro de un diagrama
35 de 154
REGLAS DE PROGRAMACIN: Desde que las ideas de Knuth, Dijkstra y Wirth fueron consolidadas en el campo informtico, las reglas para la construccin de algoritmos han ido variando constantemente y de igual forma los lenguajes de programacin, en general se han ido adaptando a estos reglas o tcnicas de programacin. Las reglas que se deben considerar en una buena programacin son:
Disear algoritmos en etapas yendo de lo general a lo particular (mtodo descendente) Dividir el algoritmo en partes independientes -mdulos- y tratar cada mdulo independientemente. 3. Establecer y utilizar la solucin de problemas tcnicas de programacin estructuradas Dar especial importancia a las estructuras de datos Describir completamente cada algoritmo Verificar o realizar la prueba de escritorio a cada algoritmo desarrollado. 1. 2.
4. 5. 6.
Un programa puede ser considerado como el conjunto de Estructuras de datos mas el conjunto de Estructuras de programacin ms el Encabezado que exige cada lenguaje en particular. PROGRAMACIN ESTRUCTURADA La programacin estructurada es el conjunto de tcnicas para desarrollar programas fciles de escribir, verificar, leer y mantener Se puede concretar mas la definicin diciendo que la programacin estructurada es el conjunto de tcnicas que incluye: Un nmero limitado de estructuras de programacin Diseo descendente Descomposicin modular con independencia de los mdulos puede ser
El teorema de Bohm y Jacopini establece que un programa propio escrito utilizando solo tres tipos de estructuras de control: Secuencial Selectiva Repetitiva
Hoy me atrevera a decir que un programa propio puede ser escrito utilizando lo siguiente:
36 de 154
Declaraciones: Libreras de inclusin Declaracin de funciones y/o procedimientos Definicin de constantes y/o variables Estructuras de programacin: Asignacin Decisin Cclicas De seleccin mltiple Estructuras de datos: Estticas simples Dinmicas Registros Arreglos Archivos Funciones: Predefinidas por el lenguaje Definidas por el usuario. Generalmente cuando el algoritmo o solucin de un problema determinado se deja en trminos de diagrama de flujo, Seudo lenguaje e incluso en Seudo cdigo se puede trabajar nicamente con estructuras de programacin.
37 de 154
ESTRUCTURAS DE PROGRAMACIN
Tambin llamadas estructuras de control por algunos autores. Son aquellas que le permiten a un usuario ejecutar tareas que a la final le permiten dar solucin a problemas que se quieran resolver usando microcomputadoras. En general se puede decir que las estructuras de programacin son herramientas que el lenguaje le provee al usuario para solucionar problemas haciendo uso de computadoras. Las estructuras de programacin que tienen la mayora de los lenguajes son cuatro as: Estructuras Estructuras Estructuras Estructuras de Asignacin de Decisin Cclicas de Seleccin mltiple.
ESTRUCTURA DE ASIGNACIN
Esta estructura se conoce tambin como sentencia en algunos lenguajes estructurados. Las estructuras de asignacin, son utilizadas en el cuerpo de programa, procedimientos esclavos o funciones. Una estructura de este tipo consiste en la asignacin de una expresin a un identificador (comnmente llamado variable) vlido en un lenguaje de programacin. La parte de esta estructura solamente puede estar ocupada por una variable. Toda variable, literal o constante aparecer formando la expresin al lado derecho. Variable = Expresin Expresiones simples La expresin ms simple consiste en un solo concepto: una simple variable, constante literal, constante numrica o constante simblica.
38 de 154
PI '20' 20 I
Constante simblica definida por algunos lenguajes. Constante literal definida por el usuario. Constante numrica definida por el usuario. Variable definida de algn tipo ofrecido por los lenguajes.
Expresiones complejas Las complejas consisten en expresiones simples conectadas o relacionadas con operadores bien sean matemticos o relacionales. Ejemplos: A+B (A + B) * (C + B) Operadores Un operador es un smbolo que le da instrucciones al lenguaje de programacin para que ejecute alguna operacin, o accin, en uno o ms operandos. Un operando es algo sobre lo cual acta un operador (podra considerarse como una expresin) El operador de asignacin Permite evaluar una expresin y calculado su valor guardarlo en una posicin de memoria asignando dicho valor al nombre de una variable. Dicho de otra manera, el valor calculado de la expresin queda referenciado a la variable a la cual se le asigna. La forma general de uso es: Lenguaje C Variable = Expresin lenguaje C X=Y Lenguaje Pascal Variable:= Expresin versiones de Pascal. X := Y
En un programa codificado en algn lenguaje, la estructura de asignacin del ejemplo anterior no significa que X es igual a Y. En cambio significa "asigne el valor de Y a X".
39 de 154
En cualquier lenguaje de programacin el lado derecho representa cualquier expresin y el lado izquierdo debe ser un nombre de variable declarado previamente y valido en el lenguaje de programacin. Operadores matemticos La mayora de los lenguajes utilizan cuatro operadores matemticos a saber: Operador Suma Resta Multiplica cin Divisin
Smb olo
Accin Suma dos operandos Resta el segundo operando del primero Multiplica sus dos operandos Divide el primer operando entre el segundo
+ * /
Ejempl o X+Y X-Y X*Y X/Y
Cada lenguaje en particular involucra otra serie de operadores tales como: Basic: ^ : Exponenciacin
Lenguaje C: Operadores Unarios: ++ -: Incremento en uno : Decremento en uno
Operador matemtico % : Mdulo: Toma la parte residuo de una divisin: Ej: Si se divide 11 entre 4 da de resultado 2 y sobra de residuo 3. Si se hace X=11%3 entonces X toma el valor residuo de 3.
Lenguaje pascal Mod Div : Para tomar la parte residual de una divisin. Similar al % del C. : Para tomar la parte entera de una divisin.
40 de 154
El operador sizeof Adems de los operadores citados, comunes a otros lenguajes de programacin, C utiliza tambin, el operador sizeof(), que le permitir conocer la longitud, en bytes, que un tipo de dato ocupa en memoria. As, por ejemplo; sizeof(variable) Devolver 2 si la variable ha sido definida de tipo entera (int), 4 si la variable ha sido declarada de tipo real (float) y as sucesivamente para todos los tipos manejados por C. El valor devuelto por sizeof() depende del compilador utilizado; no obstante, este operador que se puede utilizar con variables predefinidas por el sistema o definidas por el usuario, asegura la portabilidad del programa entre sistemas. Anlogamente: sizeof(tipodedato) Retornar un valor que corresponder al espacio reservado por el compilador para el tipo de dato especificado en el momento de compilar el programa. Asi: sizeof(float) Devolver 4 que, como se puede observar en la tabla de tipo de datos, el valor corresponde al nmero de bytes que se reservan en memoria para cada variable que se declare del tipo de dato float. Operadores al nivel de bits El lenguaje C se diseo para sustituir en muchos trabajos al lenguaje ensamblador. Por ello, soporta un juego completo de operadores capaz de manejar los datos al nivel de bits.
Las operaciones al nivel de bits soportan solamente los datos de tipo caracter (char) y entero (int) con sus variantes. Son los siguientes: & | AND binario OR binario (ascii 124)
41 de 154
^ XOR binario (ascii 94) ~ NOT binario (tilde, ascii 126) >> desplazamiento de bits a derecha << desplazamiento de bits a izquierdas Los operadores AND OR y NOT se comportan igual que los anteriormente definidos pero al nivel de bits. La tabla de verdad de estos operadores es la siguiente. X 0 0 1 1 Y 0 1 1 0 X&Y 0 0 1 0 X/Y 0 1 1 1 X^Y 0 1 0 1 ~X 1 1 0 0
Los operadores de desplazamiento de bits mueven todos los bits de una variable a la izquierda o a la derecha un nmero fijo de posiciones segn se especifique. Los formatos de estas instrucciones son los siguientes: NombreVariable>> NumeroPosicionesDerecha Precedencia de operadores En una expresin que contiene mas de un operador aritmtico diferente el computador evala dicha expresin de acuerdo a la siguiente jerarqua de operadores. = +/ * % mod div Negacin(-), ++, - Exponenciacin Jerarqua ms baja
Jerarqua ms alta
La tabla anterior indica que la primera operacin aritmtica que realiza, sera la exponenciacin, luego la operacin de negacin y las operaciones unarias del lenguaje C, luego la multiplicacin y/o la divisin, luego las sumas y las restas y por ltimo la asignacin quien tiene la jerarqua mas baja, es decir que seria la ultima operacin que realizara la computadora. Cuando en una expresin existe operadores de igual jerarqua la computadora los resuelve de izquierda a derecha. Si la expresin contiene agrupadores (o sea
42 de 154
parntesis) el destruye primero los parntesis resolviendo lo que est dentro de el y luego seguir resolviendo las operaciones de acuerdo a lo descrito anteriormente. Ejemplo: X=3
La expresin anterior es sencilla. Consta tan solo de una variable X definida de un tipo entero y una expresin constante igual a tres. En el ejemplo anterior se tiene un solo operador, por tanto el microprocesador asigna el valor de 3 a la variable X. Visto simblicamente se puede representar en un rbol de la siguiente manera = X Ce 3
I De z Para tener una mejor idea del orden en que efecta cada una de las operaciones en una estructura de asignacin es necesario identificar el tipo de notacin con la cual trabaja el microprocesador. Notacin infija: Es la notacin con la cual escribimos todas las expresiones. En esta notacin los operadores estn entre los operandos Si se realiza el recorrido en el rbol del ejemplo anterior se puede decir que la expresin estara escrita en notacin infija haciendo el siguiente recorrido: Iz - Ce - De o sea X = 3 Notacin postfija: Es la notacin que utiliza el microprocesador para resolver todas las expresiones que se asignen a una variable en una estructura de asignacin o simplemente al solucionar una expresin. En esta notacin los operadores estas despus de los operandos. Si se realiza el recorrido en el rbol del ejemplo anterior se puede decir que la expresin estara escrita en notacin postfija haciendo el siguiente recorrido:
43 de 154
Ejemplo: X=3+5
Iz - De- Ce o sea X 3 = (Expresin en notacin Postfija)
La expresin anterior consta de dos partes. Una variable X a la cual se le asignar (=) la expresin de la derecha. Antes de asignar un valor a la variable X el computador tendr que resolver dicha expresin (3 + 5).
En el ejemplo anterior el microprocesador ejecuta primero la suma y el resultado lo asigna por ultimo a la variable X.
Visto simblicamente, la estructura de asignacin se puede representar en un rbol de la siguiente manera = X +
Si la expresin de la derecha, o sea 3+5 se hace igual a W. +

W
= 3 5
Se puede representar el rbol del ejemplo de la siguiente manera: = X W Si se expresa el anterior rbol en notacin infija se tendr: X= W Si se representa en notacin postfija se tendr : XW=
44 de 154
Quiere decir lo anterior que primero se resolver la expresin W y luego se asignar el valor encontrado en dicha evaluacin a la variable X. Ahora si se resuelve el rbol de la expresin se tendr: Notacin infija W=3+5 Notacin postfija W=35+
Tomando toda la expresin se tendr entonces: Notacin infija X=3+5 Notacin postfija X35+=
Observando la ltima expresin, se notar que el microprocesador evaluar en notacin postfija la estructura de asignacin y los operadores los ejecuta de izquierda a derecha operando los dos operandos inmediatamente anteriores, o sea que sumar 3 y 5 y dicho valor (8), lo asignar a X.
Ejemplo: Si se tiene la expresin X = A + B / C * E + F / G * H y se asigna al identificador W la expresin A + B / C * E + F / G * H, la estructura de asignacin se puede representar de la siguiente manera: = X W
En la expresin W = A + B / C * E + F / G * H, se tienen varios operadores repetidos, caso particular la suma (+) que est presente dos veces. Si al identificador Y se le asigna la expresin B / C * E "(Y=B/C*E)" y al identificador Z se le asigna la expresin F / G * H "Z=F/G*H", la expresin inicial puede escribirse entonces de la siguiente manera. X=A+Y+Z
Tenga en cuenta que si hay operadores de igual jerarqua el microprocesador los resuelve de izquierda a derecha.
Al representar esta expresin en un rbol se tendr lo siguiente: = X + A Y + Z 45 de 154
Si se hace el recorrido en notacin postfija al rbol que representa la expresin anterior quedar de la siguiente manera: X A Y+Z+= En el rbol anterior se puede observar que las operaciones se realizan de abajo hacia arriba o sea que primero se realiza la suma de A con Y. A este resultado se le suma el valor de Z y por ltimo se asigna dicho valor a la variable X. Donde Y y Z representan las expresiones: Y=B/C*E Z=F/G*H
Si se involucran las expresiones Y y Z definidas anteriormente, el rbol quedar de la siguiente manera:
= X +
+ A * /
* H
Si se hace el recorrido al rbol en notacin postfija, la expresin quedar de la E / F G siguiente manera: X A B C / E * + F G / H * + = B C
46 de 154
Para pasar de notacin infija a notacin postfija, la mquina utiliza la teora de colas para dicho trabajo. Se utiliza para tal efecto las listas de pila y cola. Las pilas es la teora de manejo de datos en donde el ltimo dato que ingresa a la lista, es el primer dato que sale de ella (Last In First Out - LIFO) y las colas es la teora de manejo de informacin en donde el primer dato en entrar, es el primer dato en salir. (First In First Out - FIFO). Teniendo en cuenta lo anterior se trabajar de la siguiente manera para realizar el traslado de una expresin en notacin infija a notacin postfija. Cada uno de los operandos y operadores se van almacenando en un a lista de cola de entrada (LIFO). Una vez los datos ah entonces se empiezan a pasar cada uno de los trminos as: Cada operando pasar directamente a la cola de salida y cada operador pasa a una pila de espera de operadores. Hay que tener en cuenta que cuando un operador llega a la pila de operadores, dicho operador desplaza a la cola de salida todos aquellos operadores que sean de igual o mayor jerarqua. "Ver jerarqua de operadores".
Todo operador debe esperar en la pila de operadores, es decir el operador que llega de la lista de cola de entrada, necesariamente debe esperar en la lista de pila de operadores.
Retomando el ejemplo anterior se tendr lo siguiente: Lista de cola de ENTRADA (FIFO) X = A + B / C * E + F / G * H Cab Cola
Los identificadores "Cab" y "Cola" indican los elementos que se encuentran en la Cabeza "primer elemento en entrar" y Cola "ltimo elemento en entrar" respectivamente de la Lista de cola en referencia. En el caso de la Lista de Pila el elemento que se encuentra listo a salir "ltimo en entrar" ser apuntado por el identificador Tope.
En teora de Colas el elemento que est en la cabeza, fue el primer elemento en entrar a la lista y el elemento que est en la cola, fue el ltimo elemento que entr en dicha lista. Si se pasan los dos primeros elementos de la lista de entrada, es decir el operando "X" a la lista de cola de salida y el operador "=" a la lista de pila de espera de operadores, las listas quedarn as:
47 de 154
Lista de cola de ENTRADA (FIFO) A + B / C * E + F / G * H Cab Pila de espera (LIFO) = TOPE Lista de cola de SALIDA (FIFO) X Cab Cola Cola
Para este primer paso, el operando "X" pas directamente a la cola de salida. En estos momentos por ser el nico elemento que existe en la lista de cola de salida, es considerado como cabeza y cola de la misma. Y el operador "=" paso a la pila de espera (es de anotar nuevamente que todo operador debe hacer espera en la pila de operadores). Un segundo par de elementos de la cola de entrada sern enviados a la cola y pila de salida as: " A +" Lista de cola de ENTRADA (FIFO) B / C * E + F / G * H Cab Pila de espera + = TOPE El operador (+) que lleg a la pila de espera de operadores, no desplaz el operador "=" que estaba en el tope de la pila, porque dicho operador "=" es de menor jerarqua que el operador "+". Cola : :
48 de 154
Lista de cola de SALIDA (LIFO)
: X Cab
A Cola
Observando lo anterior, en la cola de salida hay dos operandos "X A" y en la pila de espera dos operadores "+ =". Un tercer par de elementos de la cola de entrada sern enviados a la cola y pila de salida as: "B /" Lista de cola de ENTRADA (FIFO) : C * E + F / G * H Cab Pila de espera : / + = TOPE El operador que lleg a la pila de espera no desplaza ningn operador de ella ya que los que se encuentran a la espera son de menor jerarqua. Lista de cola de SALIDA (LIFO) : X A B Cab Cola Cola
Un cuarto par de elementos de la cola de entrada sern enviados a la cola y pila de salida as: Lista de cola de ENTRADA (FIFO) Pila de espera :E + F / G * H Cab :* + = TOPE Lista de cola de SALIDA (LIFO) :X A B C / Cab Cola Cola
Al llegar a la pila de espera el operador (*) desplaza a la cola de salida al operador (/) que se encontraba en el tope de la pila porque es de igual jerarqua.
49 de 154
Un quinto par de elementos de la cola de entrada sern enviados a la cola y pila de salida as: Lista de cola de ENTRADA (FIFO) :F / G * H Cab Pila de espera :+ = TOPE Lista de cola de SALIDA (LIFO) : X A B C / E * + Cab Cola Cola
Al pasar de la cola de entrada el operador "+" a la pila de espera, este desplaza a la cola de salida los operadores "*" y "+" que se encuentran en el tope de la pila ya que son de mayor e igual jerarqua respectivamente. Primero desplazar el operador "*" y por ltimo desplaza al operador "+". Si se contina pasando par de elementos hacia las respectivas listas se tendr lo siguiente: Lista de cola de ENTRADA (FIFO) Pila de espera :G * H Cab Cola :/ + = TOPE Lista de cola de SALIDA (LIFO) :X A B C / E * + F Cab Cola
El operador (/) pas a la pila de espera. El no desplaza ningn operador porque el que est en el tope de la pila es de menor jerarqua. Lista de cola de ENTRADA (FIFO) :H Cab Cola
50 de 154
Pila de espera
:* + = TOPE
Lista de cola de SALIDA (LIFO)
: X A B C / E * + F G / Cab Cola
Ahora nos queda tan solo un operando en la lista de cola de entrada. Al pasar a la cola de salida y quedar vaca la lista de cola de entrada, se procede a vaciar la lista de pila de operadores en su orden. primero saldrn los ltimos que entraron as: Lista de cola de SALIDA (LIFO) : X A B C / E * + F G / H * + = Cab Cola
51 de 154
PLANTEAMIENTOS Y EJECUCIN DE PROGRAMAS

Cuando se inicia en el fascinante mundo de la programacin de computadoras, es necesario a la hora de construir algoritmos primero que todo intentar plantear al nivel de smbolos dicha solucin. A la construccin con los smbolos indicados es a lo que se conoce con el nombre de Diagrama de flujo. Recuerde que un algoritmo es la secuencia lgica de pasos que se sigue en la solucin de un problema determinado. En los siguientes ejercicios se ver la forma de aplicar la simbologa de los diagramas de flujo en la solucin de problemas de tipo matemtico sencillos. Aunque parezcan sencillos es una manera de adentrar un poco en el conocimiento de la diagramacin estructurada. En dichos ejercicios se utilizarn funciones que permitan la entrada de datos por el teclado como medio estndar de entrada de datos de la mquina y funciones que me permitan manejar la pantalla como medio de salida mas utilizado en las computadoras para presentar informacin. Adicional a las funciones de entrada y salidas de datos se utilizar la Estructura de asignacin en la solucin de pequeas expresiones de tipo matemtico. En los siguientes ejercicios se realiza el diseo de algoritmos al nivel de diagrama de flujo, Seudo lenguaje, Seudo cdigo y Cdigo en el lenguaje Pascal y C, que dan solucin a cada una de las preguntas planteadas. 1. Desarrolle un algoritmo que le permita leer dos valores y escribir la suma de los dos. Anlisis: Para dar solucin a este ejercicio es necesario realizar tres tareas: Leer los valores que para el caso concreto del ejemplo son dos (2), Calcular la suma de dichos valores y por ltimo escribir el resultado obtenido de dicha suma. Cada una de las tareas planteadas se enmarcan dentro de un smbolo utilizado en diagramacin as: La lectura de cada dato desde el teclado se almacenar en variables, una guardar el primer valor que para el desarrollo se ha identificado con el nombre A y la otra el guardar el segundo valor que se ha denominado o identificado con el nombre B (estas operaciones se representarn en el smbolo de lectura. Tambin se puede representar cada operacin en smbolos aparte).
52 de 154
El clculo de la suma se realizar y su valor ser almacenado en la variable identificada como C (esta operacin se representar en el smbolo de proceso) y por ltimo el valor de respuesta almacenado en la variable C, se escribir en la pantalla (esta operacin se representa en el smbolo de escritura). Vea el diagrama siguiente. Diagrama de Flujo
INICIO A,B C=A+B C
Seudo lenguaje
Inicio Leer un valor y guardarlo en A y leer un segundo valor y guardarlo en B Realizar la suma de A con B y guardar su valor en la variable C Escribir el valor de C Fin
FIN
Seudo cdigo Inicio Leer(A,B) C=A+B Escribir(C) Fin

Cdigo Turbo Pascal: Program cuadrado; Uses crt; N,R:real; Begin Clrscr; Gotoxy(10,10); Write("Digite un nmero entero A "); Readln(A); Gotoxy(10,11); Write("Digite un nmero entero B "); Readln(B); C:= A+B; Gotoxy(10,12); Write("La suma es: ",C); Repeat until keypressed; End Cdigo Lenguaje C++: #include "conio.h" #include "stdio.h" int A,B,C; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero entero "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero entero "); scanf("%d",&B); C= A+B; gotoxy(10,12); printf("La suma es: %d ",C); getch() }
53 de 154
En el ejercicio anterior se hubiera podido escribir directamente el valor de la suma sin necesidad de almacenarlo previamente en la variable C utilizando para ello la siguiente sentencia.
Write("La suma es: ",A+B); Repeat until keypressed; gotoxy(10,12); printf("La suma es: %d ",A+B);
Tenga en cuenta que si lo hace de esta manera no estar utilizando estructura de asignacin alguna.
2. Desarrolle un algoritmo que le permita leer un valor entero, calcular su cuadrado y escribir dicho resultado. Anlisis: En el ejercicio planteado, se puede identificar como tareas a realizar, cada una de las tres acciones solicitadas. Leer, Calcular y Escribir. Cada uno de los procesos mencionados se describen en smbolo respectivo quedando el diagrama de flujo de la siguiente manera.
Es necesario aclarar que cada proceso corresponde a una estructura de Asignacin. En el caso del ejercicio el calcular el cuadrado.
Algoritmo: Diagrama de flujo: INICIO N R = N R FIN

Leer el valor nmero entero y almacenarlo en la variable N. Calcula el cuadrado del numero ledo y que est almacenado en la variable N, y su resultado almacenarlo en la variable R. Escriba el valor encontrado del cuadrado que esta almacenado en la variable R. Fin
Seudo lenguaje:
Inicio
54 de 154
Seudo cdigo:
Inicio Fin
Cdigo Turbo Pascal: Program cuadrado; Uses crt; N,R:real; Begin Clrscr; Gotoxy(10,10); Write("Digite un nmero entero N"); Readln(N); R=exp(2*ln(N)); Gotoxy(10,12); Write("El cuadrado del numero es: ",R); Repeat until keypressed; End Cdigo Lenguaje C++: #include "math.h" #include "conio.h" #include "stdio.h" int N,R; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero entero N"); scanf("%d",&N); R=pow(N,2); gotoxy(10,12); printf("El cuadrado es: %d ",R); getch() }
Leer( N);
R = N;
Escribir (R)
3. Desarrolle un algoritmo que le permita leer un valor para radio (R), calcular el rea (A) de un crculo A = R y escribir su valor.
Anlisis: En el ejercicio se identifican como tareas las tres acciones solicitadas. Leer, Calcular y Escribir. Cada uno de los procesos mencionados se describen en el smbolo respectivo quedando el diagrama de flujo de la siguiente manera.
Algunos lenguajes de programacin traen incorporada una constante con el valor del nmero pi "3.1415...". Dicha constante es PI. Para utilizarla simplemente se hace referencia a ella.
Algoritmo: Diagrama de flujo:

INICIO R A = *R
Seudo lenguaje:
Inicio Leer el valor del radio y guardarlo en la variable R Calcular el valor del rea aplicando la formula *R y almacenar dicho valor en la variable A Escribir el valor encontrado para el rea guardado en la variable A. Fin
A
FIN
55 de 154
Seudo cdigo: Inicio Leer( R) A = *R Escribir (A) Finalizar

Cdigo Turbo Pascal: Program rea; Uses crt; Const pi=3.1415926; R,A:real; Begin Clrscr; Gotoxy(10,10); Write("Digite el valor de Radio R"); Readln(R); A = pi*exp(2*ln(R)); Gotoxy(10,12); Write("El valor del rea es: ",A); Repeat until keypressed; End. Cdigo Lenguaje C++: #include "math.h" #include "conio.h" #include "stdio.h" float R, A; main() { clrscr(); gotoxy(10,10); printf("Digite el Radio R"); scanf("%f",&R); A = pi*pow(R,2); gotoxy(10,12); printf("El rea es: %f ", A); getch(); }
4. Determinar la hipotenusa de un tringulo rectngulo conocidas las longitudes de sus dos catetos. Desarrolle los correspondientes algoritmos. Anlisis:
En el ejercicio se puede definir como tareas las tres acciones solicitadas. "Leer, Calcular y Escribir", Leer cada uno de los valores de los dos catetos y almacenarlos en cada uno de los identificadores definidos para el caso, calcular la hipotenusa aplicando la frmula correspondiente almacenando su valor en el identificador del caso y escribir el valor encontrado para la hipotenusa como respuesta. Cada una de las acciones se describen dentro del smbolo respectivo, quedando el diagrama de flujo de la siguiente manera.
Algoritmo: Cuando se requiere desarrollar operaciones matemticas tanto en el diagrama de flujo como en el Seudo lenguaje se dejan planteadas tal y cual como se escriben normalmente de manera simblica. En el momento de codificar dicho algoritmo se traduce el smbolo a la funcin correspondiente en el lenguaje.
Caso especfico del ejemplo anterior la raz cuadrada en cdigo es sqrt y el smbolo es el que conocemos " .
56 de 154
Para el desarrollo del siguiente ejercicio se trabajar con las siguientes variables: CatA : Cateto del triangulo CatB : Cateto del triangulo Hip : Hipotenusa del triangulo Diagrama de flujo
INICIO CatA, CatB
Seudo lenguaje
Inicio Leer el valor de cada cateto y almacenarlo en la variable CatA y CatB Calcular el valor de Hip con la formula indicada Escribir el valor de la Hip Fin
Hip = CatA 2 + CatB 2

Hip
FIN
Seudo cdigo En el seudo cdigo se dejan planteadas las operaciones tal y cual se hizo en el diagrama de flujo o en el seudo lenguaje. Inicio Leer(CatA,CatB) HIP = CatA 2 + CatB 2 Escribir(Hip) Fin
Cdigo Turbo Pascal: "programa que calcula el rea de un tringulo rectngulo conociendo el valor de sus catetos." Program rea; Uses crt; CatA,CatB,HIP:real; Begin clrscr; gotoxy(10,10); Write("Digite el valor CatetoA"); Readln(CatA); gotoxy(10,12) Write("Digite el valor CatetoB"); Readln(CatB); Hip= sqrt (exp(2 * ln( CatA)) + exp( 2 * ln( CatB ))) Gotoxy(10,14); Write("El valor HIPOTENUSA= ",HIP); Repeat until keypressed; End.
57 de 154
Cdigo Lenguaje C++: /* Programa que calcula el valor del rea de un tringulo rectngulo conociendo sus catetos */ #include "math.h" #include "conio.h" #include "stdio.h" float CatA,CatB,HIP; main() { clrscr(); gotoxy(10,10); printf("Digite el valor CatetoA"); scanf(&CatA); gotoxy(10,12); printf("Digite el valor CatetoB"); scanf(&CatB);
HIP = sqrt ( pow(CatA,2) + pow(CatB,2 ))
gotoxy(10,14); printf("El valor de HIPOTENUSA=%f",HIP); getch(); }
Para digitarlo en MatLab es necesario guardar el siguiente cdigo en el directorio Work de MatLab y ejecutarlo desde el prompt del MatLab digitando solo el nombre con el cual fue guardado. cata=input('Digite el valor Cateto A : '); catb=input('Digite el valor Cateto B : '); hip=sqrt(cata^2+catb^2); fprintf('El valor de HIPOTENUSA = %f \n',hip); Nota: Para el caso de MatLab no es necesario declarar la librera matemtica porque se supone que el ya la tiene. Si necesita ayuda en el prompt digite help sqrt o help sym/sqrt.m 5. Desarrolle un algoritmo que le permita leer un valor que represente una temperatura expresada en grados Celcius y convierta dicho valor en un valor expresado en grados Fahrenheit. Anlisis: Tareas: Leer la temperatura en grados Celcius Calcular la conversin a grados Fahrenheit Escribir el valor encontrado
En el ejercicio planteado, las tareas a realizar son: Leer, convertir y Escribir.
58 de 154
Algoritmo: Diagrama de flujo

INICIO
Seudo lenguaje
Inicio Leer los grados centgrados y almacenarlos en la variable c Asignar a la variable f la conversin de grados centgrados a Fahrenheit dado por la frmula 9/5c+32 Escribir el valor de la variable f Fin
C
F = 9/5C + 32 F
FIN
Seudo cdigo Inicio Leer(C) F = 9/5*C + 32 Escribir(F) Fin

Al momento de definir el tipo de variables a utilizar, hay que tener en cuenta que en lenguaje C cuando se divide dos variables de tipo entero el resultado igualmente ser del tipo entero.
Cdigo Turbo Pascal: Program convertir; Uses crt; C,F:real; Begin clrscr; gotoxy(10,10); write("Digite el valor expresado en Grados C"); readln(C); F = C*9/5+32; gotoxy(10,12); write("El valor en grados farenheit es : ",F); repeat until keypressed; End.
59 de 154
/* Cdigo Lenguaje C: */ #include "conio.h" #include "stdio.h" float c, f; main() { clrscr(); gotoxy(10,10); printf("Digite el valor expresado en Grados C"); scanf("%f",&c); f= c*9/5+32; gotoxy(10,12); printf("El valor en grados Farenheith es: %f ", f); getch(); }
Bajo MatLab, guarda el siguiente cdigo en un archivo y lo llama desde el prompt del MatLab. C = input('Digite el valor expresado en Grados C : '); f = c*9/5+32; fprintf('El valor en grados Farenheith es : %8.3f\n', f); Nota: El formato 8.3f indica se utilizarn 8 espacios para escr5ibir el valor de la variable f, y de los ocho espacios se utilizan 3 campos para los decimales. El \n indica que cuando termine salte el prompt a una nueva lnea (New Line). Si se omite la instruccin \n entonces el prompt quedara unido a la ltimo digito escrito del valor f. 6. Desarrolle un algoritmo que le permita calcular el rea de un tringulo en funcin de las longitudes de sus lados previamente ledos desde el teclado. Anlisis: Para darle solucin al problema planteado primero se leen los valores de los tres lados del tringulo, luego se procede a calcular el valor de su rea en funcin de los valores ledos, aplicando la frmula correspondiente y por ltimo se da orden de escribir el valor calculado. Tareas: Leer los lados Calcular el rea Escribir el valor calculado
60 de 154

INICIO
Seudo Lenguaje
Inicio Leer(a,b,c) Hacer p=(A+B+C)/2 Calcular el valor del rea dada por la frmula Escribir (a) Fin
Cdigo Lenguaje C++: #include "conio.h" #include "stdio.h" float A,B,C,AREA,p; main() { clrscr(); gotoxy(10,10); printf("Digite el valor de A"); Scanf(&A); gotoxy(10,12) printf("Digite el valor de B"); Scanf(&B); gotoxy(10,14) printf("Digite el valor de C"); Scanf(&C); p=(A+B+C)/2 AREA=
A,B, p= (A+B+C)/2 AREA= p(p-A)(p-B)(p-C) A

FIN
Cdigo Turbo Pascal: Program Area; Uses crt; A,B,C,AREA,p : real; Begin clrscr; gotoxy(10,10); write("Digite el valor de A"); readln(A); gotoxy(10,12) write("Digite el valor de B"); readln(B); gotoxy(10,14) write("Digite el valor de C"); readln(C); p=(A+B+C)/2 AREA:= sqrt ( p * ( p
A) * ( p B) * ( p C ))
gotoxy(10,16); write("El valor del rea es : ",AREA); repeat until keypressed; End. }
sqrt ( p * ( p A) * ( p B) * ( p C ))
gotoxy(10,16); printf("El valor del rea es: %f ", AREA); getch();
En MAtLab se guardar las siguientes lineas en un archivo y luego se llama para ser ejecutado. A = input('Digite el cateto a : '); b = input('Digite el cateto b : '); c = input('Digite el cateto c : '); p = (a+b+c)/2; area = sqrt(p*(p-a)*(p-b)*(p-c)); fprintf('El valor del rea es : %8.3f\n', area);
61 de 154
7. Desarrolle un algoritmo que le permita determinar el rea y volumen de un cilindro cuyo radio (R) y altura (H) se leen desde teclado. Anlisis:
Para dar solucin al ejercicio planteado es necesario leer el valor del radio y el valor de la altura del cilindro desde algn medio de entrada de datos a la computadora, generalmente el teclado. Una vez se tengan almacenados los dos valores en memoria del computador se procede a calcular el rea y el volumen aplicando las frmulas respectivas.
Tareas: Iniciar Leer valores de R y H Calcular el volumen y rea Escribir los valores respectivos Finalizar Algoritmo: Diagrama de flujo
INICIO R,H
Seudo lenguaje
Inicio Leer el valor de Radio (R) y Altura (H) Calcular el Volumen aplicando la frmula
VOL= * R H
AREA= 2* R H
AREA,VOL FIN
Calcular el valor del rea aplicando la frmula respectiva Escribir el valor del rea y del Volumen Finalizar
Seudo cdigo Inicio Leer(R, H) VOL= *RH AREA= 2* *RH Escribir(AREA, VOL) Fin
62 de 154
Cdigo Turbo Pascal: Program Area_Volumen; Uses crt; R,H,AREA,VOL:real; Begin clrscr; gotoxy(10,10); write("Digite el valor de R"); readln(R); gotoxy(10,12) write("Digite el valor de H"); readln(H); VOL := * R*R *H AREA := 2 * * R* H gotoxy(10,16); write("El valor del area es : ",AREA); gotoxy(10,17); write("El valor del Volumen es : ",VOL); repeat until keypressed; End.
Cdigo Lenguaje C++: /* Programa Area_Volumen */ #include "conio.h" #include "math.h" #include "stdio.h" float R,H,AREA,VOL; main() { clrscr(); gotoxy(10,10); printf("Digite el valor de R"); readln(R); gotoxy(10,12) printf("Digite el valor de H"); readln(H); VOL= *pow( R,2)* H AREA= 2 * * R* H gotoxy(10,16); printf("El valor del rea es : %f",AREA); gotoxy(10,17); printf("El valor del volumen es : %f",VOL); getch(); }
Para desarrollarlo en MatLab se graba el siguiente cdigo en un archivo que despus ser ejecutado desde el prompt del MatLab. R = input('Digite el valor de R :'); H = input('Digite el valor de H :'); VOL = pi*R^2*H; AREA = 2*pi*R*H; fprintf('El rea del cilindro es : %f \n',AREA); fprintf('El volumen del cilindro es : %f \n',VOL); Tenga en cuenta de que si declara variables con maysculas se debe usar en el desarrollo con maysculas. La funcin pise puede utilizar as porque MatLab la trae definida. 8. Desarrolle un algoritmo que le permita calculas el rea (A) de un segmento de crculo. Anlisis: Para calcular el rea de un segmento de crculo lo primero que hay que hacer es leer el valor del radio del vinculo y leer el valor de X que es la distancia del centro al segmento. Una vez ledo dichos valores se calcula aplicando la frmula respectiva y por ltimo se escribe el valor del rea. Tareas: Leer (X y r) Calcular (Area) Escribir
63 de 154

INICIO
Seudo lenguaje Inicio Leer el valor de X y r Calcular el valor de rea Escribir el valor de Area (A) Fin
Cdigo Lenguaje C++: /* Programa Area_Segmento_Circular */ #include "conio.h" #include "stdio.h" float R,H,AREA,VOL; main() { clrscr(); gotoxy(10,10); printf("Digite el valor de R "); scanf("%f",&r); gotoxy(10,12) printf("Digite el valor de X "); scanf("%f",&x); A= (* r)/2 [sqrt(r*r x*x)+r*r*asin (x / r)] gotoxy(10,16); printf("El valor del area es : %f",A); gecth(); }
x,r
A= (* r)/2 [x r - x + r Sin-1 (x / r)]
A
FIN
Cdigo Turbo Pascal: Program Area_Segmento_Circular; Uses crt; x,r,A:real; Begin clrscr; gotoxy(10,10); write("Digite el valor de R"); Readln(r); gotoxy(10,12) write("Digite el valor de X"); Readln(x); A= (*r*r)/2 (sqrt(r*r-x*x)+r*r*asin (x / r)) gotoxy(10,16); write("El valor del area es : ",A); repeat until keypressed; End.
Otras salidas literales como salidas con datos numricos reemplazando la funcin "printf" son: printf("El valor del rea es %f",A); cout<<"el valor del rea es"<<A; puts (A); Hay que tener en cuenta que hay que incluir las libreras de estas funciones. Otras formas de entrar datos reemplazando la funcin "scanf" son: scanf("%d",&A); cin>>A; gets(A);
64 de 154
ESTRUCTURA DE DECISIN
Cuando el programador desea especificar dos caminos alternativos en un algoritmo se deben utilizar estructuras de decisin. Una estructura de decisin dirige el flujo de un programa en una cierta direccin, de entre dos posibles, en funcin de un valor booleano. En lenguajes de programacin estructurados la estructura condicional es la IF / ELSE. La clusula ELSE en esta estructura es optativa. La forma en que trabaja esta sentencia resulta casi evidente a partir de la lgica de la lengua inglesa: Si (IF) la expresin booleana resulta cierta (TRUE), entonces la sentencia se ejecuta. Si la expresin booleana resulta falsa (FALSE), el control pasa a la siguiente (en orden descendente) instruccin del programa. Estructura Sencilla: Forma general de uso: Si (Condicin) entonces Ejecuta bloque de instrucciones uno Si_no Ejecuta blo que de instrucciones dos Fin si Si_No
Tarea 2
Entonces
Condicin Tarea 1
Una estructura de decisin por sencilla o compleja que sea debe tener solo una entrada y una salida. (Vea estructura de diagrama anterior). Un bloque de instrucciones (Denominado tarea 1 y 2 en el diagrama anterior) puede ser un conjunto de estructuras de cualquier clase (asignacin, Decisin, Cclicas o de seleccin mltiple) que se ejecutan unas tras de otras. El bloque de instrucciones tarea1 se ejecuta en caso de que la condicin que se coloque sea verdadera, En caso de ser falsa la evaluacin de la condicin se ejecuta el bloque de instrucciones tarea2. Operadores de Relacin: Una condicin tiene que ver directamente con una pregunta. La pregunta se forma mnimo con dos operandos y un operador de relacin.
65 de 154
Para tales efectos los operadores de relacin utilizados en los lenguajes son: Pascal Mayor Menor Mayor o igual Menor o igual Igual Diferente > < >= <= = <> Lenguaje C > < >= <= == !=
As, con base en los operadores de relacin descritos, algunos ejemplos de preguntas o condiciones son: Pascal a>b b>c a=4 b<>c Lenguaje C a>b b>c a==4 b!=c A B A B es es es es mayor que B? mayor que C? igual a 4? diferente de C?
Tambin se pueden desarrollar condiciones con varias preguntas. Para el efecto anterior es necesario plantear las dos preguntas tal como se indic y relacionarlas con operadores lgicos. Operadores Lgicos: Los operadores lgicos utilizados en los lenguajes estructurados son: Pascal y No and or not Lenguaje C && || !=
Con base en lo anteriormente expuesto, las preguntas o condiciones compuestas podran quedar de la siguiente manera. Pascal (a>b) and (b>c) Lenguaje C ((a>b)&&(b>c))
66 de 154
"A es mayor que B y B es mayor que C" (a<b) or (b<c) ((a<b)11(b<c)) "A es menor que B y B es menor que C" Para el lenguaje C Las condiciones es necesario que estn entre parntesis. Estructuras de decisin anidadas:
Si_No Tarea 3
Condicin 1
Entonces Entonces
Tarea 1
Si_No Tarea 2
Condicin 2
Una estructura de decisin puede estar anidada dentro de otra estructura de decisin. Hay que tener en cuenta que el anidamiento sea total. El inicio y el final de la estructura anidada debe quedar totalmente dentro del inicio y el final de la estructura que permite dicho anidamiento. Se debe mantener el concepto que una estructura de decisin debe tener una sola entrada y una sola salida tanto para la estructura que anida como para la estructura anidada. En el diagrama anterior se puede observar una estructura anidada del lado verdadero de la condicin de la primera decisin. Seudo lenguaje de la estructura de decisin anidada. Si (Condicin 1) entonces Si (Condicin 2) entonces Ejecuta bloque de instrucciones tarea 1 Si_no Ejecuta bloque de instrucciones tarea 2
67 de 154
Fin_si Si_no Ejecuta blo que de instrucciones tarea 3 Fin si. En el anterior Seudo lenguaje se puede observar que el anidamiento es total o sea que el inicio de la condicin y el final estn totalmente encajados dentro del lado verdadero de la primera estructura. Ejercicios Aplicando Estructuras de Decisin Para los siguientes ejercicios utilice el siguiente planteamiento 1. Desarrolle un algoritmo que le permita leer un valor cualquiera N y escribir si dicho nmero es par o impar. Anlisis: Para resolver el ejercicio planteado hay que leer primero el valor y almacenarlo en una variable (N). Para saber si el numero es par, la divisin por dos (2) debe ser exacta. Por tanto la decisin si la divisin es exacta o no, la debe tomar el computador usando el smbolo respectivo en el diagrama. (En los diagramas se utilizar el smbolo % para representar el residuo de la divisin de dos operandos, en este caso de la divisin de N y 2). Una vez resuelva la asercin el computador escribir si es par o impar el numero ledo y almacenado en la variable N. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer un numero y almacenarlo en la variable N Si el residuo de dividir a N entre 2 es igual a cero Entonces Escriba que es par Sino Escriba que es impar Fin
No Es impar
N%2=0
Si Es par
FIN
68 de 154
Seudo cdigo Inicio Leer (N) Si (N residuo 2 = 0) entonces Escriba (N es par) Si_no Escriba (N es impar) Fin_si Fin
Cdigo Turbo Pascal: Program par_impar; Uses crt; N: integer; Begin clrscr; gotoxy(10,10); write("Digite un nmero "); readln(N); gotoxy(10,12) if N mod 2 = 0 then write("El numero es par") Esle write("El numero es impar"); repeat until keypressed; End. Cdigo Lenguaje C /* programa para decir si un numero es par o impar */ #include "conio.h" #include "stdio.h" int N; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero "); scanf("%d",&N); gotoxy(10,12); if (N%2==0) printf("el nmero es par"); else printf("el nmero es impar"); getch(); }
Digitado en MatLab, se guarda bajo un nombre de archivo y se ejecuta desde el prompt del MatLab. N = input('Digite un nmero '); if mod(N,2) == 0 fprintf('el nmero es par \n'); else fprintf('el nmero es impar \n'); end
69 de 154
Es importante resaltar la diferencia que existe entre = y ==, el primero para asignar y elsegundo para comparar. En el casodel MatLab la sentencia if se cierra con un end, ya que no trabaja con marcas como lo hace C { y }o Pascal Begin y end. En el caso de C o Pascal omiten las marcas cuando hay una sola instruccin por alguna de las dos opciones. 2. Desarrolle un algoritmo que le permita leer un valor cualquiera N y escribir en la pantalla si dicho nmero es Positivo o Negativo Anlisis: Para resolver el ejercicio planteado hay que leer primero el valor del nmero y almacenarlo en una variable (N). Para saber si dicho nmero es positivo o no, simplemente lo compara con cero. En caso de que sea mayor o igual a cero entonces el nmero ser positivo, y para el caso contrario el nmero ser negativo. Algoritmo: Diagrama de flujo Seudo lenguaje Inicio Leer en nmero y almacenarlo en la variable N Si el nmero es mayor o igual a cero Entonces escriba que es positivo Si no escriba que es negativo Fin
FIN
INICIO
N Si
Es positivo
No
Es negativo
N>=0
Seudo cdigo Inicio Leer(N) Si (N>=0) entonces Escriba("Es positivo") Sino
70 de 154
Escriba("Es negativo") Fin si Fin
Cdigo en Turbo Pascal Program positivo_Negativo; Uses crt; N: integer; Begin clrscr; gotoxy(10,10); write("Digite un nmero "); Readln(N); gotoxy(10,12) if N >= 0 then write("El nmero es positivo") Esle write("El nmero es negativo"); repeat until keypressed; End.
Cdigo Lenguaje C /* programa positivo o negativo */ #include "conio.h" #include "stdio.h" int N; main() { clrscr(); gotoxy(10,10); printf("Digite un numero "); scanf("%d",&N); gotoxy(10,12); if (N>=0) printf("el nmero es positivo"); else printf("el nmero es negativo"); getch(); }
El siguiente cdigo lo guarda bajo un nombre de archivo.m y lo ejecuta desde el prompt del MatLab. N = input('Digite un nmero '); if N>=0 fprintf('el nmero es positivo \n'); else fprintf('el nmero es negativo \n'); end Nota: Recuerde que el archivo debe quedar en el directorio Work o un directorio que haya configurado en la opcin Set Path de la opcin File del men del MatLab 3. Desarrolle un algoritmo que le permita leer un valor cualquiera N y escribir si dicho nmero es mltiplo de Z.
Anlisis: Para resolver el ejercicio planteado anteriormente, hay que leer primero el valor del nmero y almacenarlo en una variable (N). Luego leer otro valor y almacenarlo en la variable Z. Para saber si el nmero almacenado en la variable N
71 de 154
es mltiplo del nmero almacenado en Z, se hace la divisin entre Z y N, si la divisin es exacta entonces N es mltiplo de Z, de lo contrario N no ser mltiplo de Z. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer un valor y almacenarlo en la la variable N y leer otro valor y almacenarlo en la variable Z Si Es mltiplo Si la divisin entre N y Z es exacta Entonces escriba N es mltiplo de Z Sino Escriba N no es mltiplo de Z Fin
N,Z
No
No es mltiplo
N%Z=0
FIN
Seudo cdigo Inicio Leer (N,Z) Si (N residuo Z=0) entonces Escriba (N es mltiplo de Z) Sino Escriba(N no es mltiplo de Z) Fin si Fin
Cdigo Turbo Pascal: Program multiplo_de_Z; Uses crt; Z,N: integer; Begin clrscr; gotoxy(10,10); write("Digite un nmero N"); Readln(N); gotoxy(10,11); write("Digite un nmero Z"); Readln(Z); gotoxy(10,12); if N mod Z = 0 then write("N es mltiplo de Z") Esle UNIVERSIDAD SURCOLOMBIANA write("N no es mltiplo de Z"); repeat until keypressed; End. Cdigo Lenguaje C /* Programa mltiplo_de_Z */ #include "conio.h" #include "stdio.h" int N,Z; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero N "); scanf("%d",&N); gotoxy(10,11); printf("Digite un nmero Z "); scanf("%d",&Z); gotoxy(10,12); if (N%Z==0) printf("N es mltiplo de Z"); else 72 printf("N no es mltiplo de Z"); getch(); }
de 154
4.
Desarrolle un algoritmo que le permita leer un valor cualquiera N y escribir si dicho nmero es comn divisor de otros dos valores ledos W y Z
Anlisis:
Para resolver el ejercicio planteado, hay que leer primero el valor del nmero y almacenarlo en una variable (N). Leer dos valores mas y almacenarlos en las variables W y Z respectivamente. Para saber si el valor almacenado en la variable N es comn divisor de W y Z, se chequea para ver si la divisin entre W/n y Z/n son exactas. En caso de ser exactas entonces el valor numrico almacenado en la variable N es comn divisor de los dos. En caso contrario no lo ser.

INICIO
Seudo lenguaje Inicio Leer 3 valores y almacenarlos en las variables W, Z y N. Si W residuo N es igual a 0 y Z residuo N es igual a 0 Entonces Escriba N es comn divisor de W y Z Sino Escriba N no es comn divisor de W y Z Fin.
W,Z,N
No
W%N=0 Y Z%N=0
Si
No es comun divisor
Es comun divisor
FIN
Seudo cdigo Inicio Leer (W,Z,N) If (W residuo N=0 y Z residuo N=0) entonces
73 de 154
Escriba (N es comn divisor de W y Z) Sino Fin si Fin Escriba(N no es comn divisor de W y Z)
Cdigo Turbo Pascal: Program comun divisor; Uses crt; W,Z,N: integer; Begin clrscr; gotoxy(10,10); write("Digite un nmero N ");Readln(N); gotoxy(10,11); write("Digite un nmero W ");Readln(W); gotoxy(10,12); write("Digite un nmero Z ");Readln(Z); gotoxy(10,14); if (W mod N = 0) and (Z mod N=0) then write("N es comn divisor de W y Z") Esle write("N no es comn divisor de W y Z "); repeat until keypressed; End
Cdigo Lenguaje C /* Programa comun divisor */ #include "conio.h" #include "stdio.h" int W,Z,N; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero N ");scanf("%d",&N); gotoxy(10,11); printf("Digite un nmero W ");scanf("%d",&W); gotoxy(10,12); printf("Digite un nmero Z ");scanf("%d",&Z); gotoxy(10,14); if (W%N==0 && Z%N==0) printf("N es comn divisor de W y Z"); else printf("N no es comn divisor de W y Z"'); getch(); }
Para ejecutar este programa desde MatLab recuerde guardarlo bajo un nombre de archivo.m y llamarlo desde el prompt del MatLab. N = input('Digite un nmero N '); W = input('Digite un nmero W '); Z = input('Digite un nmero Z '); if (mod(W,N)==0) & (mod(Z,N)==0) fprintf('N es comn divisor de W y Z \n'); else fprintf('N no es comn divisor de W y Z \n'); end 5. Desarrolle un algoritmo que le permita leer un valor cualquiera N y escribir si dicho nmero es comn mltiplo de M y P. M y P tambin se deben leer desde el teclado.
Anlisis: Para dar solucin, primero se deben leer los valores. En N se almacena un valor y en las variables M y P se almacenarn los otros dos valores de los cuales se desea
74 de 154
saber si N es comn mltiplo o no. Para poder saber si N es mltiplo habr que realizar una divisin y preguntar si dicha divisin es exacta o no, con cada uno de los dos valores (N/M y N/P). Si cada divisin es exacta entonces escribir que N es comn mltiplo de M y P o en caso contrario decir que N no es comn mltiplo. Algoritmo: Diagrama de flujo
INICIO N,M,P
Seudo lenguaje
Inicio Leer un numero (N) y otros dos y almacenarlos en las variables M y P Si la divisin entre (N,M) y (N,P) es exacta Entonces Escreba N es comn mltiplo de M y P Sino Escriba N no es comn mltiplo de MyP Fin
No
N no es comn mltiplo
N%M=0 y N%P=0
Si
N es comn mltiplo
FIN
Seudo cdigo Inicio Leer(N,M,P) Si (N residuo M =0 y N residuo P =0) entonces Escriba( N es comn mltiplo de M y P) Si no Escriba( N no es comn mltiplo de M y P) Fin si Fin
Cdigo Turbo Pascal: Program comn_mltiplo_de_M_y_P; Uses crt; N,M,P: integer; Begin clrscr; gotoxy(10,10); write("Digite un nmero N"); readln(N); gotoxy(10,11); write("Digite un nmero M"); readln(M); gotoxy(10,12); write("Digite un nmero P"); readln(P); gotoxy(10,13); if (N mod M=0) and (N mod P=0) then write("N es mltiplo de M y P") Esle UNIVERSIDAD SURCOLOMBIANA write("N no es mltiplo de M y P"); repeat until keypressed; End Cdigo Lenguaje C /* Programa comn_mltiplo_de_M_y_P */ #include "conio.h" #include "stdio.h" int N,M,P; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero N "); scanf("%d",&N); gotoxy(10,11); printf("Digite un nmero M "); scanf("%d",&M); gotoxy(10,12); printf("Digite un nmero P "); scanf("%d",&P); gotoxy(10,13); if (N%M==0 && N%P==0) printf("N es mltiplo de M y P"); else 75 de 154 printf("N no es mltiplo de M y P"); getch(); }
Para desarrollar los siguientes ejercicios se asume que los valores que se lean para las variables A y B son diferentes
6.
Desarrolle un algoritmo que le permita leer dos valores (A y B) y que escriba cual de los dos valores ledos es el mayor
Anlisis: Para dar solucin al anterior ejercicio, primero se deben leer los dos valores y almacenar cada uno de ellos en una variable. Para el caso del desarrollo se almacenar un valor en la variable A y el otro en la variable B. Para poder saber cual de los dos valores es mayor simplemente se comparan las dos variables y se escribir cual de las dos es la mayor. Se supone que los dos valores ledos son diferentes. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer dos valores y almacenarlos en las variables A y B Si A es el mayor Si A>B Entonces Escriba A es el mayor Sino Escriba B es el mayor
A,B No B es el mayor
A>B
FIN
Fin
Seudo cdigo Inicio Leer(A,B)
76 de 154
Fin
Si (A>B) entonces Escriba(A es el mayor) Sino Escriba(B es el mayor) Fin Si
Cdigo Turbo Pascal: program cual_de_los_dos_es_mayor; uses crt; A,B: Integer; begin clrscr; gotoxy(10,10); write("Digite un nmero"); readln(A); gotoxy(10,11); write("Digite otro nmero"); readln(B); gotoxy(10,12); if A>B then write("A es el mayor") else write("B es el mayor"); repeat until keypressed; end
Cdigo Lenguaje C /* programa cual_de_los_dos_es_mayor */ #include "conio.h" #include "stdio.h" int A,B; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); if (A>B) printf("A es el mayor"); else printf("B es el mayor"); getch(); }
7.
Desarrolle un algoritmo que le permita leer dos valores A y B y escriba cual de los dos valores ledos es el menor
Anlisis: Este ejercicio es similar al anterior, primero se deben leer los dos valores y almacenar cada uno de ellos en una variable. Para el caso del desarrollo se almacenar un valor en la variable A y el otro en la variable B. Para poder saber cual de los dos valores es menor se comparan las dos variables y se escribir cual de las dos es la menor. Se supone que los dos valores ledos son diferentes. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Lea dos valores y almacnelos en las variables A y B. Si A es menor Fin 77 de 154 Si al evaluar la condicin A<B es verdadero Entonces Escriba A es el menor Sino escriba B es el menor
A,B No A<B B es menor
FIN
Seudo cdigo Inicio Leer(A,B) Si (A<B) entonces Escriba(A es el menor) Sino Escriba(B es el menor) Fin Si Fin
Cdigo Turbo Pascal: program cual_de_los_dos_es_menor; Uses crt; A,B: Integer; begin clrscr; gotoxy(10,10); write("Digite un nmero A "); readln(A); gotoxy(10,11); write("Digite un nmero B "); readln(B); gotoxy(10,12); if A<B then write("A es el menor") else write("B es el menor"); repeat until keypressed; end Cdigo Lenguaje C /* Programa cual_de_los_dos_es_menor */ #include "conio.h" #include "stdio.h" int A,B; main() { clrscr(); gotoxy(10,10); printf("Digite un numero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un numero B "); scanf("%d",&B); gotoxy(10,12); if (A<B) printf("A es el menor"); else printf("B es el menor"); getch(); }
Digitado en Matlab quedar as: A = input('Digite un nmero A '); B = input('Digite un nmero B '); if (A>B) fprintf('A es mayor\n'); else fprintf('B es mayor\n'); end 8. Desarrolle un algoritmo que le permita leer 2 valores A y B e indicar si uno de los dos divide al otro exactamente
78 de 154
Anlisis: Para dar solucin al anterior ejercicio, primero se deben leer los dos valores y almacenar cada uno de ellos en una variable. Para el caso del desarrollo se almacenar un valor en la variable A y el otro en la variable B. Para saber si uno de los dos divide exactamente al otro se examina primero el caso en que B divida exactamente a A; se compara el residuo, si es cero se escribir que divide exactamente a A de lo contrario se examina el caso en que A divida exactamente a B. Se compara nuevamente el residuo, si es cero se escribir "A divide exactamente a B" sino "ninguno de los dos divide exactamente al otro". Se supone que los dos valores ledos son diferentes. Algoritmo: Diagrama de flujo
INICIO
A,B No No
Ninguno divide al otro exactamente A%B=0
Si
B divide exactamente a A
B%A=0
Si
A divide exactamente a B
FIN
Seudo lenguaje
Inicio Leer dos valores. El uno almacenarlo en la variable A y el otro en la variable B Si la divisin entre A y B es exacta Entonces Escribir que B divide exactamente a A Sino Si la divisin entre B y A es exacta Entonces Escribir que A divide exactamente a B Si_no Escribir que no se dividen exactamente.
79 de 154
Fin_si Fin_si Fin
Seudo cdigo Inicio Leer (A,B) Si A residuo B=0 entonces Escriba (B divide exactamente a A) Si_no Si B residuo A=0 entonces Escriba (A divide exactamente a B) Si_no Escriba (No se dividen exactamente) Fin_si Fin_si Fin
Cdigo Turbo Pascal: program divisin_exacta; Uses crt; A,B: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero"); readln(A); gotoxy(10,11); write("Digite otro nmero"); readln(B); gotoxy(10,12); if A mod B=0 then write("B divide exactamente a A") else if B mod A=0 then write("A divide exactamente a B") else write("Ninguno de los dos divide exactamente al otro"); repeat until keypressed; end Cdigo Lenguaje C /* Programa divisin exacta */ #include "conio.h" #include "stdio.h" int A,B; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); if (A%B==0) printf("B divide exactamente a A"); else if (B%A==0) printf("A divide exactamente a B"); else printf("Ninguno de los dos divide exactamente al otro"); getch(); }
9.
Desarrolle un algoritmo que le permita leer dos valores A y B e indicar si el resultado de dividir la suma del los dos nmeros entre la resta del primer nmero con el segundo es exacta.
80 de 154
Anlisis:
Primero se leen los dos valores almacenando cada uno de ellos en una variable, para el caso del ejercicio, el primer valor es almacenado en la variable A y el segundo valor es almacenado en la variable B. Para saber si la divisin es exactas se chequea el residuo. En caso de que el residuo sea igual a cero es porque la divisin fue exacta, de lo contrario la divisin no es exacta.

INICIO
Seudo lenguaje
Inicio Leer dos valores. El uno almacenarlo en la variable A y el otro en la variable B Si la divisin entre A+B y A-B es exacta Entonces Escribir que La divisin es exacta Sino Escribir que no se dividen exactamente. Fin_si Fin
A,B
No
La divisin no es exacta
((A+B)% (A-B))=0
Si
La divisin es exacta
FIN
Seudo cdigo Inicio Leer (A,B) Si (A+B) residuo (A-B)=0 entonces Escriba (La divisin es exacta) Si_no Escriba (La divisin es inexacta) Fin_si Fin
Cdigo Turbo Pascal: program divisin_exacta; Uses crt; A,B: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero"); readln(A); gotoxy(10,11); write("Digite otro nmero"); readln(B); gotoxy(10,12); if (A+B) mod (A-B)=0 then UNIVERSIDAD SURCOLOMBIANA write("La divisin es exacta") else write("La divisin es inexacta"); Cdigo Lenguaje C /* Programa divisin exacta */ #include "conio.h" #include "stdio.h" int A,B; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); 81 de 154 if ((A+B)%(A-B) == 0) printf("La divisin es exacta"); else
10.
Desarrolle un algoritmo que le permita leer dos valores A y B e indicar si la suma de los dos nmeros es par
Anlisis: Primero se leen los dos datos almacenando cada uno de ellos en un variable, en el caso del ejercicio el primer valor se almacena en la variable A y el segundo se almacena en la variable B. Al sumarlos para saber si el resultado es par o impar se divide entre dos chequeando el residuo. Si el residuo es cero es porque el valor es par y si el residuo es uno es porque el valor es impar. Algoritmo: Diagrama de flujo Seudo lenguaje
Inicio Leer dos valores y almacenarlos en las variables A y B
INICIO
A,B No
La suma es impar
(A+B)% 2=0
Si
La suma es par
Si el residuo de (A+B)/2 es igual a =0 entonces Escribir La suma es par Sino Escribir La suma es impar Fin Si Fin
FIN
Seudo cdigo Inicio Leer (A y B) Si (A+B)%2=0 entonces Escribir(La suma es par) Sino
82 de 154
Escribir(La suma es impar) Fin Si Fin
Cdigo Turbo Pascal: program suma_par; Uses crt; A,B: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero"); readln(A); gotoxy(10,11); write("Digite otro nmero"); readln(B); gotoxy(10,12); if ((A+B)mod 2=0 then write("La suma es par") else write("La suma es impar"); repeat until keypressed; end
Cdigo Lenguaje C /* Programa suma par */ #include "conio.h" #include "stdio.h" int A,B; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); if ((A+B)%2== 0) printf("La suma es par"); else printf("La suma es impar"); getch(); }
11.
Desarrolle un algoritmo que le permita leer dos valores A y B e indicar cual de las dos restas (B-A) o (A-B) es positiva
Anlisis:
Ledos los dos valores,y almacenados los valores en las variables respectivas A y B, se procede a comparar una de las dos restas, si dicha resta es positiva se escribe el mensaje o si no se escribe lo contrario.
Algoritmo: Diagrama de flujo Seudo lenguaje
INICIO
A,B No
(B-A) es
(A-B)>=0
Si
(A-B) es
positiva
positiva
Inicio Leer dos valores y almacenarlos en las variables A y B Si la resta A menos B es mayor o igual a 0 entonces Escribir la resta de A menos B es positiva Sino Escribir La resta de B menos A es positiva Fin Si Fin
FIN UNIVERSIDAD SURCOLOMBIANA
83 de 154
Seudo cdigo
Inicio Leer (A y B) Si A-B>=0 entonces Escribir(A - B es positiva) Sino Escribir(B - A es positiva) Fin Si Fin
Cdigo Turbo Pascal: program resta_positiva; Uses crt; A,B: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero A "); readln(A); gotoxy(10,11); write("Digite un nmero B "); readln(B); gotoxy(10,12); if (A - B)>=0 then write("A - B es positiva") else write("B - A es positiva"); repeat until keypressed; end Cdigo Lenguaje C /* Programa resta positiva */ #include "conio.h" #include "stdio.h" int A,B; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); if (A-B>= 0) printf("A - B es positiva"); else printf("B - A es positiva"); getch(); }
Para los siguientes algoritmos, los valores A, B y C deben ser ingresados diferentes.
12.
Desarrolle un algoritmo que le permita leer tres valores y almacenarlos en las variables A,B,C respectivamente. El algoritmo debe indicar cual es el mayor. Para este caso se asume que los tres valores ledos por el teclado son valores distintos/
Anlisis:
Es necesario leer los tres valores a comparar, cada uno de ellos se almacena en una variable que para el ejercicio ser A, B y C. Para saber si A es el valor mayor se compara con las variables B y C respectivamente. En caso de ser mayor se escribe el mensaje, en caso contrario se sigue verificando otra variable caso B y si no por
84 de 154
defecto se dir que C es el mayor asumiendo que los tres valores almacenados son diferentes.
INICIO A,B,C
No No
B>A y B>C C es el mayor
A>B y A>C
Si
Si
B es el mayor A es el mayor
Seudo lenguaje
Inicio Leer tres valores y almacenarlos en las variables A, B y C Si A es mayor que B y A es mayor que C entonces Escribir A es el mayor Sino Si B es mayor que A y B es mayor que C entonces Escribir B es el mayor Sino Escribir C es el mayor Fin Si Cdigo Turbo Pascal: Fin Si program mayor; Fin Uses crt;
FIN
Seudo cdigo
Inicio Leer (A, B y C) Si A>B y A>C entonces Escribir(A es el mayor) Sino Si B>A y B>C entonces Escribir (B es el mayor) Sino Escribir (C es el mayor) Fin Si Fin Si Cdigo Lenguaje C Fin
/* Programa mayor */ #include "conio.h" #include "stdio.h" int A,B,C; main() { clrscr();gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A);gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B);gotoxy(10,12) printf("Digite un nmero C "); scanf("%d",&C);gotoxy(10,13); if (A>B && A>C) printf("A es el mayor"); else if (B>A && B>C) printf("B es el mayor"); 85 else printf("C es el mayor"); getch(); }
A,B,C: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero A") ;readln(A);gotoxy(10,11); write("Digite un nmero B") ;readln(B);gotoxy(10,12); write("Digite un nmero C"); readln(C);gotoxy(10,13); if (A > B) and (A>C) then write("A es el mayor") else if ( B>A) and (B>C) then write("B es el mayor") else UNIVERSIDAD SURCOLOMBIANA write("C es el mayor"); repeat until keypressed; end
de 154
13.
Desarrolle un algoritmo que le permita leer tres valores A,B,C e indicar cual es el menor
Anlisis: Es similar al ejercicio anterior con diferencia en la asercin realizada. En este se verificar si una variable contiene el menor valor con respecto a las otras dos. Igualmente se asume que los valores ledos son diferentes. Algoritmo: Diagrama de flujo
INICIO A,B,C
No No
C es el menor
A<B y A<C
Si
A es el menor
B<A y B<C
Si
B es el menor
FIN
Cdigo Turbo Pascal: program menor; Uses crt; A,B,C: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero"); readln(A); gotoxy(10,11); write("Digite otro nmero"); readln(B); gotoxy(10,12); write("Digite otro nmero"); readln(C); gotoxy(10,13); if (A< B) and (A<C) then write("A es el menor") else if ( B<A) and (B<C) then write("B es el menor") else write("C es el menor"); repeat until keypressed; end Cdigo Lenguaje C /* Programa menor */ #include "conio.h" #include "stdio.h" int A,B,C; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); printf("Digite un nmero C "); scanf("%d",&C); gotoxy(10,13); if (A<B && A<C) printf("A es el menor"); else if (B<A && B<C) printf("B es el menor"); else printf("C es el menor"); getch(); }
86 de 154
Seudo Lenguaje Inicio Leer tres valores y almacenarlos en las variables A, B y C Si A es menor que B y A es menor que C entonces Escribir A es el menor Sino Si B es menor que A y B es menor que C entonces Escribir B es el menor Sino Escribir C es el menor Fin Si Fin Si Fin
Seudo Cdigo Inicio Leer (A, B y C) Si A<B y A<C entonces Escribir(A es el menor) Sino Si B<A y B<C entonces Escribir (B es el menor) Sino Escribir (C es el menor) Fin Si Fin Si Fin
14.
Desarrolle un algoritmo que le permita leer tres valores A,B,C e indique cual es valor del centro
Anlisis: Una vez ledos los valores en cada uno de los indicadores (variables A,B,C) se procede a comparar cada uno de ellos con los otros dos para verificar si es valor del centro o no. Un valor es del centro si es menor que uno y mayor que otro o el caso contrario. Igualmente se asume que los tres valores ledos son diferentes. Algoritmo: Diagrama de flujo
INICIO A,B,C
No
(A<B y A>C) (A>B y A<C) Si
Si
A es el centro
No
C es el centro
(B<A y B>C) (B>A y B<C) B es el centro
FIN
87 de 154
Seudo lenguaje Inicio Leer tres valores y almacenarlos en las variables A, B y C Si A es menor que B y A es mayor que C A es mayor que B y A es menor que C entonces Escribir A es el valor del centro Sino Si B es menor que A y B es mayor que C B es mayor que A y B es menor que C entonces Escribir B es el valor del centro Sino Escribir C es el valor del centro Fin Si Fin Si Fin Seudo cdigo Inicio Leer (A, B y C) Si A<B y A>C o A>B y A<C entonces Escribir(A es el centro) Sino Si B<A y B>C B>A y B<C entonces Escribir (B es el centro) Sino Escribir (C es el centro) Fin Si Fin Si Fin
Cdigo Turbo Pascal: program valor_centro; Uses crt; A,B,C: integer; begin clrscr; gotoxy(10,10); write("Digite un nmero A "); readln(A); gotoxy(10,11); write("Digite un nmero B "); readln(B); gotoxy(10,12); write("Digite un nmero C "); readln(C); gotoxy(10,13); if (A< B)and(A>C) or (A>B)and(A<C) then write("A es el centro") else if (B< A) and (B>C) or (B>A) and (B<C) then write("B es el centro") else write("C es el centro"); repeat until keypressed; end Cdigo Lenguaje C /* Programa valor centro */ #include "conio.h" #include "stdio.h" int A,B,C; main() { clrscr(); gotoxy(10,10); printf("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); printf("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); printf("Digite un nmero C "); scanf("%d",&C); gotoxy(10,13); if ((A<B && A>C) | (A>B && A<C)) printf("A es el centro"); else if ((B<A && B>C) | (B>A && B<C)) printf("B es el centro"); else printf("C es el centro"); getch(); }
88 de 154
15.
Desarrolle un algoritmo que le permita leer tres valores A,B,C e indicar si uno de los tres divide a los otros dos exactamente
Anlisis: Ledos los tres valores y almacenados en cada una de las varaibles A,B y C respectivamente se procede a verificar si cada uno de ellos divide exactamente a los otros dos. La divisin es exacta si el residuo de la divisin respectiva es igual a cero. Algoritmo: Diagrama de flujo
INICIO
A,B,C
No
B%A=0 y C%A=0
Si
No
A%B=0 y C%B=0
Si
A divide a los otros dos
exactamen No
A%C=0 y B%C=0 Ninguno divide a los otros dos
Si
B divide a los otros dos exactamente
C divide a los otros dos exactamente
exactamente
FIN
89 de 154
Tanto el seudo lenguaje como el seudo cdigo deben quedar de acuerdo como se haya realizado el diagrama de flujo. Es importante para que al realizar la prueba de escritorio nos de lo que diagramamos. Seudo lenguaje Inicio Leer tres valores y almacenarlos en las variables A, B y C Si B residuo A es igual a cero y C residuo A es igual a cero Entonces A divide exactamente a B y C Sino Si A residuo B es igual a cero y C residuo B es igual a cero Escribir B divide exactamente a A y C Sino Si A residuo C es igual a cero y B residuo C es igual a cero Escribir C divide exactamente a A y B Sino Escribir no hay divisin exacta Fin _Si Fin_Si Fin Seudo cdigo Inicio Leer (A, B y C) Si B%A=0 y C%A=0 entonces Escribir(A divide exactamente a B y C) Sino Si A%B=0 y C%B=0 entonces Escribir (B divide exactamente a A y C) Sino Si A%C=0 y B%C=0 entonces Escribir (C divide exactamente a B y A) Sino Escribir (No hay divisin exacta) Fin Si Fin Si Fin Si Fin
90 de 154
Cdigo Turbo Pascal:
Cdigo Lenguaje C /* Programa divisin exacta */ program division_exacta; #include "conio.h" Uses crt; #include "stdio.h" A,B,C: integer; int A,B,C; begin main() clrscr; { clrscr(); gotoxy(10,10); gotoxy(10,10); write("Digite un nmero"); printf("Digite un nmero A "); readln(A); scanf("%d",&A); gotoxy(10,11); gotoxy(10,11); write("Digite otro nmero"); printf("Digite un nmero B "); readln(B); scanf("%d",&B); gotoxy(10,12); gotoxy(10,12); write("Digite otro nmero"); printf("Digite un nmero C "); readln(C); scanf("%d",&C); gotoxy(10,13); gotoxy(10,13); if (B mod A=0)and(C mod A=0) then if (B%A==0 && C%A==0) write("A divide exactamente a C y B") printf("A divide exactamente a C y B"); else else if (A mod B=0) and (C mod B=0) then if (A%B==0 && C%B==0) write("B divide exactamente a A y C") printf("B divide exactamente a A y C"); else else if (A mod C=0) and (B mod C=0) then if (A%C==0 && B%C==0) write("C divide exactamente a A y B"); printf("C divide exactamente a A y B"); else else write("no hay divisin exacta"); printf("no hay divisin exacta"); repeat until keypressed; getch(); end }
Nota: En el ejercicio anterior se hace uso de preguntas que involucran tanto a operadores tanto de relacin como operadores lgicos. Esto es importante ya que la solucin no queda tan compleja y no se queda ninguna opcin sin contemplar. 16. Desarrolle un algoritmo que le permita leer tres valores A,B,C e indicar si la suma de dos nmeros cualquiera es igual al tercero.
Anlisis: Primero se deben leer los tres valores y almacenar cada valor en una variable. En el caso del ejemplo se guardaran los valores en los identificadores A,B, y C. luego se proceder a realizar las diferentes comparaciones.
91 de 154
Algoritmo: INICIO Diagrama de flujo A, B, C
A+B=C A+C=B C+B=A En ningn caso la suma de dos nmeros cualquiera es igual al tercero C + B es igual al tercero
A + C es igual al tercero
A + B es igual al tercero
FIN Seudo lenguaje Inicio Leer tres valores y almacenarlos en las variables A, B y C Si A mas B es igual C entonces Entonces Escribir La suma de A con B es igual a C Sino Si A+C es igual B entonces Escribir la suma de A con C es igual a B Sino Si C mas B es igual A Escribir la suma de C con B es igual a A Sino Escribir En ningn caso la suma es igual Fin _Si Fin_Si Fin
92 de 154
Seudo cdigo Inicio Leer (A, B y C) Si A+B=C entonces Escribir(la suma de A+B=C) Sino Si A+C=B entonces Escribir (La suma de A+C=B) Sino Si C+B=A entonces Escribir (La suma de C+B=A) Sino Escribir (En ningn caso la suma es igual) Fin Si Fin Si Fin Si Fin
Cdigo Turbo Pascal: Cdigo Lenguaje C /* Programa valor centro */ program valor_centro; #include "conio.h" Uses crt; #include "stdio.h" A,B,C: integer; int A,B,C; begin main() clrscr; { clrscr(); gotoxy(10,10); gotoxy(10,10); write("Digite un nmero A "); printf("Digite un nmero A "); readln(A); scanf("%d",&A); gotoxy(10,11); gotoxy(10,11); write("Digite un nmero B "); printf("Digite un nmero B "); readln(B); scanf("%d",&B); gotoxy(10,12); gotoxy(10,12); write("Digite un nmero C "); printf("Digite un nmero C "); readln(C); scanf("%d",&C); gotoxy(10,13); gotoxy(10,13); if (A+B=C) then if (A+B==C) write("A + B = C") printf("La suma de A+B=C"); else else if (A +C= B) then if (A+C==B) write("A + C = B") printf("La suma de A+B=C"); else else if (C+B=A) then if (C+B==A) write("C + B = A") printf("La suma de C+B= A"); Else else write("en ningun caso hay suma igual") printf("En ningun caso hay suma igual"); repeat until keypressed; getch(); end }
93 de 154
17.
Si se tiene la funcin: f(x) = ax 2 + bx + c , el valor de x se calcula as: b b 2 4ac , la expresin dentro del radical se le llama 2a discriminante de la ecuacin. Las dos races son reales y desiguales, reales e iguales o imaginarias, segn que el discriminante sea positivo, cero o negativo. Desarrolle un algoritmo que lea valores para a,b,c y determine si hay posible solucin para x de dicha funcin. x=
Anlisis: Ledos los tres valores en las variable a,b y c respectivamente se procede a realizar los chequeos tendientes a ver si las operaciones implcitas en el ejercicio se pueden o no realizar. Por ejemplo hay que verificar que la parte que est dentro del radical no sea negativa y que el valor de divisor "2a" no sea igual a cero. Si verificada esas dos acciones se pueden realizar las operaciones se procede a sacar cada uno de los valore de X, uno con el signo positivo y otro con el signo negativo.
INICIO
Algoritmo: Diagrama de flujo No No

A =0 A, B, C
Si
B - 4AC <0
Si
Las races son imaginarias
b + b 2 4ac X1 = 2a
X = -B 2a
X2 =
b b 2 4ac 2a
Las races son reales iguales
Las races son reales diferentes X1 Y X2
FIN
94 de 154
Seudo lenguaje Inicio Leer tres valores y almacenarlos en las variables A, B y C Si B al cuadrado - 4 veces A por C es menor que cero entonces Escribir Las races son imaginarias Sino Si B al cuadrado - 4 veces A por C es igual a cero entonces Hacer X igual a -B dividido 2 por a Escribir la races son reales e iguales a X Sino b + b 2 4ac Hacer X 1 = 2a b b 2 4ac 2a Escribir races reales iguales a X1 y x2 Fin _Si Fin_Si Fin Hacer X 2 = Seudo cdigo Inicio Leer (A, B y C) Si b 2 4ac < 0 entonces Escribir(Races imaginarias) Sino Si a=0 entonces X = b / 2a Escribir (Races reales iguales a X) Sino b + b 2 4ac X1 = 2a b b 2 4ac X2 = 2a Escribir (Races reales X1 y X2) Fin Si Fin Si Fin
95 de 154
Cdigo Lenguaje C /* Programa valor centro */ #include "conio.h" program valor_centro; #include "stdio.h" Uses crt; int A,B,C; A,B,C: integer; main() begin { clrscr(); gotoxy(10,10); clrscr; gotoxy(10,10); printf("Digite un nmero A "); write("Digite un nmero A "); scanf("%d",&A); gotoxy(10,11); readln(A); gotoxy(10,11); printf("Digite un nmero B "); write("Digite un nmero B "); scanf("%d",&B); gotoxy(10,12); readln(B); gotoxy(10,12); printf("Digite un nmero C "); write("Digite un nmero C "); scanf("%d",&C); readln(C); gotoxy(10,13); gotoxy(10,13); if (b*b-4*a*c<0) if (b*b-4*a*c<0) then printf("Raices imaginarias"); write("Raices imaginarias") else else if (a==0) if (a=0) then { begin X=-b/(2*a); X:=-b/(2*a) printf("Raices reales iguales a X"); write("Raices reales iguales a X") } end else else { begin X1=-b+sqrt(b*b-4*a*c)/(2*a); X1:=(-b+(sqrt(b*b-4*a*c))/(2*a); X2=-b-sqrt(b*b-4*a*c)/(2*a); X2:=(-b-(sqrt(b*b-4*a*c))/(2*a); printf("raices reales igual a X1 y X2"); write("raices reales igual a X1 y X2"); } end; getch(); repeat until keypressed; } end Cdigo Turbo Pascal:
El siguiente cdigo soluciona el anterior ejercicio, con instrucciones para ser ejecutado desde el prompt del Matlab. Recuerde que tiene que guardarlo en un archivo tipo m y luego llamar el archivo desde el prompt colocando el nombre. a = input('Digite un nmero A '); b = input('Digite un nmero B '); c = input('Digite un nmero C '); if b^2-4*a*c<0 fprintf('Races imaginarias\n'); else if (a==0) x=-b/(2*a); fprintf('Races reales iguales a X = %f\m',x); else x1=-b+sqrt(b*b-4*a*c)/(2*a); x2=-b-sqrt(b*b-4*a*c)/(2*a); fprintf('Races reales igual a X1 = %f y X2 = %f\n',x1,x2); end end
96 de 154
ESTRUCTURAS CCLICAS
Los procesos repetitivos son la base del uso de las computadoras. En estos procesos se necesita normalmente contar los sucesos, acciones o tareas internas del ciclo. Una estructura cclica o estructura repetitiva es aquella que le permite al programador repetir un conjunto o bloque de instrucciones un nmero determinado de veces mientras una condicin dada sea cierta o hasta que una condicin dada sea cierta. Se debe establecer un mecanismo para terminar las tareas repetitivas. Dicho mecanismo es un control que se evala cada vez que se realiza un ciclo. La condicin que sirve de control puede ser verificada antes o despus de ejecutarse el conjunto de instrucciones o sentencias. En caso de que la verificacin o evaluacin resulte verdadera se repite el ciclo o caso de ser falsa lo terminar. Ciclos con control antes Las estructuras cclicas cuyo control esta antes del ciclo, son estructuras que realizan la evaluacin antes de ejecutar el bloque de instrucciones que tiene que repetir. Dependiendo de la evaluacin que se realice se ejecutara o no dicho conjunto de instrucciones. Es posible que no se realice ni una sola vez ese conjunto de instrucciones. En el caso del MatLab solo trabaja con estructuras cuyo control est antes del ciclo (For y While) Ciclos con control despus: Las estructuras cclicas cuyo control esta despus del ciclo, son estructuras que realizan la evaluacin despus de ejecutar el bloque de instrucciones que se desea repetir. Con este tipo de control se obliga a la ejecucin al menos de una vez del bloque de instrucciones. El nmero de ciclos que se realiza puede ser definido previamente o no definido. Para el caso de que el ciclo sea definido en el nmero de veces que se repetir, se debe trabajar un contador para que lleve la cuenta del nmero de tareas. En caso de no tener definido el nmero de ciclos previamente, se tendr que definir muy bien el control a fin de evitar que se quede en un nmero indefinido de ciclos y se bloquee la computadora (LOOP)
97 de 154
Estructuras cclicas anidadas: Una estructura cclica puede estar anidada dentro de otra estructura cclica o de decisin sin problemas. Hay que tener en cuenta que el anidamiento debe ser total.
INICIO
Inicio Inicializacin de variable que cuenta las veces que se repetir las tareas Control de la variable inicio con el final del numero de tarea Inicio
VAR INICIO
CONTROL
>
<=
TAREA FIN
Fin
Tarea o tareas a realizar Incremento de la variable que llevara el ciclo
INCREMENTO
FIN
Forma general de la estructura cclica con control antes del ciclo

INICIO Inicio Inicializacin de variable que cuenta las veces que se repetir las tareas Hacer Tarea o tareas a realizar INCREMENTO ciclo Incremento de la variable que llevara el
VAR INICIO
TAREA
<=
CONTROL
Control de la variable que inicia con el final del numero de tarea FIN
>
FIN
Forma general de la estructura cclica con control despus del ciclo
98 de 154
Estructura cclica FOR-ENDFOR El enunciado FOR es una construccin de programacin del C que ejecuta un bloque de uno o ms enunciados una determinada cantidad de veces. A veces es llamado ciclo for, debido a que la ejecucin del programa por lo general hace ciclos por los enunciados mas de una vez. Si bien este bucle no se incluye en el Seudo cdigo clsico, con ligeras variantes, es prcticamente adoptado por todos los lenguajes. Por ello, tratamos aqu este bloque con sus posibles modalidades y su Seudo cdigo, no estndar, correspondiente. Un enunciado FOR tiene la siguiente estructura: for (inicial; condicin; incremento) enunciado En el caso del MatLab el FOR esta definido as: for (inicial: incremento: final) enunciado end Si no se define el incremento, el Matlab asume un valor de 1. inicial, condicin e incremento son expresiones del C, y enunciado es un enunciado simple compuesto del C. Cuando se encuentra un enunciado for durante la ejecucin del programa sucede los siguientes eventos: 1. la expresin inicial es evaluada. Lo inicial es por lo general un enunciado de asignacin que pone una variable a un valor determinado. 2. La expresin de condicin es evaluada. La condicin es tpicamente una expresin relacional. 3. Si la condicin evala a falso, el enunciado for termina y la ejecucin pasa al primer enunciado que se encuentra a continuacin del for. 4. Si la condicin evala a cierto se ejecutan los enunciados que se encuentran dentro del for. 5. La expresin de incremento es evaluada y la evaluacin regresa al paso dos.
99 de 154
INICIO
/* Programa que escribe los cuatro primeros nmeros */ #include "conio.h" #include "stdio.h" int i; main() { clrscr(); for(i=1; i<=4; i++) printf("%d ",i); getch(); }
i=1 i<=4 i=i+1

FIN
TAREA
1.
Desarrolle un algoritmo que le permita realizar la escritura de los primeros 100 nmeros naturales.
Anlisis: Para poder escribir los primeros 100 nmeros primero hay que generar dichos valores. Una forma de generar los valores es con las estructuras cclicas. Hacer una variable que se inicie en 1 que seria el primer valor a escribir y finalice en 100 que seria el ltimo nmero necesitado incrementando de uno en uno dicha variable. Inicia con I=1 Finaliza con I=100 Incrementa la I en uno o sea I=I+1 Dentro del ciclo se da la orden para escribir el valor de la variable I. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje
Inicio Asignar a la variable i el valor de 1 Mientras el valor de i sea menor o igual a 100 Haga > Inicie las instrucciones del ciclo Escriba el valor de i
FIN
i=1
i : 100
<=
Incremente el valor de i en uno Finalice las instrucciones del ciclo
i=i+1
Fin
100 de 154
Seudo cdigo
Inicio i=1 Mientras i<=100 haga Inicio Escribir(i) i= i+1 Fin_Mientras Fin
Cdigo Turbo Pascal con el control antes del ciclo: Program escrinbe_100_numeros; Uses crt; var I:integer; Begin clrscr; i:=1; while i<=100 do begin write(i:3); i=i+1; end; repeat until keypressed; End. /* Cdigo Lenguaje C con Control antes del ciclo Escribe 100 numeros */ #include "conio.h" #include "stdio.h" int i; main() { clrscr(); i=1; while (i<=100) { printf("%d ",i); i++; } getch(); } Cdigo Turbo Pascal con el control despus del ciclo: Program escrinbe_100_numeros; Uses crt; Var I: integer; Begin clrscr; i:=1; repeat write(i:3); i=i+1; until i>100; repeat until keypressed; End.
/* Cdigo Lenguaje C con Control despus del ciclo Escribe 100 numeros */ #include "conio.h" #include "stdio.h" int i; main() { clrscr(); i=1; do { printf("%d ",i); i++; } while (i<=100); getch(); }
/* Cdigo Lenguaje C con Estructura for Escribe 100 numeros */ #include "conio.h" #include "stdio.h" int i; main() { clrscr(); for (i=1; i<=100 ; i++) printf("%d ",i); } getch();
Para Matlab simplemente se define la variable y y se indica en el FOR donde inicia y donde termina, El incremento como no se define, el Matlab asume un incremento de 1. for i=1:100 fprintf('%d ',i); end
101 de 154
2.
Desarrolle un algoritmo que le permita realizar la suma a los primeros N nmeros impares.
Anlisis: Al igual que en ejercicio anterior es necesario apoyarse en una estructura de tipo cclica a fin de poder dar solucin al problema. La idea es desarrollar la estructura para N veces y de la variable que lleve la cuenta generar los nmeros impares buscando la relacin entre la cuenta y el nmero como tal. El primer trmino es el 1, el segundo el tres, el tercero el cinco y as sucesivamente hasta llegar al ensimo trmino que es el 2*N-1. Algoritmo: Diagrama de flujo
INICIO N S=0
Seudo lenguaje
Inicio Leer un numero y almacenarlo en la variable N Asignar a la variable S el valor de 0 Asignar a la variable i el valor de 1
i=1
Mientras el valor de la variable i sea menor o igual al valor de la variable N haga >
S
i:N
Inicio de las instrucciones del ciclo Asigne a la variable Num el valor de 2 * i - 1 Asigne a la variable s el valor que hay Almacenado en s mas el valor almacenado en la variable Num Incremente el valor de la variable i en 1 Fin de las instrucciones del ciclo Escriba el valor almacenado en S Fin
<=
Num =2 * i -1
S = S+Num
FIN
i = i+1
Seudo cdigo Inicio Leer N; S=0; i=1 Mientras i<=N hacer Inicio Num=2i-1; S=S+Num; i= i+1 Fin_Mientras Escribir(S) Fin
102 de 154
Cdigo Turbo Pascal con el control antes del ciclo: Program suma_N_impares; Uses crt; var num,s,N,I:integer; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); s:=0; i:=1; while i<=N do begin num:=2*i-1; s=s+num; i=i+1; end; gotoxy(10,20); write("La suma es ",s); repeat until keypressed; End.
Cdigo Turbo Pascal con el control despus del ciclo: Program suma_N_impares; Uses crt; Var num,s,N,I: integer; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); s:=0; i:=1; repeat num:=2*i-1; s:=s+num; i=i+1; until i>N; gotoxy(10,20); write("La suma es ",s); repeat until keypressed; End.
Cdigo Lenguaje C con Control antes del ciclo /* Programa suma N impares */ #include "conio.h" #include "stdio.h" int num,s,N,i; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d,&N); s=0; i=1; while (i<=N) { num=2*i-1; s=s+num; i++; } gotoxy(10,20); printf("La suma es %d",s); getch(); }
Cdigo Lenguaje C con Control despus del ciclo /* Programa suma N imapres */ #include "conio.h" #include "stdio.h" int num,s,N,i; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d,&N); i=1; s=0; do { num=2*i-1; s=s+num; i++; } while (i<=N); gotoxy(10,20); printf("La suma es %d",s); getch(); }
103 de 154
3.
Desarrolle un algoritmo que calcule el promedio a los primeros N nmeros naturales.
Anlisis: Para dar solucin al ejercicio se procede de la siguiente forma: Se debe generar una estructura cclica que se encargue de contar el numero de trminos a sumar, en el caso del ejercicio ser de N. La cuenta de los trminos coincide con el valor a sumar, es decir la variable que se va a encargar de contar los trminos sirve adems como generadora de los trminos a sumar. Se acumularn dichos nmeros generados y al final se promediara dicha sumatoria entre el numero de trminos sumados. Algoritmo: Diagrama de flujo Seudo cdigo
INICIO N
Inicio Leer N S=0 i=1
S=0 i=1
>
P=S/N
i:N
<=
S = S+i S,P i++

FIN
Mientras i<=N hacer Inicio S=S+i i= i+1 Fin_Mientras P=S/N Escribir(S,P) Fin
104 de 154
Cdigo Turbo Pascal con el Control antes del ciclo: Program promedio_de_N_nmeros; Uses crt; var s,N,I : integer; p : real; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); s:=0; i:=1; while i<=N do begin s:=s+i; i:=i+1; end; p:=s/N; gotoxy(10,20); write("El promedio es ",p); repeat until keypressed; End.
Control Cdigo Turbo Pascal con el despus del ciclo: Program promedio_de_N_nmeros; Uses crt; Var s,N,I : integer; p : real; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); s:=0; i:=1; repeat s:=s+num; i:=i+1; until i>N; p:=s/N; gotoxy(10,20); write("El promedio es ",p); repeat until keypressed; End.
Cdigo Lenguaje C con Control antes del ciclo /* Programa suma N impares */ #include "conio.h" #include "stdio.h" int s,N,i; float p; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d,&N); s=0; i=1; while (i<=N) { s=s+i; i++; } p=s/N; gotoxy(10,20); printf("El promedio es %f",p); getch(); }
Cdigo Lenguaje C con Control despus del ciclo /* Programa suma N imapres */ #include "conio.h" #include "stdio.h" int s,N,i; float p; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d,&N); i=1; s=0; do { s=s+i; i++; } while (i<=N); p=s/N; gotoxy(10,20); printf("El promedio es %f",p); getch(); }
105 de 154
4. Desarrolle un algoritmo que le permita sacar y escribir el cuadrado de cada uno de los primeros N nmeros naturales. Anlisis: Para dar solucin al ejercicio se procede de la siguiente forma: Se debe generar una estructura cclica que se encargue de generar cada uno de los trminos a los cuales se les va a sacar cuadrado. La variable encargada de contar los trminos en la estructura cclica sirve como variable que guarda cada termino al cual se le saca el cuadrado. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer un valor y almacenarlo en la variable N Hacer i igual a 1

>
N i=1
i:N
<=
Num = i * i
Mientras i sea menor o igual a N hacer

FIN
Inicio del ciclo Hacer Num igual a i * i Escribir el valor de Num
Num Hacer i igual a i mas 1 i=i+1 Fin del ciclo mientras Fin
Seudo cdigo
Inicio Leer N; i=1 Mientras i<=N hacer Inicio Num= i * i; Escribir(Num); i= i+1 Fin_Mientras Fin
106 de 154
Cdigo Turbo Pascal con el control antes del ciclo: Program cuadrado_de_N_numeros; Uses crt; var N,Num,I : integer; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); i:=1; while i<=N do begin Num:=i*i; gotoxy(10,12+i); write("EL cuadrado es ",Num); i:=i+1; end; repeat until keypressed; End.
Cdigo Turbo Pascal con el control despus del ciclo: Program cuadrado_de_N_numeros; Uses crt; Var s,N,I : integer; p : real; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); i:=1; repeat Num:=i*i; gotoxy(10,12+i); write("EL cuadrado es ",Num); i:=i+1; until i>N; repeat until keypressed; End.
Cdigo Lenguaje C con Control antes del ciclo /* Programa cuadrado de N numeros */ #include "conio.h" #include "stdio.h" int Num,N,i; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d",&N); i=1; while (i<=N) { Num=i*i; gotoxy(10,12+i); printf("EL cuadrado de %d es %d ",i,Num); i++; } getch(); }
Cdigo Lenguaje C con Control despus del ciclo /* Programa cuadrado de N Numeros */ #include "conio.h" #include "stdio.h" int Num,N,i; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d",&N); i=1; do { Num=i*i; gotoxy(10,12+i); printf("EL cuadrado de %d es %d",i,Num); i++; } while (i<=N); getch(); }
107 de 154
5. Desarrolle un algoritmo que le permita leer un valor entero positivo N y calcule su factorial. Anlisis: El tipo de operacin que se repite en este ejercicio es la multiplicacin por tanto hay que iniciar una variable con el valor de 1 ya que este valor no afecta el resultado final. Dicha variable es S y como generador de la serie de trminos a multiplicar se tiene la misma variable que llevara la cuenta del numero de tareas. Algoritmo: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer un valor y almacenarlo en la variable N. A este valor se calcular su factorial Asignar a la variable S el valor de 1 Asignar a la variable i el valor de 1 Mientras el valor de i sea menor o igual que el valor de N hacer Inicio de instrucciones del ciclo mientras Asignar a s el valor de S por i Incrementar el valor de i en uno. Finalizar las instrucciones del ciclo Escribir el valor de S Fin
N S=1 i=1
>
i:N
<=
S = S*i
i=i+1
FIN
Seudo cdigo
Inicio Leer N S=1 i=1 Mientras i<=N hacer Inicio S=S * i; i= i+1 Fin Escribir(S) Fin
108 de 154
Cdigo Turbo Pascal con el control antes del ciclo: Program Factorial_de_N; Uses crt; var N,S,i : integer; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); i:=1;S:=1; while i<=N do begin S:=S*i; i:=i+1; end; gotoxy(10,12); write("EL factorial es ",S); repeat until keypressed; End.
Cdigo Turbo Pascal con el control despus del ciclo: Program Factorial_de_N; Uses crt; Var S,N,I : integer; p : real; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); i:=1; S:=1; repeat S:=S*i; i:=i+1; until i>N; gotoxy(10,12); write("EL factorial es ",S); repeat until keypressed; End.
Cdigo Lenguaje C con Control antes del ciclo /* Programa factorial de N */ #include "conio.h" #include "stdio.h" int S,N,i; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d",&N); i=1; S=1; while (i<=N) { S=S*i; i++; } gotoxy(10,12); printf("EL factorial es %d ",S); getch(); }
Cdigo Lenguaje C con Control despus del ciclo /* Programa Factorial de N */ #include "conio.h" #include "stdio.h" int S,N,i; main() { clrscr(); gotoxy(10,10); printf("Digite un valor "); scanf("%d",&N); i=1; S=1; do { S=S*i; i++; } while (i<=N); gotoxy(10,12+i); printf("EL factorial es %d",S); getch(); }
109 de 154
6. Desarrolle un algoritmo que le permita leer un valor entero positivo N y decir si es primo o no. Anlisis:
Un nmero es primo cuando es divisible tan solo por la unidad y por si mismo. Para determinar si un nmero es primo o no se realiza la verificacin de la divisin de dicho nmero con el rango de datos comprendidos entre el dos y la mitad del nmero. Si existe algn valor de dicho rango que divide exactamente a nuestro nmero entonces este no ser primo. Si al finalizar dicha revisin no hay ningn valor que lo divida exactamente entonces nuestro nmero ser primo. La revisin se hace hasta la mitad del nmero ya que de la mitad hacia arriba ningn valor lo divide exactamente.

INICIO
Seudo cdigo Inicio Leer N S=0
N S=0
J=2 J=2
>
Mientras J<=N%2 hacer Inicio Si N / J=0 S=S+1 Si S= S+1 N S=0 Si Si S=0 Escribir(N es primo) Sino Escribir(N es primo) Fin_Si Fin
FIN
J: N / 2
<=
N%J=0
J=J+1 Fin
J= J+1 N no es N es primo
110 de 154
Cdigo Turbo Pascal con control antes del ciclo: Program nmero_primo; Uses crt; var N,S,J : integer; Begin clrscr; gotoxy(10,10); write("Digite un valor N "); readln(N); J=2; S:=0; while J<=N mod 2 do begin if N mod J =0 then S:=S+1; J:=J+1; end; gotoxy(10,12); if S=0 then write("N es primo") else write("N no es primo[); repeat until keypressed; End.
Cdigo Turbo Pascal con control despus del ciclo: Program nmero_primo Uses crt; Var S,N,J : integer; Begin clrscr; gotoxy(10,10); write("Digite un valor "); readln(N); J:=2; S:=0; Repeat begin if N mod J =0 then S:=S+1; J:=J+1; end; until J>N mod 2; gotoxy(10,12); if S=0 then write("N es primo") else write("N no es primo[); repeat until keypressed; End. Cdigo Lenguaje C con control despus del ciclo /* Programa numero primo */ #include "conio.h" #include "stdio.h" int S,N,J; main() { clrscr(); gotoxy(10,10); printf("Digite un valor N "); scanf("%d",&N); J=2; S=0; do { if (N%J==0) S=S+1; J++; } while (J<N/2); gotoxy(10,12); if (S==0) printf("N es primo"); else printf("N no es primo"); getch(); }
Cdigo Lenguaje C con control antes del ciclo /* Programa numero primo */ #include "conio.h" #include "stdio.h" int S,N,J; main() { clrscr(); gotoxy(10,10); printf("Digite un valor N "); scanf("%d",&N); J=2; S=0; while (J<=N/2) { if (N%J==0) S=S+1; J++; } gotoxy(10,12); if (S==0) printf("N es primo"); else printf("N no es primo"); getch(); }
111 de 154
7. Desarrolle un algoritmo que le permita realizar la escritura de los primeros N nmeros Primos. Anlisis: En este ejercicio se involucra el concepto anterior de numero primo y se est adicionando una estructura cclica que se encargara de contar los N nmeros primos que se desean escribir. Algoritmo: Diagrama de flujo
INICIO
N Num=1 i=1
>
i:N
<=
S=0
FIN
J=2
> <=
J: N
N Si
S= S+1
S=0
Si Num i++
Num%J
J= J+1 Num++
112 de 154
Seudo cdigo Inicio Leer(N) Num=1 i=1 mientras i<=1 hacer inicio S=0 J=2 Mientras j<= Num/2 hacer inicio If Num%j=0 entonces S=S+1 j=j+1 fin_mientras si S=0 entonces inicio Escriba(num) I=i+1 fin_si Num=Num+1 fin_mientras fin
/* Programa que escribe los primeros N nmeros primos */ #include "conio.h" #include "stdio.h" int i,j,Num,N,S; main() { clrscr(); gotoxy(10,6); printf("Digite un valor N "); scanf("%d",&N); Num=1; i=1; while (i<=N) { S=0; j=2; while (j<=Num/2) { if (Num%j==0) S=S+1; j++;} if (S==0) { printf("%d ",Num); i++; } Num++; } getch(); }
113 de 154
8. Desarrolle un algoritmo que le permita leer un valor entero positivo N y verifique si es mximo comn divisor de W y Z. Anlisis: Existen diferentes maneras de verificar si un nmero es el mximo comn divisor de otros dos valores. Una manera es hallar la diferencia entre dichos valores y comenzar a verificar de esa diferencia hacia atrs si existe un valor que divida a los dos exactamente. En el momento de encontrar dicho valor el algoritmo no verifica ms. En caso de existir un valor que los divida, al final se compara con el valor de N, si es igual es porque N es el MCD. Algoritmo Diagrama de flujo
INICIO
N,W,Z Dif=WZ MCD=1

<=
Dif:0
>
W%Dif=0 Y
Si
MCD=Dif
Dif=Dif-1
No N no es
MCD=
Si
Dif=0
N es MCD
FIN
114 de 154
/* Programa que verifica si un nmero N es mximo comn divisor de W y Z */ #include "conio.h" #include "stdio.h" #include "math.h" int Dif,N,W,Z,MCD; main() { clrscr(); gotoxy(10,6); printf("Digite un valor N "); scanf("%d",&N); gotoxy(10,8); printf("Digite un valor W "); scanf("%d",&W); gotoxy(10,10); printf("Digite un valor Z "); scanf("%d",&Z); Dif=abs(W-Z); MCD=1; while (Dif>0) { if (W%Dif==0 && Z%Dif==0) { MCD=Dif; Dif=0; } else Dif=Dif-1; } gotoxy(10,12); if (MCD==N) printf("N es MCD "); else printf("N no es MCD "); getch(); }
9. Desarrolle un algoritmo que le permita leer un valor entero positivo N dado en base decimal y convertirlo a base binaria. Anlisis: Para convertir un nmero representado en base decimal a base binaria es necesario dividir consecutivamente por dos el numero hasta llegar a un valor de 1. Se toma en una variable el residuo de dividir el nmero entre dos y el residuo de la divisin exacta se va escribiendo, Luego se retoma en la variable donde estaba el nmero inicialmente, el valor entero de la divisin.
115 de 154
Algoritmo Diagrama de flujo

INICIO
Seudo lenguaje Inicio Leer un valor y almacenarlo en N Mientras N >0 hacer Inicio Hacer R igual al residuo de dividir a N entre 2 Escribir el residuo R
N
<=
N:0
>
R = N%2
FIN
Hacer el numero N igual a la parte entera de N Divido 2 Fin mientras Fin
N = N/2
/* Programa que lee un nmero y dicho nmero a base binaria */ #include "conio.h" #include "stdio.h" int N,R,col; main() { clrscr(); col=70; gotoxy(10,6); printf("Digite un valor N "); scanf("%d",&N); gotoxy(10,8); printf("El decimal %d en base binaria es",N); while (N>0) { R=N%2; gotoxy(col,10); printf("%d",R); col=col-4; N=N/2; } getch(); }
116 de 154
10. Leer un nmero entero y almacenarlo en la variable N y leer una base numrica cualquiera en la variable B y pasar dicho nmero a esta Base. Anlisis: Para la solucin del presente ejercicio se sigue el procedimiento anterior con la diferencia que se va a dividir consecutivamente por el valor de la base y no por dos como se hizo en el anterior. Diagrama de flujo
INICIO N, Base
Seudo lenguaje Inicio Leer un valor y almacenarlo en N y una base y almacenarla en la variable Base Mientras N >0 hacer Inicio Hacer R igual al residuo de dividir a N entre 2 Escribir el residuo R Hacer el numero N igual a la parte entera de N Divido 2 Fin mientras Fin
N:0
<=
R = N%Base
>
FIN
N = N/Base
/* Programa que lee un nmero y una base y convierte dicho nmero a esa base */ #include "conio.h" #include "stdio.h" int N,base,R,col; main() { clrscr(); col=70; gotoxy(10,6); printf("Digite un valor N "); scanf("%d",&N); gotoxy(10,8); printf("Digite una base "); scanf("%d",&base); gotoxy(10,10); printf("El decimal %d en base %d es :",N,base); while (N>0) { R=N%base; gotoxy(col,12); printf("%d",R); col=col-4; N=N/base; } getch(); }
117 de 154
11. Desarrolle un algoritmo que le permita leer un valor entero positivo N y sacar su cuadrado sumando los primeros N impares. Analisis: Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer un valor y almacenarlo en N
N S=0 i=1 > i:N < S = S+ (2*i-1)

FIN
Hacer S igual a 0 Hacer i igual a 1 Mientras i sea menor o igual a N hacer Inicio Hacer S igual a S mas 2 por i menos 1 S Hacer i igual a i mas 1 Fin mientras Escribir el valor de S Fin
i = i+1
/* programa que escribe el cuadrado de un nmero sumando N impares */ #include "conio.h" /* programa que lee un valor N y calcule su cuadrado */ #include "stdio.h" int i,N,S; main() { clrscr(); gotoxy(10,6); printf("Digite un valor N "); scanf("%d",&N); S=0; i=1; while (i<=N) { S=S+(2*i-1); i++; } gotoxy(10,8); printf("El cuadrado de %d es %d ",N,S); getch(); }
118 de 154
12. Desarrolle un algoritmo que le permita leer un valor entero positivo N y calcular su cuadrado sumando N veces N. Anlisis : Para desarrollar el ejercicio basta con declarar un acumulador para llevar la suma de los N trminos y generar un ciclo que se repita esas N veces. Diagrama de flujo
INICIO
Seudo lenguaje Inicio Leer un valor y almacenarlo en N Hacer S igual a 0 Hacer i igual a 1 Mientras i sea menor o igual a N hacer Inicio > Hacer S igual a S ms N S
FIN
N S=0 i=1 i:N < S = S+ N i = i+1
Hacer i igual a i ms 1 Fin mientras Escribir el valor de S Fin
/* programa que escribe el cuadrado de un nmero sumando N veces el nmero */ #include "conio.h" /* programa que lee un valor N y calcule su cuadrado sumando N veces */ #include "stdio.h" int i,N,S; main() { clrscr(); gotoxy(10,6); printf("Digite un valor N "); scanf("%d",&N); S=0; i=1; while (i<=N) { S=S+N; i++; } gotoxy(10,8); printf("El cuadrado de %d es %d ",N,S); getch(); }
119 de 154
13. Desarrolle un algoritmo que le permita leer N valores y calcular la media aritmtica ( x1 + x 2 + x3 + ....x n ) / n Anlisis : para poder calcular el valor de la media aritmtica a N valores es necesario dentro de una estructura cclica leer y almacenar los valores y al finalizar el ciclo calcular el valor del promedio. Las tareas a ejecutar Dentro del ciclo son : Leer Acumular Fuera del ciclo son : Promediar Escribir Seudo lenguaje Inicio Leer un valor y almacenarlo en N Hacer S igual a 0 Hacer i igual a 1 i=1 Mientras i sea menor o igual a N hacer Inicio
>
Diagrama de flujo
INICIO N
S=0
i:N
<=
Num S = S+ Num
Leer un valor y almacenarlo en Num Hacer S igual a S + Num Hacer i igual a i ms 1 Fin mientras
Media = S/N
Hacer media igual a S dividido N i++ Media

FIN
Escribir el valor de Media Fin
120 de 154
/* programa Calcula la media aritmtica */ #include "conio.h" #include "stdio.h" int N, i, Num; float Media, S; main() { clrscr(); gotoxy(10,10); printf("Digite El numero de trminos a promediar "); scanf("%d",&N); S=0; i=1; while (i<=N) { gotoxy(10,12);clreol(); printf("Digite el %d nmero ",i); scanf("%d",&Num); S=S+ Num; i++; } Media=S/N; gotoxy(10,14); printf("La media Aritmtica es %f",Media); getch(); }
14. Desarrolle un algoritmo que le permita leer N valores y calcule con dichos valores la media geomtrica n x1 * x 2 * x3 * ... * x n Anlisis: Leer los n valores no tendr inconvenientes porque se sabe que con la ayuda de una estructura de programacin cclica se puede realizar esta labor. Ahora la tarea a realizar es la multiplicacin sucesiva de los trminos que se irn a leer. En razn de lo anterior es necesario declarar una variable que servir de acumulador de la multiplicacin sucesiva con un valor inicial de 1, ya que este valor no afectar el resultado final. Al final del ciclo se realizar el calculo de la media geomtrica. Las tareas a ejecutar Dentro del ciclo son : Leer Acumular multiplicacin Fuera del ciclo son : Calcula la media Escribir el resultado
121 de 154
Algoritmo Diagrama de flujo

INICIO N S=1
Cdigo
/* programa Calcula la media geomtrica */ #include "conio.h" #include "stdio.h" #include "math.h" int N, i, Num; float Media, S; main() { clrscr(); gotoxy(10,10); printf("Digite El nmero de trminos a promediar "); scanf("%d",&N); S=0; i=1; while (i<=N) { gotoxy(10,12); clreol(); printf("Digite el %d nmero ",i); scanf("%d",&Num); S=S*Num; i++; } Media = pow(S,1/N); gotoxy(10,14); printf("La media Geomtrica es %f",Media); getch(); }
i=1
>
i:N
<=
Num Mediageo Mediageo= N s
S = S*Num
i++
FIN
122 de 154
CODIFICAR EN C LOS SIGUIENTES EJERCICIOS

15. Desarrolle un algoritmo que le permita leer N valores, sumar todos los valores y decir cual es el nmero mayor, cual es el menor y cual es la suma. Anlisis: El desarrollar algoritmos nos permite plantearlos de mltiples maneras. En el caso del ejercicio planteado es necesario leer un primer valor y asumir a ese valor como mayor y a su vez como menor. Luego se desarrolla la lectura de los N-1 valor restantes y cada vez que se tenga un nuevo valor se compara para saber si es mayor o menor de los almacenados anteriormente. Esta tarea se desarrolla con la ayuda de una estructura de decisin. Diagrama de flujo INICIO N,Num S=Num : i=1 May Men
>
i : N-1
<=
Num
No
Men, May, S
Si
Num>M
FIN
May
No
Num<M
Si
Men=Num
S = S+ i++
123 de 154
16. Desarrolle un algoritmo que le permita leer N valores y escriba los que sean mltiplos de 5. Anlisis: Apoyados en una estructura de programacin cclica se leen los N valores y con una estructura de decisin se decide si el numero ledo es o no mltiplo de cinco para escribirlo en caso afirmativo. Es de anotar que se desarrolla el ejercicio con una estructura completamente anidada dentro de otra. Diagrama de flujo INICI N i=1
>
i:N
<=
FIN
Num
No
Num%5
Si
Num
i++
124 de 154
17. Desarrolle un algoritmo que le permita leer N valores y escribir independientemente el promedio de pares e impares. Anlisis: Apoyados en una estructura de programacin cclica se leen los N valores y dentro del ciclo se verifica si es par o impar para as mismo acumularlo en variables independientes. Igualmente se van contando el nmero de trminos pares e impares por aparte. Al final se promediara la suma de cada uno entre el numero de trminos. Cada tarea se hace por aparte con variables diferentes. Diagrama de flujo INICI N I=0 P=0 i=1 Par=0 Imp=
>
i:N
<=
Num
No
Num%2
Si
PromPromProm-par, PromFIN
Imp=Imp+N I=I+1
Par=Par+Nu P=P+
i++
125 de 154
18. Desarrolle un algoritmo que le permita leer N valores y al final escribir si el mayor valor de los datos ledos es par o impar Anlisis: Se desarrolla la lectura de los N trminos con una estructura de programacin cclica. Como se trata de mantener el mayor valor, es necesario asumir inicialmente el primer valor como mayor almacenndolo en la variable May, y de ah en adelante cada vez que se lea un nuevo valor compararlo con May, por si es mayor entonces cambiar el valor a dicha variable. Al final del ciclo se chequea si dicho valor es par o impar. Diagrama de flujo INICI N i=1 Num May=Nu
>
i : N-1
<=
Num
No
Num>M
Si
May=Nu May%2 i++ El mayor es impar El mayor es par
FIN
126 de 154
19. Genere la serie de fibonnacci iniciando con valores 1 y 2. Cada nmero de la serie generada es la suma de los dos anteriores. Anlisis: La serie de fibonnacci inicia la generacin de nmeros a partir de dos valores iniciales. Cada nuevo valor generado es igual a la suma de los dos anteriores. En ese sentido el primer valor generado ser igual a la suma de los dos valores iniciales. Si se trata de generar N valores pues se apoya en una estructura cclica que le permita realizar esas N tareas. Ej: 0,1 (valores iniciales) 1,2,3,5,8,13,21,34 (8 valores generados)
Diagrama de flujo INICI N V1= 1 V2= i=1 > i:N < V3= V1 + V2 V1 = V2 V2 = V3 V3 i = i+1 FIN
127 de 154
20.
e =1+
1 1 1 + 2 + 3 + ... 2 2 2! 2 3!
INICIO N S=0 i=0 > i:N < S = S+ S

i
2
i =0
1 * (i!)
FIN
i = i+1
21. e x = 1 + x +
x2 x3 x4 + + + ...... 2! 3! 4!
INICI X, i, S=0 i=0 > i:N < S = S+ S X i!

i
i =0
FIN
i = i+1
128 de 154
22.
e sin ( x ) = 1 + sin( x ) +
sin 2 ( x ) sin 3 ( x ) sin 4 ( x ) + + + ...... 2! 3! 4!
INICIO X,i, S=0 i=0 > i:N < S

i
S =S+
i =0
(sen( X )) i!
FIN
i = i+1
23. Sin( x ) = x
x3 x5 x7 + + ... 3! 5! 7!
INICIO
X,i, S=0 i=1 > i:N < S =S+

i =1 N
S FIN
X 1 * ( 1)i + (2i 1)! i = i+1
2i 1
129 de 154
24. Sinh( x ) = x +
x 3 x5 x 7 + + + ... 3! 5! 7!
INICIO
X,i, S=0 i=1 > i:N < S =S+

i =1 N
S
2 i 1
X (2i 1)!
FIN
i = i+1
x2 x4 x6 25. Cos ( x ) = 1 + + ... 2! 4! 6!
INICIO X,i, S=0 i=0 > i:N < S =S+

i =0 N
S FIN
X * ( 1)i (2i )!
2i
i = i+1
130 de 154
26. Cos ( x ) = 1 +
x2 x4 x6 + + + ... 2! 4! 6!
INICIO X, N S=0 i=0 > i:N < S =S+

i =0 N
S
2i
X (2i )!
FIN
i = i+1
Los polinomios de legendre se calculan por medio de las frmulas: p0 = 1 p1 = x ....... 2n 1 n 1 pn = ( ) xpn 1 ( ) pn 2 n n donde n=2,3,4... y X es cualquier nmero entre -1 y 1. Desarrolle un algoritmo que genere una tabla de p n vs X, para cualquier valor de n hasta n=10; generando 201 valor de p n en cada tabla, para valores igualmente distanciados de x (esto es hacer x= -1,-0.99,-0.98,....0,0.01,0.02,...0.99,1).
131 de 154
El coeficiente binomial n! n como: = i (n i )!i!
n para enteros no negativos n e i (donde i<=n) se define i
Se tienen dos nmeros almacenados en las variables A y B. Desarrolle un algoritmo que permita dividir A con B pero utilizando el mtodo de restas sucesivas. El computador debe mostrar el resultado de la divisin en su parte entera y en su parte residual.
Aplicaciones en Ingeniera
Las races reales de una ecuacin se pueden calcular por diferentes mtodos uno de ellos es de Newton Raphson X n+1 = X n f (X n ) Donde Xn es el valor asumido inicialmente. f ( X n )
La Integral de una funcin se puede calcular de la siguiente manera. Mtodo rectangular: n= nmero de rectngulos
f ( x )dx = x( f ( xi )) donde xi = (a + (2 * i 1)x / 2)

i =1
Mtodo trapecial: n= nmero de trapecios
f ( x )dx =
n 1 x ( f (a) + f (b) + 2 f ( xi )) donde xi = a + ix 2 i =1
Mtodo de simpson: n= nmero de arcos de parbola
f ( x )dx =
n h ( f (a ) f (b) + 2 ( f ( x 2 i 1 ) + 2 f ( x 2 i )) donde h = x / 2 3 i =1
132 de 154
ESTRUCTURA DE SELECCIN MULTIPLE

Aunque el bloque if-else puede resolver mltiples comparaciones escalonadas, su uso puede ser engorroso y producir errores cuando las comparaciones son numerosas. El bloque switch permite un cdigo mas compacto y de mayor claridad interpretativa. El formato general del bloque es el siguiente: Switch (expresin entera) { case constante1: bloque de sentencias1; break; case constante2: bloque de sentencias2; break; case constante3: bloque de sentencias3; break; case constante4: bloque de sentencias4; break; default bloque de sentencias por defecto; } donde expresin entera es una expresin que devuelve un valor tipo entero o constante de caracter. ConstanteN es un numero entero o una constante de carcter. Break es una orden imperativa de salida de bloque. Default indica que de no cumplirse ninguna de las condiciones el programa ejecutara el bloque de sentencias por defecto. La diferencia de la estructura switch con el if son las siguientes: la sentencia switch solo puede comprobar la igualdad no pueden existir dos sentencias case en el mismo switch las constantes de tipo carcter se convierten automticamente en enteros.
133 de 154
Ejemplo:
#include "conio.h" #include "stdio.h" void menu(); void rectangular(); void trapezoidal(); void simpson(); void limites(); float funcion(float x); char op; float i,dx,xi,n,li,ls,area,s; main() { do { menu(); switch (op) { case '1':rectangular(); break; case '2':trapezoidal(); break; case '3':simpson(); break; } } while (op!='0'); } void menu() { clrscr(); gotoxy(10,6);printf("Menu Principal"); gotoxy(10,10);printf("1. Integral modelo Rectangular"); gotoxy(10,11);printf("2. Integral modelo Trapezoidal"); gotoxy(10,12);printf("3. Integral modelo Simpson"); gotoxy(10,13);printf("0. Opcion de Salir"); gotoxy(10,20);printf("Digite una opcion [ ]"); gotoxy(29,20);op=getch(); } void limites() { clrscr(); gotoxy(10,2);printf("Digitada de parametros para solucion a integral"); gotoxy(10,5);printf("Digite el limite inferior : ");scanf("%f",&li); gotoxy(10,7);printf("Digite el limite superior : ");scanf("%f",&ls); gotoxy(10,9);printf("Digite el numero de subareas : ");scanf("%f",&n); dx=(ls-li)/n; gotoxy(10,11);printf("El valor del dx es %f ",dx); }
134 de 154
void rectangular() { limites(); s=0; i=1; while (i<=n) { xi=(li+(2*i-1)*dx/2); s=s+funcion(xi); i++; } area=s*dx; gotoxy(10,15);printf("El valor de integral por rectangulos es %f",area); getch(); } void trapezoidal() { limites(); s=funcion(li)+funcion(ls); i=1; while (i<=n-1) { xi=(li+i*dx); s=s+2*funcion(xi); i++; } area=s*dx/2; gotoxy(10,15);printf("El valor de integral por trapecios es %f",area); getch(); } void simpson() { limites(); s=funcion(li)-funcion(ls); i=1; while (i<=n) { xi=(li+i*dx); s=s+4*funcion(li+(2*i-1)*dx/2)+2*funcion(li+i*dx); i++; } area=s*dx/6; gotoxy(10,15);printf("El valor de integral por arcos de parbola es %f",area); getch(); } float funcion(float x) { float f; f= x*x-4; return f;}
135 de 154
FUNCIONES
Definicin En C, una funcin es un bloque de instrucciones que realizan una tarea especfica la cual se maneja como una unidad lgica. Esta unidad, regresa opcionalmente un valor de acuerdo al proceso que realice. C es un programa de funciones, todo se hace a partir de ellas. La principales main() la cual, utiliza a otras que se encuentran definidas en las bibliotecas (todas las instrucciones que maneja C). Adems de stas, se puede definir nuestras propias funciones. De esta manera se dividen tareas grandes de computacin en varias ms pequeas lo que da como resultado que el programa sea ms fcil de entender y se pueda manejar ms eficientemente. Adems, al subdividir los programas en funciones, stas pueden ser reutilizadas en otros programas. En esta unidad se muestra como crear nuestras propias funciones. La forma general para definir una funcin es: Especificador_tipo Nombre_de_la_funcin (declaracin de parmetros) { cuerpo de la funcin } El especificador_de_tipo : este especificador de tipo de la funcin define la clase de valor que regresa la funcin. El valor puede ser cualquier tipo que maneje el lenguaje C. En caso de que no se especifique ninguno, la funcin devuelve por omisin un entero. Ej: Si el valor a retornar es un decimal entonces definimos la funcin de tipo float. Si el valor a retornar es un entero entonces definimos la funcin de tipo int. Y as sucesivamente
136 de 154
Nombre_de_la_funcin : es la palabra con la que se identificar la funcin. Cada funcin tiene un nombre nico. Con ese nombre, en cualquier otra parte del programa se pueden ejecutar los enunciados contenidos en la funcin. A esto se le conoce como la llamada de la funcin. Una funcin puede ser llamada desde el interior de otra funcin. Una funcin es independiente. Una funcin puede ejecutar su trabajo sin interferencia de , y sin interferir con, otras partes del programa. Una funcin ejecuta una tarea especifica. Esta es la parte fcil de la definicin. Una tarea es un trabajo concreto que un programa debe ejecutar como parte de su operacin general, como enviar una lnea de texto a la impresora, ordenar un arreglo en orden numrico o calcular una raz cubica. Una funcin puede regresar un valor al programa que la llama. Cuando el programa llama a una funcin, se ejecutan los enunciados que contiene. Estos, en caso de que se desee, pueden pasar informacin de regreso al programa que la llama. Declaracin de parmetros : La declaracin de parmetros es un conjunto de variables separados por comas y con un tipo de dato especfico que reciben los valores de los argumentos cuando se llama a la funcin. Una funcin puede carecer de parmetros en cuyo caso los parntesis estarn vacos tanto al declarar como al mandar llamar a la funcin. Por ejemplo: float multiplicacin (float multiplicando,float multiplicador) { multiplicando=multiplicando*multiplicador; return(multiplicando); } La funcin est declarada de tipo float porque es la clase de valor que va a regresar. Multiplicando y multiplicador es el nombre que le vamos a darlos valores que recibir la funcin para trabajar con ellos, los cuales son declarados dentro de los parntesis. Por ltimo se define el cuerpo de la funcin (delimitndose con llaves)
137 de 154
En este caso, se asigna el resultado de la multiplicacin a multiplicando para ahorrar memoria (se declara una variable menos) y regresa el valor obtenido por medio de la sentencia return. Return Esta sentencia se utiliza para devolver valores generados en una funcin al programa desde donde se hizo el llamado de la funcin. Tambin sirven para salir de la funcin donde se encuentra y continuar con la instruccin posterior a la funcin que lo llam. En la funcin anterior return(multiplicando); return multiplicando; devuelve el contenido de multiplicando al programa principal. En caso de que slo se quiera salir de la funcin, no es necesario indicarle parmetros, basta con return();. Todas la funciones, excepto las de tipo void (Es el tipo de datos que no tiene valor) generan valores que se transmiten al programa principal. Estos valores son de tipo int (entero) por omisin, pero puede regresarlos de todo tipo si as se declara; por ejemplo, en la funcin del ejemplo, la funcin regresa un valor de tipo float (flotante). Cuando se quiere utilizar el valor que devuelve la funcin en el programa principal, es necesario asignar la funcin a una variable del tipo de dato que va a regresar la funcin.
#include "conio.h" #include "stdio.h" #include "math.h" float fun(float x); float X,Z; main() { clrscr(); gotoxy(10,6); printf("Digite un valor X "); scanf("%f",&X); Z=fun(X); printf("La funcion evaluada en %4.2f es = %10.3f",X,Z); getch(); } float fun(float x) { float fx; fx=pow(x,7)-4*pow(x,3)+3*x; return fx; }
138 de 154
Reglas de las funciones - Una funcin puede tomar cualquier numero de parmetros, o ninguno. En caso de tener varios parmetros solo devolver un valor. - Una funcin se puede disear para que devuelva un valor, sin que sea obligatorio que lo haga. - Si una funcin tiene un tipo de devolucin void, no devolver ningn valor. Cuando intenta obtener un valor de una funcin con tipo de devolucin void, se produce un error de compilacin. Una funcin que devuelva void no necesita contener una instruccin return, aunque puede tenerla si as lo desea. Ambos mtodos son aceptables. Si no incluye una instruccin return, la funcin se devuelve automticamente cuando llega al final del bloque de funcin (la llave de cierre). - No se puede declarar funciones dentro de funciones ya que todas estn al mismo nivel. - Tampoco se puede ingresar al cdigo de una funcin si estamos fuera de la misma. - Las variables que se declaran en las funciones, son locales y no pueden ser utilizadas fuera de esa funcin. - Se pueden pasar variables a las funciones por valor, por apuntador o por referencia. Adems, si se utiliza una funcin dos o ms veces, la segunda vez que se llame a la funcin las variables locales no contendrn el valor que obtuvieron al ejecutar la primera vez la funcin y as sucesivamente ya que se crean al entrar a la funcin y se destruyen al salir. Si el llamado a la funcin se hace desde dentro de la misma funcin, los datos de las variables que estn dentro de la funcin se mantendrn. Argumentos de las funciones: Es muy comn que las funciones utilicen argumentos es decir, que necesiten de algn valor o valores externos dentro de su propio cdigo. Estos valores se pasan mediante variables llamadas parmetros formales de la funcin las cuales se declaran dentro de los parntesis que suceden al nombre de la funcin o bien, despus de estos y antes de la llave de comienzo. Asegrese de que de que los argumentos utilizados al declarar la funcin sean del mismo tipo que los usados para llamar la funcin. Si hay algn error en los tipos, el compilador no mandar mensaje de error pero se obtendrn resultados inesperados.
139 de 154
Puedes utilizar a las variables que son parmetros formales como cualquier otra variable local es decir, se les puede hacer asignaciones o usarlos en cualquier expresin permitida por C. Existen dos formas de pasar argumentos a una funcin: La primera es por medio de las llamadas por valor: Llamadas por valor Consiste en slo pasar el contenido de la variable utilizada como argumento a la subrutina. De esta manera, los cambios efectuados en los parmetros de la funcin no afectan a las variables (globales) que se utilizaron para hacer la llamada a la funcin.
#include "conio.h" #include "stdio.h" float cuadrado(float X); float Z,X; main() { clrscr(); gotoxy(10,2);printf("Cuadrado de un numero"); gotoxy(10,5);printf("Digite el primer numero : ");scanf("%f",&X); Z=cuadrado(X); gotoxy(10,9);printf("El cuadrado de %f es %f",X,Z); getch(); } float cuadrado(float y) { float X; X=y*y; return X; }
Llamadas por referencia La segunda forma es mediante las llamadas por referencia en la cual, lo que se pasa a la subrutina es la direccin de la variable que se est mandando como parmetro. De esta manera, los cambios que sufra el parmetro dentro de la subrutina, se efectuarn tambin en la variable que se introdujo como parmetro.
140 de 154
La forma de pasar una llamada por referencia es pasando un puntero al argumento, de esta manera, lo que pasar es la direccin de la variable en vez de su contenido. Para esto, los parmetros se declaran de tipo puntero. /*Ejemplo de funciones por valor y por referencia*/ /*Calcula dos veces el procentaje de gastos, la primera vez utilizando una funcin por valor y la segunda por referencia*/ #include<stdio.h> porcentaje_xvalor(float ingreso, float egreso) { egreso=((egreso/ingreso)*100) printf("Usted gasta el %.2f por ciento de lo quegana",egreso); } porcentaje_xref(float *ingreso,float *egreso) { *egreso=(((*egreso)/(*ingreso))*100); printf("Usted gasta el %.2f por ciento de lo quegana",egreso); } main() { float entrada,salida; clrscr(); printf("Entradas: "); scanf("%f",&entrada); printf("Salidad: "); scanf("%f",&salida); porcentaje_xvalor(entrada,salida); /*Llamada a la funcin porcentaje utilizando paso de parmetros por valor*/ printf("\n\n"); porcentaje_xref(&entrada,&salida); /*Utilizacin de la funcin porcentaje con paso de parmetros por referencia*/ getch(); }
141 de 154
En el programa anterior, realizamos la misma tarea dos veces pero de diferente manera. En porcentaje_xvalor(entrada,salida) mandamos el contenido de entrada y salida a la funcin donde son recibidos por ingreso y egreso respectivamente. De esta manera, el clculo del porcentaje se hace internamente es decir, utilizando las variables definidas en la funcin. Tanto entrada como salida, no se modifican. La funcin porcentaje_xref(&entrada,&salida) tambin obtiene el mismo resultado, pero en este caso, en vez de pasar los valores existentes en las variables, pasamos su direccin; por lo que trabajamos directamente con ellas dentro de la funcin an cuando las llamemos de diferente manera( ingresos y egresos). En esta ocasin, las variables globales si se modifican. Para comprobar esto, despus de compilar el programa (que no muestre errores), en vez de ejecutarlo con Ctrl-F9, dale F8, esto te permitir correr el programa paso a paso. Para ver los valores que van tomando las variables, teclea Ctrl-F7 y escribe el nombre de la variable que desees observar tal cual aparezca en el programa luego pulsa <ENTER>. Aparecer una ventana en la parte inferior de tu programa en la cual se indicar el estado o valor de la o las variables que hayas especificado. Observars que despus de haber ejecutado, la funcin porcentaje_xvalor, el contenido de las variables no cambiar mientras que despus de haber ejecutado porcentaje_xref, salida se ver modificada porque le asignamos un valor dentro de la funcin. En realidad, tanto las funciones que utilizan paso de parmetros por valor como las que utilizan el paso por referencia, pueden hacer las mismas cosas. Lo nico que cambia es la manera en que trabajan en la memoria de la computadora. Lo que tenemos que tener en cuenta para saber cul utilizar, es si queremos que las variables que utilizaremos en el parmetro de la funcin se modifiquen o no. No olvide que las variables que pase como parmetros deben ser del mismo tipo de las que estn declaradas dentro de los parntesis de la funcin. Ejemplo2:
#include "conio.h" #include "stdio.h" void cambio(float *num1,float *num2); float numero1,numero2;
142 de 154
main() { clrscr(); gotoxy(10,2);printf("Digitada de dos nmeros"); gotoxy(10,5);printf("Digite el primer numero : ");scanf("%f",&numero1); gotoxy(10,7);printf("Digite el segundo numero : ");scanf("%f",&numero2); cambio(&numero1,&numero2); gotoxy(10,9);printf("El primer numero ahora es %f\n",numero1); gotoxy(10,10);printf("El segundo numero ahora es %f\n",numero2); getch(); } void cambio(float *num1,float *num2) { float *temp; *temp=*num1; *num1=*num2; *num2=*temp; }
Creacin de Bibliotecas propias: Si se quiere utilizar funciones definidas por el usuario en varios programas, se puede hacer, creando una biblioteca propia. Esto se logra de la siguiente manera: - Define tus funciones en un nuevo archivo. Manda llamar las libreras estndar de C, que necesites. - No utilice la funcin main(). - Complalo - Cuando la compilacin sea exitosa, se generar un archivo con el mismo nombre que el tuyo pero con la terminacin Obj. Este archivo deber ser incluido preferentemente en el mismo directorio que se encuentre la biblioteca. En caso contrario, se debe dar la ruta en la seccin Directorios del men Options. - En el programa donde quieras utilizar esta unidad slo tendrs que mandarla llamar al principio del programa de la siguiente manera: #include "nombre_archivo" Despus de esto, puedes llamar a las funciones que tengas definidas en esta librera normalmente sin tener que declararlas al principio del programa. Adems de funciones, en la biblioteca tambin puede definir constantes, macros, etc. Intenta pasar a una biblioteca las funciones que hemos visto en este mdulo para que puedas utilizarlas posteriormente.
143 de 154
Programa ejemplo: En el programa que se muestra a continuacin, se convierte un nmero en hexadecimal a su representacin decimal. Es una demostracin muy sencilla de lo que es una funcin ya que en este manual existen otros programas que contienen funciones en los cuales podrs reafirmar este conocimiento. Complalo y ejectalo para que puedas comprenderlo mejor. /*Programa que convierte un nmero en hexadecimal a decimal*/ #include<math.h> #include<string.h> #include<conio.h> void main() { char hexa[10]; float numero; clrscr(); printf("Numero hexadecimal (maysculas): "); gets(hexa); numero=hex_dec(hexa); printf("\nEn decimal es : %.0f",numero); } float hex_dec(char cadena[]) { int i,j; char letra; float decimal=0; float temp=0; i=strlen(cadena); for (j=0;i>0;j++,i--) { letra=cadena[i-1]; switch(letra) { case 1:temp=(1*pow(16,j)); break; case 2:temp=(2*pow(16,j)); break; case 3:temp=(3*pow(16,j)); break; case 4:temp=(4*pow(16,j)); break; case 5:temp=(5*pow(16,j)); break; case 6:temp=(6*pow(16,j)); break; case 7:temp=(7*pow(16,j)); break; case 8:temp=(8*pow(16,j)); break; case 9:temp=(9*pow(16,j)); break; case 0:temp=(0*pow(16,j)); break;
144 de 154
case 'A':temp=(10*pow(16,j)); break; case 'B':temp=(11*pow(16,j)); break; case 'C':temp=(12*pow(16,j)); break; case 'D':temp=(13*pow(16,j)); break; case 'E':temp=(14*pow(16,j)); break; case 'F':temp=(15*pow(16,j)); break; } decimal+=temp; } return(decimal); } Funciones recursivas y Algoritmos Recursivos Una funcin que se llama a si misma un numero indefinido de veces, que se controla por la variacin de un cierto valor de una o varias variables dentro de la misma funcin, recibe el nombre de funcin recursiva. Un clsico ejemplo de recursividad es el calculo del factorial de un numero entero. Si bien la recursividad puede aadir brillantez a los programas, tenga en cuenta que su uso aumenta el trabajo de la pila y en muchos casos podr realizar la tarea con mayor facilidad acudiendo a un mtodo de iteracin clsica Ejemplo: 5! = 5*4*3*2*1 un pequeo anlisis de este ejemplo bastara para entender la recursividad: 5! Es lo mismo que 5*4! 4! Es lo mismo que 4*3! y asi sucesivamente. En general N! = N*(N-1)!. Utilizando esta expresin se puede obtener directamente un algoritmo recursivo para definirlo en trminos de factorial.
#include "conio.h" #include "stdio.h" int fun(int x); int X,Z; main() { clrscr(); gotoxy(10,6); printf("Digite un valor X "); scanf("%d",&X); Z=fun(X); gotoxy(10,8); printf("el factorial es %d",Z); getch(); } int fun(int N) { if (N==1)
145 de 154
return 1; else { N=N*fun(N-1); return N; }
146 de 154
ARREGLOS
Definicin Arreglos unidimensionales Forma de acceso a un elemento especfico del arreglo - Paso de arreglos a funciones - Utilizacin de arrays unidimensionales como cadenas - Arreglos bidimensionales - Arreglos multidimensionales - Inicializacin de arreglos con tamao - Inicializacin de arreglos sin tamao
Definicin Un arreglo es un conjunto de elementos del mismo tipo agrupados en una sola variable. Tambin se les conoce con el nombre de arreglos. Cada posicin de almacenamiento en un arreglo es llamada un elemento del arreglo. Para ingresar a un elemento en particular, utilizamos un ndice. Existen arreglos unidimensionales, bidimensionales y tridimensionales. Su uso ms comn es en la implementacin de cadenas de caracteres. Recuerda que en C no existen variables de tipo cadena por lo cual se utiliza un arreglo de caracteres. Fsicamente, un arreglo es un conjunto de localidades de memoria contiguas donde la direccin ms baja corresponde al primer elemento y la direccin ms alta al ltimo. En un arreglo de n elementos, stos ocuparan desde la casilla 0 hasta la n-1. Por si mismo, el nombre del arreglo apunta a la direccin del primer elemento del arreglo. Arreglos Unidimensionales un arreglo de una sola dimensin es un arreglo que tiene solamente un subndice. Un subndice es un numero encerrado en corchetes a continuacin del nombre del arreglo. Este numero puede identificar el numero de elementos individuales en el arreglo. La forma general para definir un arreglo de slo una dimensin es la siguiente:
147 de 154
Tipo_de_dato nombre_variable [tamao] ej: float x [10]; int y [10]; tipo_de_dato se refiere al tipo de dato de cada elemento del arreglo y tamao es la cantidad de elementos agrupados en la misma variable. Forma de acceso a un elemento especfico del arreglo Para accesar a uno de los elementos del arreglo en particular, basta con invocar el nombre del arreglo y especificar entre corchetes el nmero de casilla que ocupa el elemento en el arreglo.
Por ejemplo, si queremos accesar al cuarto elemento de un arreglo de 10, se invocara de la siguiente manera:
nombre_variable[10] se refiere al nombre con el cual se identificaran todos los datos que pertenezcan al arreglo y estn almacenados en memoria. Recuerde que el arreglo almacena desde la casilla 0. Por tanto, en un arreglo de 10 casillas, stas estn numeradas del 0 al 9. Paso de arreglos a funciones La forma de pasar un arreglo a una funcin consiste en llamar a la funcin y en el argumento, especificar el nombre del arreglo sin ninguna indexacin. Esto hace que se pase a la funcin la direccin del primer elemento del arreglo ya que en C no es posible pasar el arreglo completo como argumento. Por ejemplo: main() int conjunto[20]; clrscr(); . . funcion(conjunto); . . } Aqu, al pasar el arreglo conjunto a funcin, estamos pasando la direccin en memoria del primer elemento de conjunto. En caso de que dentro de la funcin
148 de 154
tuvisemos que accesar a algn elemento del arreglo, se pasa de la misma manera slo que dentro de la funcin utilizaremos los corchetes para accesar al elemento deseado. Hay tres formas de declarar un arreglo como parmetro formal: como un arreglo delimitado, como un arreglo no delimitado y como un puntero. Por ejemplo: #include<stdio.h> funcion1(int conjunto[20]) /*Delimitando el array*/ { . } o como funcion1(int conjunto[]) /*arreglo no delimitado*/ { . } o se puede declarar como funcion1(int *conjunto) /* como un puntero */ { . } El resultado de los tres mtodos de declaracin es idntico. Utilizacin de arreglos unidimensionales como cadenas El uso ms comn de los arreglos unidimensionales es la implementacin de una cadena (conjunto) de caracteres porque recuerde que en C no existe este tipo de datos. Por tanto, definimos una cadena en C como un arreglo de caracteres que al final tiene un caracter nulo ('\0'). Por esta razn es necesario que al declarar los arreglos estos sean de un caracter ms que la cadena ms larga que pueda contener. Por ejemplo si deseamos crear un cadena que contenga 5 caracteres la declaracin debe hacerse como sigue: char cadena[6];
149 de 154
Esto es con el fin de dejar el ltimo espacio para el caracter nulo. No es necesario aadir explcitamente el caracter nulo de las constantes de cadena porque el compilador de C lo hace automticamente. Algunas de las principales funciones que soporta C para el manejo de cadenas de caracteres son las siguientes: Nombre Definicin strcpy(s1,s2) Copia s2 en s1 strcat(s1,s2) Concatena s2 al final de s1 strlen(s1) Devuelve la longitud de s1 strcmp(s1,s2) Compara la cantidad de elementos de s1 y s2 Si son iguales, devuelve 0; menor que cero si s1 es Menor que s2 y mayor que 0 si s1>s2. Para una referencia ms amplia sobre estas y otras rdenes, busca estas funciones en el apndice B. arreglos bidimensionales Un arreglo bidimensional es un arreglo de arreglos unidimensionales. Constituyen la forma ms simple de los arreglos multidimensionales. Un arreglo bidimensional tiene dos subndices. Su forma general de declaracin es tipo_dato variable[primer ndice][segundo ndice]; El primer ndice corresponde a la filas y el segundo a las columnas. Cuando se utiliza un arreglo bidimensional como argumento de una funcin, realmente se pasa slo la direccin del primer elemento (el[0][0]). Sin embargo, la funcin que recibe un arreglo bidimensional como parmetro tiene que definir al menos la longitud de la segunda dimensin. Esto es necesario debido a que el compilador de C necesita "conocer" la longitud de cada fila para ordenar el arreglo correctamente. Por ejemplo, una funcin que recibe un arreglo bidimensional de 5,9 se declara as:
150 de 154
funcion(int matriz[][9]) { . . } No es necesario especificar la primera dimensin pero la segunda s ya que el compilador de C la necesita para saber donde empieza la segunda fila. Tambin podemos utilizar arreglos bidimensionales para crear arreglos de cadenas. El primer ndice indicara el nmero de cadenas y el segundo la longitud mxima de las cadenas. char mensajes[5][20]; En la declaracin anterior se especifica que tenemos un arreglo llamado mensajes el cual contiene 5 cadenas de 20 caracteres cada una. Para acceder a una cadena en especial, slo especificamos el nmero de cadena (de 0 al nmero de cadenas menos 1). Ejemplo: printf("%s",mensajes[3]); Aqu mandamos imprimir la cadena nmero 3 de la variable mensajes. Esto sera equivalente a printf("%s",mensajes[3][0]); aunque es ms comn utilizar la primera forma. Arreglos multidimensionales En C, podemos crear arreglos de dos o ms dimensiones el lmite de dimensiones, viene dado por el compilador. Su forma general de declaracin es tipo_dato variable [long ind 1][longindice 2]...[long indice N] donde tipo_dato es el tipo de dato de los elementos del arreglo y long ind 1, long ind 2...long ind N es la longitud de cada dimensin del arreglo. Este tipo de arreglos no se utiliza muy frecuentemente debido a el gran espacio en memoria que ocupan. Otra desventaja es que el acceso a un arreglo multidimensional dura ms tiempo que el requerido por uno del tipo unidimensional. Cuando se pasan arreglos multidimensionales a funciones, se tiene que declarar todo excepto la primera dimensin. Por ejemplo:
151 de 154
#include<stdio.h> funcion1(int multiarreglo[][3][[4][5]) { . } main() { int m[2][3][4][5]; funcion(m[][3][4][5]); {. . } Claro que si se desea, se puede especificar tambin la longitud de la primera dimensin. Inicializacin de arreglos con tamao En C, podemos inicializar (dar un valor determinado a la variable antes de usarla) arreglos globales y arreglos estticos locales en el momento de declararlos. No es posible inicializar arreglos globales no estticos. Su forma general de inicializacin es tipo_dato variable [tamao 1][tamao2]...[tamao] = {lista de valores}; Lista de valores es un conjunto de constantes, separadas comas, cuyo tipo es compatible con tipo_dato. La primera constante se coloca en la primera posicin del arreglo, la segunda constante en la segunda posicin, y as sucesivamente. Fjese que un punto y coma sigue a }. A continuacin tenemos la inicializacin de un arreglo unidimensional: int dgitos[5]={'0','1','2','3','4','5','6','7','8','9'}; En el caso de los arreglos unidimensionales de caracteres podemos inicializarlos abreviadamente con la forma: char variable [tamao]="cadena";
152 de 154
Por ejemplo: char nombre[6]="clase"; Lo anterior es lo mismo que si se inicializara nombre caracter a caracter como en el ejemplo de dgitos. char nombre[6]={'c','l','a','s','e'.'\0'}; Importante: Se debe estar seguro de que el arreglo que se declara es suficientemente largo para incluirlo. Esto es por lo que nombre tiene16 caracteres de longitud en vez de 15 que es la cantidad de letras ya que cuando se utiliza una cadena constante, el compilador proporciona la terminacin nula automticamente. Inicializacin de arreglos sin tamao En los arreglos con tamao, tenemos que calcular que la longitud del arreglo fuera lo suficientemente grande para que fueran almacenados todos los elementos que desebamos. Si tuviramos que inicializar varios arreglos de cadena seria fastidioso contar cuantos caracteres ocupa cada arreglo. Es posible que C calcule automticamente la longitud del arreglo utilizando la inicializacin de arreglos indeterminados la cual permite que el compilador de C cree automticamente un arreglo suficientemente grande para mantener todos los inicializadores presentes si el tamao del arreglo no est especificado. El uso de la inicializacin de los arreglos indeterminados permite al programador cambiar el contenido de cualquiera de las cadenas sin tener que reconsiderar el tamao del arreglo. Tambin puede utilizarse tambin en arreglos multidimensionales (2 o ms). En este caso, se debe especificar todo, sin considerar la dimensin que se encuentra ms a la izquierda para permitir al compilador de C indexar el arreglo adecuadamente. El mtodo es similar a la especificacin de parmetros de un arreglo. De este modo se pueden construir tablas de longitudes variables, y el compilador asignar automticamente el espacio suficiente para ellas. La ventaja de este tipo de declaracin sobre la versin del tamao determinado es que la tabla puede alargarse o acortarse sin cambiar las dimensiones del arreglo.
153 de 154
154 de 154
APENDICE A
INTRODUCCIN A LA PROGRAMACIN ESTRUCTURADA
APENDICE A
INTRODUCCIN A LA PROGRAMACIN EXTRUCTURADA

ETIMOLOGIA
Desde la antigedad la Programacin se ha venido dando un inters mutuo y esto se puede ver en la actualidad teniendo como base la ampliacin de las memorias centrales y las altas velocidades de los procesadores , el estilo de escritura de los programas se vuelve una de las caractersticas mas sobresalientes en la programacin
4.1. Tcnicas de programacin. En esta parte las herramientas de programacin son: El Diagrama de Flujo , pseudo cdigo, etc.
Diagrama de Flujo: Herramienta que constituye el fundamento de Programacin convencional siendo muy til en los programas de pequeo y Mediano complejidad.
4.2. Programacin modular.
Concepto: Es uno de los mtodos mas flexibles y potentes para mejorar la Calidad de un programa y su productividad, en lo cual dicho programa se divide En mdulos (partes independientes). Cada programa se tiene un modulo principal denominado programa Principal que controla a los submodulos que posteriormente se denominan sub. Programas. Los mdulos son independientes ya que ninguno tiene acceso Directo a otro modulo o sub. Programa, un modulo se puede modificar sin Radicalmente sin afectar a otros mdulos inclusive sin alterar su funcionamiento; a este proceso se le conoce tambin como el mtodo de divide y vencers (Divide and conquer). Programacin Modular
Raz
Modulo1
Modulo2
Modulo3
Modulo4
Modulo 11
Modulo12
Modulo13
Modulo14
Modulo15
Modulo 24
Modulo 25
Modulo 26
Modulo 27
Modulo30
Modulo 31
Modulo 41
A-1
APENDICE A
4.2.1. Tamao de los mdulos. Esto se origina debido a la complejidad del programa y para un fcil entendimiento por lo que lo el tamao mas usual de un mdulo seria de una pagina (40lineas de Instrucciones). Ejemplo: Disear un algoritmo que muestre los sgts resultados: Impresin de Cabeceras de un Informe. Lectura de Datos. Ejecutar Clculos Imprimir lneas detalladas de informacin. Imprimir totales. Solucin Modulo Principal: Llamada a sub. moduloImpresin de Cabeceras. Llamada a sub. moduloProceso de Datos. Llamada a sub. modulo Impresin de totales Fin del Proceso
Submodulo Impresin de Cabeceras: Instruccin para impresin de Cabeceras. Retorno al modulo Principal. Submodulo Proceso de Datos: Lectura de Datos. Ejecucin de Clculos. Impresin detallada de lneas. Retorno al modulo Principal.
Submodulo Impresin de totales: Instruccin de Impresin de totales. Retorno al modulo Principal.
4.2.2. Implementacin de los mdulos.
Esta implementacin se realiza teniendo en cuenta el lenguaje de programacin en la que se desea compilar el programa SINDO los ms comunes: Funciones ( Lenguaje C/C++) Subrutinas ( Lenguaje BASICC) Procedimientos (Lenguaje PASCAL) Subrutinas (Lenguaje FORTRAN) Secciones (Lenguaje COBOL) Funciones (En todos los lenguajes C, C++, ADA, ETC)
a) b) c) d) e) f)
A-2
APENDICE A
4.3. Programacin estructurada.

Concepto: Conjunto de Tcnicas que han hido evolucionando, estas tcnicas Empleadas aumentan considerablemente la productividad del programa reduciendo Tiempo, dinero, verificacin, compilacin, escritura y mantenimiento del programa Este tipo de programacin utiliza un numero limitado de estructuras de Control reduciendo a un mnimo los errores que pueden tener dicho programa .
Tipos de Programacin Estructurada

Recursos abstractos. Diseo descendente. (TOP-down). Teorema de la programacin estructurada: estructuras bsicas. Consiste en descomponer una determinada accin compleja en funcin de un Numero de acciones ms simples, capaces de ser ejecutadas por una Computadora y que constituirn sus instrucciones.
4.3.1. Recursos abstractos.
4.3.2. Diseo descendente. (Top-down). Concepto: Proceso mediante el cual un problema se descompone en una serie de
Niveles o pasos sucesivos de refinamiento (stepwise). Su Metodologa consiste en efectuar una relacin entre las sucesivas etapas de Estructuracin de modo que se relacionen unas con otras mediante entradas y Salidas de informacin, sea el problema se descompone en etapas o Estructuras jerrquicas. Diseo Descendente
4.3.3. Teorema de la programacin estructurada: estructuras bsicas.

Programa Propio: Posee un solo punto de entrada y uno de salida o fin para el control del programa. Existen caminos desde la entrada hasta la salida que se pueden seguir y que pasan por todas las partes del programa. Todas las instrucciones son ejecutables y no existen lazos o bucles infinitos (sinfn). Un Programa propio puede ser escrito utilizando solamente tres tipos de estructuras de control: Estructura secuencial. Estructura selectiva. Estructura repetitiva.
A-3
APENDICE A
4.4. Estructura secuencial.

Concepto: Es aquella en la que una accin (instruccin) sigue a otra en secuencia, Las tareas se suceden de tal modo que la salida de un programa es la entrada de Otro programa hasta llegar al final del proceso del programa. Estructura secuencial Accin 1
Accin 2
Accin n
Diagrama N- S (Estructura Secuencial)

Accin 1 Accin 2 .. .. .. .. .. .. .. .. Accin n Ejemplo: Calculo de la suma y producto de dos nmeros. Hallar su algoritmo: Solucin Inicio Leer (A) Leer (B) S A+B P A*B Escribir(s, p) Fin
A-4
APENDICE A
Diagrama de Flujo
Inicio
Leer A
Leer B S S A+B A*B
Escribir S, P Fin
4.5. Estructura selectiva. Funcin: Se utililiza para tomar decisiones lgicas; se denominan tambin
Estructuras de decisin o alternativas, primero se evala primero una condicin y en Funcin del resultado de la misma se realiza una opcin u otra. Su representacin se realiza o hace con palabras de pseudo cdigos (if, then, else) Espaol (si, entonces, si_no), con una figura geomtrica en forma de rombo o bien Con un triangulo en el interior de una caja rectangular (Diagrama de Flujo)
Tipos Alternativa simple (si-entonces/if-then). Alternativa doble(si-entonces-si_no / if- then- else). Alternativa mltiple(segn _sea ,caso de / case)
4.5.1Alternativa simple (si entonces / if then). Funcin: Ejecuta una determinada accin cuando se cumple una determinada
Accin: Si la condicin es verdadera entonces se ejecuta la accin SI (o acciones caso de ser SI una accin compuesta y constar de varias acciones) Si la condicin es falsa , entonces no hacer nada
A-5
APENDICE A
Representacin Grafica de una estructura de control (Diagrama N-S)

Verdadera Accin Pseudocodigo en Castellano S1 (accin compuesta) Si < Condicin> entonces < accin s11 > < accin s 12 > . . . Fin _ si Diagrama de Flujo Condicin Verdadera Acciones Falsa Condicin? Falsa
Pseudocodigo en castellano Si < condicin > entonces < accin SI > Fin _ si Pseudocodigo en Ingls If < condicin > then < Accin SI > Endif
.5.2. Alternativa doble(si-entonces-si_no / if- then- else).

Funcin: Ejecuta una o determinadas acciones cuando se cumple una o mas Acciones: Si la condicin es verdadera entonces se ejecuta la accin SI (o acciones caso de ser SI una accin compuesta y constar de varias acciones). Si la condicin es falsa, entonces se pasara a la accin sino (else); si los datos son incorrectos entonces en la accin sino se ingresara un cuadro de dialogo diciendo datos de entrada incorrectos.
A-6
APENDICE A
Diagrama de Flujo
Si
Accin S1
Condicin
no Accin S2
Pseudocodigo en Castellano Si < Condicin> entonces < Accin SI > Si_no < Accin S2 > Fin _ si Pseudocodigo en Ingls If < condicin > then < Accin SI > Else < Accin S2 > Endif Representacin del Algoritmo Diagrama N-S Condicin? Verdadera Accin S1 Falsa Accin S2
Pseudocodigo en Castellano S1 (accin compuesta) Si < Condicin> entonces < Accin s11 > . . . < Accin S 2n > si_no < Accin S21 > < Accin S22 > . < Accin S 1n > Fin _ si
A-7
APENDICE A
Ejemplo: Dados tres nmeros imprimir o escribir cual es el mayor (Pseudocodigo) Start Read: a, b, c If a > b and b > c then m m else m Write : m End c a b if b >a and a>c then
4.5.3. Alternativa mltiple (segn _sea, caso de / case) Concepto: Es aquella que evala una expresin que podr tomar N valores
distintos (1, 2, 3, 4,n) segn que elija uno de estos valores en la condicin, se realizara una de las n acciones, o lo que es igual, el flujo del algoritmo seguir un determinado camino entre los n posibles. Modelo (simplificado) Segn E hacer . . . Fin _ segn Diagrama de Flujo 1 Condicin 2 3 Accin S3 4 n
Accin S1
Accin S2
Accin S4
Accin Sn
A-8
APENDICE A
4.6. Estructura repetitiva.

Concepto: Son aquellas en las que especialmente se disea para todas aquellas aplicaciones en las cuales una operacin o conjunto de ellas deben repetirse muchas veces. Bucles (lazos: Son estructuras que repiten una secuencia de instrucciones un numero determinado de veces. Interaccin: Es el hecho de repetir la ejecucin de una secuencia de acciones; en otras palabras el algoritmo repite muchas veces las acciones. Al utilizar un bucle para sumar una lista de nmeros, se necesita saber cuantos nmeros se han de sumar, para poder detenerlo en el momento preciso; las dos principales preguntas ha realizarse en el diseo de un bucle son: Que contiene el bucle? y Cuntas veces se debe repetir? Casos Generales de Estructuras repetitivas 1) La condicin de Salida del bucle se realiza al principio del bucle (estructura mientras) 2) La condicin de Salida se origina al final del bucle; el bucle se verifica hasta que se verifique una cierta condicin 3) La condicin de salida se realiza con un contador que cuente el numero de interacciones. ( i es un contador que cuenta desde el valor inicial (vi.) hasta el valor final (vf) con los incrementos que se consideran.)
4.6.1. Estructura mientras (while). Concepto: Es aquella en que el cuerpo del bucle se repite mientras se cumple una determinada condicin. Cuando se ejecuta la accin mientras, la primera
cosa que sucede es que se evala la condicin (una expresin booleana), si se evala falsa ninguna accin se tomara y el programa en la siguiente instruccin del bucle; si la expresin booleana es verdadera, entonces se ejecuta el cuerpo del bucle, depuse del cual se evala de nuevo la expresin booleana. Esta expresin booleana se repite una y otra vez mientras la expresin booleana (condicin) sea verdadera Expresin de un Bucle cero veces En una estructura mientras la primera cosa que sucede es la evaluacin de la expresin booleana; si es falsa en este punto entonces el cuerpo del bucle nunca se ejecuta. Puede parecer intil ejecutar el cuerpo del bucle cero veces, ya que no tendr efecto en ningn valor o salida. Sin embargo no es una accin deseada Bucles infinitos Algunos bucles no existen fin y otros no encuentran el fin por error en su diseo, el bucle y el programa corren siempre, o al menos hasta que la computadora se apaga; en otras ocasiones el bucle no se termina nunca por que nunca se cumple la condicin.
A-9
APENDICE A
Regla Prctica Las pruebas o tesis en las expresiones booleanas es conveniente que sean mayor o menor que en lugar de pruebas de igualdad o desigualdad. En el caso de la codificacin en un lenguaje de programacin, esta regla debe seguirse rgidamente el caso de comparacin de nmeros reales.
4.6.2. Estructura repetir (repeat).

Bucle no se ejecutara, por ello se necesitan de otros tipos de estructuras Dicha estructura se ejecuta hasta que cumpla una condicin Determinada que se comprueba hasta el final del bucle
Concepto: si el valor de la expresin booleana es inicialmente falso, el cuerpo del
Diferencias entre las estructuras mientras y repetir La estructura mientras termina cuando la condicin es falsa, mientras que repetir termina cuando la condicin es verdadera. En la estructura repetir el cuerpo del bucle se ejecuta siempre al menos una sola vez; por el contrario mientras es mas general y permite la posibilidad de que el bucle pueda no ser ejecutado. Para usar la estructura repetir debe estar seguro de que el cuerpo del bucle se repetir al menos una sola vez.
4.6.3. Estructura desde/para (for).
Concepto: Son el numero total de veces que se desea ejecutar las acciones del Bucle (numero de interacciones fijo), este ejecuta las acciones del cuerpo o del Bucle un numero especifico de veces y de modo automtico controla el numero de Interacciones o pasos a travs del cuerpo del bucle.
4.6.4. Salidas internas de los bucles.

Concepto: Esta nueva estructura solo esta disponible en algunos lenguajes de programacin especficos la denominaremos salir o iterar para diferenciarla de repetir _hasta ya conocida .las estructuras de bucles suelen ser validas en estructuras mientras, repetir, desde .La estructura salir no produce un programa legible y comprensible mientras lo hacen mientras y repetir por lo que le recomendamos que no disponga nunca de esta estructura aunque el lenguaje a utilizar lo tenga.
4.7. Estructura de decisiones anidadas encajadas.

Concepto: Estas estructuras si entonces y si entonces si_no implican la seleccin de una de las alternativas ya que tambin se puede disear estructuras de seleccin que contengan mas de dos alternativas; o sea pueden contener una u otra y as sucesivamente cualquier numero de veces , a su vez dentro de cada estructura pueden existir diferentes acciones.
A-10
APENDICE A
4.8. Estructura repetitivas anidadas.

Reglas La estructura interna debe estar incluida debe estar incluida dentro de la externa y no puede existir solapamiento Tipos de Bucles anidados Bucles anidados Correctos
a)
b)
Bucles anidados incorrectos
c)
d)
Nota: Las variables ndices o de control de los bucles toman valores de modo tal que por cada valor de la variable ndice del ciclo externo se debe ejecutar totalmente el bucle internos .Es posible anidar cualquier tipo de estructura selectiva con tal que cumpla las condiciones de la grafica vista anteriormente
A-11
APENDICE A
4.9. La instruccin ir_a (goto).

Aunque la instruccin ir_a (goto) la tienen todos los lenguajes de programacin en su Juego de instrucciones, existen mas que dependen de ella que de otros (BASICC, FORTRAN. En general, no existe ninguna necesidad de utilizar esta instruccin, ya que esta instruccin ha sido tema de confusin y controversia por lo que los Programadores recomiendan no utilizarla en sus algoritmos y programas PASCALHuye de esta instruccin considerndola como nefasta y no se utiliza- ya que es ms Difcil de leer y comprenderlo que otro mismo programa bien escrito, Solamente esta instruccin se recomienda utilizar en la salida de bucles.Las bifurcaciones o saltos Producidos por esta instruccin debe realizarse a programas o instrucciones que Estn enumeradas o que presenten otra referencia para el salto
A-12
APENDICE A
EJERCICIOS 4.1. Determinar la media de una lista indefinida de nmeros positivos, terminados con un Nmero negativo. 4.2. Dado el nombre o nmero de un mes y si el ao es o no bisiesto, deducir el nmero de das del mes. 4.3. Sumar los nmeros enteros de 1 a 100 mediante: a) estructura repetir b) estructura mientras c) estructura desde 4.4. Determinar la media de una lista de nmeros positivos terminada con un nmero no Positivo despus del ltimo nmero vlido. 4.5. Imprimir todos los nmeros primos entre 2 y 1000 inclusive. 4.6. Se desea leer las calificaciones de una clase de informtica y contar el nmero total de aprobados (5 o mayor que 5) 4.7. Leer las notas de una clase de Informtica y deducir todas aquellas que sean Notables (>= 7 y <9) 4.8. Leer 100 nmeros .Determinar la media de los nmeros positivos y la media de los Nmeros negativos. 4.9. Un comercio dispone de dos tipos de artculos en fichas correspondientes a diversas Sucursales con los siguientes campos: a) Cdigo del artculo A o B b) precio unitario del artculo c) nmero de artculos La ltima ficha del archivo del artculo tiene un cdigo de artculo, una letra se pide: a) el nmero de artculos existentes en cada categora b) el importe total de los artculos de cada categora 4.10. Una estacin climtica proporciona un par de temperaturas diarias (Mxima, mnima)(no es posible que alguna o ambas temperaturas sea 9 grados).La Pareja fin de temperaturas es 0,0.Se pide determinar el nmero de das ,cuyas Temperaturas se han proporcionado, las medias mxima y mnima, el nmero de Das cuyas temperaturas se han proporcionado, las medias mxima y mnima, el Nmero de errores-temperaturas de o__y el porcentaje que representaban. 4.11. Calcular: 2 E(x) = 1+x+x ++n 2! n! n
4.12. Calcular el ensimo trmino de la serie de Fibonanci definida por: A1 = 1 A2 = 1 A3 = 1 + 2 = A1 + A2 An-1 + An-2 (n >=3)
A-13
APENDICE A
4.13. Se pretende leer todos los empleados de una empresa__situados en un archivo empresa__ y a la terminacin de la lectura del archivo se debe visualizar un Mensaje existen trabajadores mayores de 65 aos en un nmero de t trabajadores mayores de 65 aos. 4.14. Un capital c est situado a un tipo de inters R, al trmino de cuntos aos se Doblara? 4.15. Los empleados de una fbrica trabajan en dos turnos, diurno y nocturno.Se desea Calcular el jornal diario de acuerdo con los siguientes puntos: a) la tarifa de las horas diurnas es de 500 pesetas b) la tarifa de las horas nocturnas es de 800 pesetas c) caso de ser domingo, la tarifa se incrementar en 200 pesetas el turno diurno 300 Pesetas el turno nocturno. 4.16. Averiguar si dados dos nmeros ledos del teclado, uno es divisor de otro. 4.17. Se introduce la hora del da en horas, minutos y segundos desea escribir la hora correspondiente al siguiente segundo. 4.18. Se desea conocer una serie de datos de una empresa con 50 empleados: a) Cuntos empleados ganan ms de 300.000 pesetas al mes( salarios altos) b) entre 100.000 y 300.000 pesetas (salarios medios) c) Menos de 100.000 pesetas (salarios bajos empleados a tiempo parcial)? 4.19. Imprimir una tabla de multiplicar como ** 1* 2* 3* 4* . . . 15* 1 2 3 ** ** ** ** 1 2 3 2 4 6 3 6 9 4 8 12 4 4 8 12 16 ** 15 15 30 45 60
15
30
45
60
225
4.20. Dado un entero positivo n(>1),comprobar si es primo o completo .
A-14
APENDICE B
APUNTADORES EN C Y C++
APENDICE B
Apuntadores en C y C++
Universidad de Carabobo Facultad Experimental de Ciencias y Tecnolog a Prof. Marcos A. Gil T. 8 de diciembre de 2004
1.
Introduccin o
Los apuntadores en C y C++ son una herramienta muy potente de programacin que suele causar mucha o confusin en los estudiantes que la estn aprendiendo. Adems, cuando los programadores cometen un error o a a en su utilizacin, puede ser muy dif encontrar el error, por lo cual es importante saber utilizarlos muy o cil bien. El uso de apuntadores en C y C++ es muy importante debido a que permite hacer los programas ms a ecientes y ms exibles. En en este art a culo se explica de una manera sencilla y breve todo lo referente a la utilizacin de apuntadores tanto en C como en C++. o Todo lo explicado en este art culo aplica tanto para C como para C++, a menos que se especique un lenguaje en particular. En algunos ejemplos de cdigo que son aplicables a C aparecen instrucciones de o entrada y salida de las librer estndar de C++. as a
2.
Denicin de apuntador o
Cuando se declara una variable, el compilador reserva un espacio de memoria para ella y asocia el nombre de sta a la direccin de memoria desde donde comienzan los datos de esa variable. Las direcciones de memoria e o se suelen describir como nmeros en hexadecimal. u Un apuntador es una variable cuyo valor es la direccin de memoria de otra variable. Se dice que un o apuntador apunta a la variable cuyo valor se almacena a partir de la direccin de memoria que contiene el o apuntador. Por ejemplo, si un apuntador p almacena la direccin de una variable x, se dice que p apunta a o x .
3.
Referenciacin o
La referenciacin es la obtencin de la direccin de una variable. En C y C++ esto se hace a travs del o o o e operador &, aplicado a la variable a la cual se desea saber su direccin. Ntese que se trata de un operador o o unario. Ejemplo: Cdigo C y C++ o int x = 25; cout << "La direccin de x es: " << &x << endl; o
Este cdigo imprime un valor del estilo 0x4fffd34. Este valor puede variar durante cada ejecucin del o o programa, debido a que el programa puede reservar distintos espacios de memoria durante cada ejecucin. o
B-1
APENDICE B
4.
Declaracin de apuntadores o
Para declarar un apuntador se especica el tipo de dato al que apunta, el operador *, y el nombre del apuntador. La sintaxis es la siguiente: <tipo de dato apuntado> *<indenticador del apuntador> A continuacin se muestran varios ejemplos: o Cdigo C y C++ o int *ptr1; // Apuntador a un dato de tipo entero (int) char *cad1, *cad2; // Dos apuntadores a datos de tipo carcter (char) a float *ptr2; // Apuntador a un dato de tipo punto-flotante (float)
5.
Asignacin de apuntadores o
Se pueden asignar a un apuntador direcciones de variables a travs del operador de referenciacin (&) o e o direcciones almacenadas en otros apuntadores. Ejemplos: Cdigo C y C++ o int i = 5; int *p, *q; p = &i; q = p; // Se le asigna a p la direccin de i o // Se le asigna a q la direccin almacenada en p (la misma de i) o
6.
Desreferenciacin de apuntadores o
La desreferenciacin es la obtencin del valor almacenado en el espacio de memoria donde apunta un o o apuntador. En C y C++ esto se hace a travs del operador *, aplicado al apuntador que contiene la e direccin del valor. Ntese que se trata de un operador unario. Ejemplos: o o Cdigo C y C++ o int x = 17, y; int *p; p = &x; cout << "El valor de x es: " << *p << endl; // Imprime 17 y = *p + 3; // A y se le asigna 20
C++ adems provee el operador binario ->, utilizado para obtener campos de un registro con un apuntaa dor al mismo de una manera ms fcil y legible. Muchos compiladores de C tambin soportan este operador. a a e Ejemplo:
B-2
APENDICE B
Cdigo C++ o struct Data { char nombre[20]; int edad; }; Data d; Data *pd = &d; (*pd).edad = 23; // Acceso al campo edad utilizando el operador . pd->edad = 23; // Acceso al campo edad utilizando el operador ->
7.
Vericacin de tipos en apuntadores o
Al igual que el resto de las variables, los apuntadores se enlazan a tipos de datos espec cos (apuntadores a variables de cierto tipo), de manera que a un apuntador slo se le pueden asignar direcciones de variables o del tipo especicado en la declaracin del apuntador. Ejemplo: o Cdigo C y C++ o int *p1; float *p2; int x; p1 = &x; // Esto es vlido a p2 = &x; // Esto no es vlido (el compilador genera un error) a
8.
Direcciones invlidas y la direccin NULL a o
Normalmente, un apuntador inicializado adecuadamente apunta a alguna posicin espec o ca de la memoria. Sin embargo, algunas veces es posible que un apuntador no contenga una direccin vlida, en cuyo caso o a es incorrecto desreferenciarlo (obtener el valor al que apunta) porque el programa tendr un comportamiento a impredecible y probablemente errneo, aunque es posible que funcione bien. Un apuntador puede contener o una direccin invlida debido a dos razones: o a 1. Cuando un apuntador se declara, al igual que cualquier otra variable, el mismo posee un valor cualquiera que no se puede conocer con antelacin, hasta que se inicialice con algn valor (direccin). Ejemplo: o u o Cdigo C y C++ o float *p; cout << "El valor apuntado por p es: " << *p << endl; // Incorrecto *p = 3.5; // Incorrecto 2. Despus de que un apuntador ha sido inicializado, la direccin que posee puede dejar de ser vlida si e o a se libera la memoria reservada en esa direccin, ya sea porque la variable asociada termina su mbito o a o porque ese espacio de memoria fue reservado dinmicamente y luego se liber1 . Ejemplo: a o
1 La
asignacin dinmica de memoria se explica en la seccin 13 o a o
B-3
APENDICE B
Cdigo C y C++ o int *p, y; void func() { int x = 40; p = &x; y = *p; // Correcto *p = 23; // Correcto } void main() { func(); y = *p; // Incorrecto *p = 25; // Incorrecto }
Si se intenta desreferenciar un apuntador que contiene una direccin invlida pueden ocurrir cosas como o a las siguientes: Se obtiene un valor incorrecto en una o ms variables debido a que no fue debidamente inicializada a la zona de memoria que se accede a travs de la direccin en cuestin. Esto puede ocasionar que el e o o programa genere resultados incorrectos. Si casualmente la direccin es la misma de otra variable utilizada en el programa, o est dentro del o a rango de direcciones de una zona de memoria utilizada, existe el riesgo de sobreescribir datos de otras variables. Existe la posibilidad de que la direccin est fuera de la zona de memoria utilizada para almacenar o e datos y ms bien est, por ejemplo, en la zona donde se almacenan las instrucciones del programa. Al a e intentar escribir en dicha zona, fcilmente puede ocurrir que el programa genere un error de ejecucin a o y el sistema operativo lo detenga, o que el programa no responda y deje al sistema operativo inestable. En muchos casos el sistema operativo detecta el acceso inadecuado a una direccin de memoria, en cuyo o caso detiene abruptamente el programa. Cuando no se desea que un apuntador apunte a algo, se le suele asignar el valor NULL, en cuyo caso se dice que el apuntador es nulo (no apunta a nada). NULL es una macro t picamente denida en archivos de cabecera como stdef.h y stdlib.h. Normalmente, en C++ se encuentra disponible sin incluir ningn archivo u de cabecera. NULL se suele denir en estas librer as as : Cdigo C y C++ o #define NULL 0
Un apuntador nulo se utiliza para proporcionar a un programa un medio de conocer cundo un apuntador a contiene una direccin vlida. Se suele utilizar un test condicional para saber si un apuntador es nulo o no o a lo es, y tomar las medidas necesarias. El valor NULL es muy util para la construccin de estructuras de o datos dinmicas, como las listas enlazadas, matrices esparcidas, etc. Es igualmente incorrecto desreferenciar a el valor NULL por las mismas razones presentadas previamente.
9.
Apuntadores a apuntadores
Dado que un apuntador es una variable que apunta a otra, fcilmente se puede deducir que pueden existir a apuntadores a apuntadores, y a su vez los segundos pueden apuntar a apuntadores, y as sucesivamente. Estos 4
B-4
APENDICE B
apuntadores se declaran colocando tantos asteriscos (*) como sea necesario. Ejemplo: Cdigo C y C++ o char c = z; char *pc = &c; char **ppc = &pc; char ***pppc = &ppc; ***pppc = m; // Cambia el valor de c a m
10.
Apuntadores constantes y apuntadores a constantes
Es posible declarar apuntadores constantes. De esta manera, no se permite la modicacin de la direccin o o almacenada en el apuntador, pero s se permite la modicacin del valor al que apunta. Ejemplo: o Cdigo C y C++ o int x = 5, y = 7; int *const p = &x; // Declaracin e inicializacin del apuntador constante o o *p = 3; // Esto es vlido a p = &y; // Esto no es vlido (el compilador genera un error) a
Tambin es posible declarar apuntadores a datos constantes. Esto hace que no sea posible modicar el e valor al que apunta el apuntador. Ejemplo: Cdigo C y C++ o int x = 5, y = 7; const int *p = &x; // Declaracin e inicializacin del apuntador a constante o o p = &y; // Esto es vlido a *p = 3; // Esto no es vlido (el compilador genera un error) a y = 3; // Esto es vlido a
11.
Apuntadores, arreglos y aritmtica de apuntadores e
Los arreglos y apuntadores estn fuertemente relacionados. El nombre de un arreglo es simplemente a un apuntador constante al inicio del arreglo. Se pueden direccionar arreglos como si fueran apuntadores y apuntadores como si fueran arreglos. Ejemplos: Cdigo C y C++ o int lista_arr[5] = {10, 20, 30, 40, 50}; int *lista_ptr; lista_ptr = lista_arr; // A partir de aqu ambas variables apuntan al mismo sitio cout << lista_arr[0]; // Imprime 10 cout << lista_ptr[0]; // Instruccin equivalente a la anterior o cout << *lista_arr; // Instruccin equivalente a la anterior o cout << *lista_ptr; // Instruccin equivalente a la anterior o cout << lista_arr[3]; // Imprime 40 cout << lista_ptr[3]; // Instruccin equivalente a la anterior o
Es posible sumar y restar valores enteros a un apuntador. El resultado de estas operaciones es el desplazamiento de la direccin de memoria hacia adelante (suma) o hacia atrs (resta) por bloques de bytes del o a tamao del tipo de dato apuntado por el apuntador. Esto permite recorrer arreglos utilizando apuntadores. n Ejemplos: 5
B-5
APENDICE B
Cdigo C y C++ o int lista[5] = {10, 20, 30, 40, 50}; int *p; char cad[15]; char *q; p = &lista[3]; p = lista + 3; cout << lista[2]; cout << *(lista+2); // // // // p almacena la direccin de la posicin 3 del arreglo o o Instruccin equivalente a la anterior o Imprime 30; Instruccin equivalente a la anterior o
// Las siguientes instrucciones imprimen la palabra "Programando" /* Nota: Recurdese que una constante de cadena de caracteres es e una secuencia de caracteres en memoria seguidos del cracter nulo */ a strcpy(cad, "Programando"); for (q = cad; *q != \0; q++) cout << q;
Tambin es posible restar dos apuntadores. El resultado de esta operacin es el nmero de bloques de e o u bytes que hay entre las dos direcciones del tamao del tipo de dato apuntado por los apuntadores. Ejemplo: n Cdigo C y C++ o double x[5] = {1.1, 2.1, 3.1, 4.1, 5.1}; double *p = &x[1], *q = &x[4]; int n; n = q - p; // a n se le asigna 3
12.
Apuntadores para paso de parmetros por referencia a
El lenguaje C no provee una manera de pasar parmetros por referencia. Sin embargo, es posible hacerlo a a travs del uso de apuntadores. A continuacin se muestra un ejemplo del paso de un parmetro por referencia e o a en C++, y luego un cdigo equivalente en C o C++ utilizando un apuntador: o Cdigo C++ o void suma(int a, int b, int& r) { r = a + b; } void main() { int x; suma(7, 5, x); cout << "7 + 5 = " << x; }
B-6
APENDICE B
Cdigo C y C++ o void suma(int a, int b, int *r) { *r = a + b; } void main() { int x; suma(7, 5, &x); cout << "7 + 5 = " << x; }
Ntese que en ambos casos se utiliza el operador & para cosas distintas. El operador & tiene dos o signicados como operador unario: sealacin de parmetro por referencia y operador de referenciacin. n o a o
13.
Asignacin dinmica de memoria o a
Los programas pueden crear variables globales o locales. Las variables declaradas globales en sus programas se almacenan en posiciones jas de memoria, en la zona conocida como segmento de datos del programa, y todas las funciones pueden utilizar estas variables. Las variables locales se almacenan en la pila (stack ) y existen slo mientras estn activas las funciones donde estn declaradas. En ambos casos el espacio de o a a almacenamiento se reserva en el momento de la compilacin del programa. o Tambin es posible reservar y utilizar memoria dinmicamente, tomada de la zona de memoria llamada e a mont culo (heap) o almacn libre. En C estn disponibles varias funciones que permiten realizar reservar y e a librerar memoria, pero C++ adems provee un mtodo ms fcil y seguro de hacerlo. a e a a
13.1.
Asignacin dinmica de memoria al estilo de C o a
Para asignar memoria dinmicamente en C se utilizan las funciones malloc() y free(), denidas t a picamente en el archivo de cabecera stdlib.h. La funcin malloc() reserva memoria y retorna su direccin, o o o retorna NULL en caso de no haber conseguido suciente memoria; y la funcin free() permite liberar la o memoria reservada a travs de un apuntador. La sintaxis de ambas funciones es como sigue: e Cdigo C y C++ o void *malloc(size_t tam_bloque); // size_t es un tipo de datos entero. // tam_bloque es el tama~o en bytes n // del bloque de memoria a reservar. void free(void *bloque); // bloque es un apuntador a la zona // de memoria a liberar.
Como se puede apreciar, malloc() reserva memoria sin importar el tipo de datos que se almacenar en a ella, retornando un apuntador a void. Por esta razn, se hace necesario convertir el tipo de apuntador al o tipo del apuntador que guardar la direccin. Tambin es necesario calcular exactamente cuntos bytes se a o e a requieren reservar, ayudndose con el uso del operador sizeof. Ejemplos: a
B-7
APENDICE B
Cdigo C y C++ o typedef struct { char nombre[20]; int edad; } Data; Data *p_data; // Declaracin de un apuntador a Data o int i; p_data = (Data*) malloc(sizeof(Data)); // Reservacin de memoria para un registro o if (p_data != NULL) { strcpy(p_data->nombre, "Rachel"); p_data->edad = 21; free(p_data); } // Reservacin de memoria para un arreglo de 10 registros o p_data = (Data*) malloc(sizeof(Data)*10); if (p_data != NULL) // Verificacin de reservacin o o { // Lectura de datos del arreglo for (i = 0; i < 10; i++) cin >> p_data[i].nombre >> p_data[i].edad; // Liberacin de memoria del arreglo o free(p_data); } // Verificacin de reservacin o o // Inicializacin de datos o // en la memoria reservada // Liberacin de memoria o
13.2.
Asignacin dinmica de memoria al estilo de C++ o a
Para asignar memoria dinmicamente en C++ se utilizan los operadores new y delete. El operador new a reserva memoria para un tipo de datos espec co y retorna su direccin, o retorna NULL en caso de no haber o conseguido suciente memoria; y el operador delete permite liberar la memoria reservada a travs de un e apuntador. La sintaxis de ambos operadores es como sigue: Para reservar y liberar un solo bloque: <apuntador> = new <tipo de dato> delete <apuntador> Para reservar y liberar varios bloques (un arreglo): <apuntador> = new <tipo de dato>[<nmero de bloques>] u delete [] <apuntador> El tipo del apuntador especicado del lado izquierdo del operador new debe coincidir con el tipo especicado del lado derecho. De no ser as se produce un error de compilacin. Ejemplos: , o
B-8
APENDICE B
Cdigo C++ o struct Data { char nombre[20]; int edad; }; Data *p_data; // Declaracin de un apuntador a Data o int i; p_data = new Data; // Reservacin de memoria para un registro o if (p_data != NULL) { strcpy(p_data->nombre, "Rachel"); p_data->edad = 21; delete p_data; } // Reservacin de memoria para un arreglo de 10 registros o p_data = new Data[10]; if (p_data != NULL) // Verificacin de reservacin o o { // Lectura de datos del arreglo for (i = 0; i < 10; i++) cin >> p_data[i].nombre >> p_data[i].edad; // Liberacin de memoria del arreglo o delete [] p_data; } // Verificacin de reservacin o o // Inicializacin de datos o // en la memoria reservada // Liberacin de memoria o
14.
Bibliograf a
El presente art culo fue realizado con la ayuda del libro Programacin en C++, del autor Luis Joyanes o Aguilar, editorial Mc Graw Hill.
B-9
APENDICE C
TUTORIAL SOBRE APUNTADORES Y ARREGLOS EN C
APENDICE C
TUTORIAL SOBRE APUNTADORES Y ARREGLOS EN C

por Ted Jensen
Versin 1.2 Febrero de 2000 El material aqu presentado est en el dominio pblico. Disponible en diferentes formatos en: http://www. netcom.com/~tjensen/ptr/cpoint.htm
CONTENIDO
Prefacio .................................................................................................................. 2 Introduccin .......................................................................................................... 3 Captulo 1: Captulo 2: Captulo 3: Captulo 4: Captulo 5: Captulo 6: Captulo 7: Captulo 8: Captulo 9: Qu es un Apuntador? ................................................................ 4 Tipos de Apuntadores y Arreglos................................................. 9 Apuntadores y Cadenas. ............................................................... 13 Ms sobre Cadenas. ...................................................................... 17 Apuntadores y Estructuras. .......................................................... 19 Ms sobre Cadenas y Arreglos de Cadenas. ................................ 23 Ms sobre Arreglos Multidimensionales...................................... 27 Apuntadores a Arreglos................................................................ 29 Apuntadores y Gestin Dinmica de Memoria. ........................... 31
Captulo 10: Apuntadores a Funciones ............................................................. 38 Eplogo .................................................................................................................. 49
Traducido al espaol por Marte Baquerizo martemorfosis@yahoo.com.mx Universidad de los Altos de Chiapas. Mxico. Junio de 2003
C-1
APENDICE C
PREFACIO
Este documento pretende dar una introduccin sobre apuntadores a los programadores novatos del lenguaje C. Despus de varios aos de leer y de contribuir en varias conferencias de C, incluyendo aquellas en FidoNet y UseNet, he notado que un buen nmero de principiantes en C presentan dificultades en comprender los fundamentos sobre apuntadores. Es por esto que me he dado a la tarea de tratar de explicarlos en un lenguaje simple y con un montn de ejemplos. La primera versin de este documento se otorg al dominio pblico, al igual que esta. Fue recogida por Bob Stout quien la incluy como un archivo de nombre PTR -HELP.TXT en su ampliamente distribuida coleccin de SNIPPETS. Desde esa edicin original de 1995, he aadido una cantidad significativa de material y corregido algunos pequeos errores. En la versin 1.1 de HTML hice algunas correcciones en el manejo de terminologa como resultado de los comentarios que he recibido de todas partes del mundo. En la versin 1.2 he actualizado los primeros 2 captulos para hacer notar el cambio de 16 a 32 bits en los compiladores para PCs.
Reconocimientos: Son tantos los que sin saberlo han contribuido a este trabajo debido a las preguntas que han publicado en FidoNet C Echo, o en el grupo de noticias de UseNet comp.lang.c, o en muchas otras conferencias en otras redes, que sera imposible hacer una lista de todos ellos. Agradecimientos especiales a Bob Stout quien fue tan amable en incluir la primera versin de este archivo en sus SNIPPETS.
Sobre el Autor: Ted Jensen es un Ingeniero en Electrnica retirado que ha trabajado tanto como diseador de hardware o gerente de diseadores de hardware en el campo de almacenamiento magntico. La programacin ha sido uno de sus pasatiempos desde 1968 cuando aprendi a perforar tarjetas para ser ejecutadas en un mainframe. (La mainframe tena 64Kb de memoria magntica!).
Uso de este Material: Todo lo que se encuentra contenido en este documento es liberado al dominio pblico. Cualquier persona es libre de copiar o distribuir este material en la manera que prefiera. Lo nico que pido, en caso de que este material sea usado como material de apoyo en una clase, es que fuera distribuido en su totalidad, es decir, incluyendo todos los captulos, el prefacio y la introduccin. Tambin apreciara que en ese caso, el instructor de la clase me mandara una nota a alguna de las direcciones de abajo informndome al respecto. Escrib esto con la esperanza de que fuese til a otros y es por eso que no solicito remuneracin econmica alguna, el nico modo de enterarme en que he alcanzado este objetivo es a travs de los comentarios de quienes han encontrado til este material. No tienes que ser un instructor o maestro para contactarte conmigo. Apreciara mucho un mensaje de cualquier persona que encuentre til este material, o de quien tenga alguna crtica constructiva que ofrecer. Tambin espero poder contestar las preguntas enviadas por e-mail. Ted Jensen Redwood City, CA 94064 tjensen@ix.netcom.com Febrero de 2000.
C-2
APENDICE C
INTRODUCCION
Si uno quiere ser eficiente escribiendo cdigo en el lenguaje de programacin C se debe tener un , profundo y activo c onocimiento del uso de los apuntadores. Desafortunadamente, los apuntadores en C parecen representar una piedra en el camino de los principiantes, particularmente de aquellos que vienen de otros lenguajes de programacin como Fortran, Pascal o Basic. Es para ayudar a estos principiantes en el uso de apuntadores que he escrito el siguiente material. Para obtener el mximo beneficio del mismo, siento que es necesario que el usuario sea capaz de ejecutar el cdigo fuente que se incluye en los artculos. Debido a esto he intentado mantener todo el cdigo dentro de las 1 especificaciones del ANSI para que este pueda trabajar en cualquier compilador compatible con ANSI. He tratado de dar formato al cdigo dentro del texto de tal manera que con la ayuda de un editor de texto ASCII uno pueda copiar el bloque de cdigo que interesa a un archivo nuevo y compilarlo en su sistema. Recomiendo a los lectores el hacerlo porque esto es de gran ayuda para la comprensin del material.
ANSI: American National Standards Institute (Instituto Nacional Americano de Estndares), defini a travs del comit X3J11 formado en 1982, el estndar del lenguaje C en 1989 y de sus funciones de librera. Esto debido a que surgieron varias versiones del lenguaje que diferan en cuanto a caractersticas y extensiones hechas al mismo. (Nota del traductor).
C-3
APENDICE C
CAPITULO 1: QUE ES UN APUNTADOR?
Una de las cosas ms difciles que encuentran los principiantes en C es entender el concepto de apuntadores. El propsito de este documento es dar una introduccin sobre apuntadores y de su uso a estos principiantes. Me he encontrado a menudo que la principal razn por la que los principiantes tienen problemas con los apuntadores es que tienen una muy pobre o mnima concepcin de las variables, (del modo en que C hace uso de ellas). As que comencemos con una discusin sobre las variables de C en general. Una variable en un programa es algo con un nombre, que contiene un valor que puede variar. El modo en que el compilador y el enlazador (linker) manejan esto es que asignan un bloque especfico de la memoria dentro de la computadora para guardar el valor de una variable. El tamao de este bloque depende del rango en que a esta variable le es permitido variar. Por ejemplo, en PCs de 32 bits, el tamao de una variable de tipo entero (int) es de 4 bytes, en una mquina antigua de 16 bits los enteros tienen un tamao de 2 bytes. En C el tamao de un tipo de variable como una de tipo entero no tiene porqu ser el mismo en todos los tipos de mquinas. Es ms en C disponemos de diferentes tipos de variables enteras, estn los enteros largos (long int) y los enteros cortos (short int) sobre los que puedes averiguar en cualquier texto bsico sobre C. El presente documento asume que se est usando un sistema de 32 bits con enteros de 4 bytes. Si quieres conocer el tamao de los diferentes tipos de enteros de tu sistema, ejecutar el siguiente cdigo te dar la informacin. #include <stdio.h> int main() { printf("El tamao de short (entero corto), es: %d\n", sizeof(short)); printf("El tamao de int (entero), es: %d\n", sizeof(int)); printf("El tamao de long (entero largo), es: %d\n", sizeof(long)); }
Cuando declaramos una variable le informamos al compilador 2 cosas, el nombre de la variable y el tipo de la variable. Por ejemplo, declaramos una variable de tipo entero llamada k al escribir:
int k;
Cuando el compilador encuentra la palabra int de esta instruccin, reserva 4 bytes (en un PC) de memoria para almacenar el valor del entero. Tambin construye una tabla de smbolos. Y en esa tabla agrega el smbolo k y la correspondiente direccin de la memoria en donde esos 4 bytes han sido reservados. As que si luego escribimos:
k = 2;
C-4
APENDICE C
esperamos encontrar al momento de la ejecucin, un 2 colocado en el rea de memoria reservada para guardar 2 el valor de k. En C nos referimos a una variable como la de tipo entero k como un objeto .
Tiene sentido decir que hay dos valores asociados con el objeto k, uno es el valor del entero alojado ah (un 2 en el ejemplo de arriba) y el otro el valor de la localidad de la memoria donde se ha guardado, es decir, la direccin de k. Algunos textos se refieren a estos dos valores con la nomenclatura rvalue (are value, right value valor a la derecha) y lvalue (el value left value valor a la izquierda). En algunos lenguajes, el lvalue, es el valor que se permite a la izquierda del operador de asignacin = (la direccin donde se alojar el resultado de la evaluacin de la expresin). El rvalue es el que se encuentra a la derecha de la operacin de asignacin, el 2 de arriba. Los rvalues no pueden ser usados en la parte izquierda de una instruccin de asignacin. As que hacer algo como: 2 = k; No es permitido.
En realidad, la definicin de arriba para "lvalue" es modificada de algn modo para C de acuerdo con K&R II , (pgina 197) [1]: Un obj eto es una regin de almacenamiento; Un lvalue es una expresin que hace referencia a un objeto. En este momento, nos basta la definicin de arriba. A medida que nos vayan resultado familiares los apuntadores entraremos ms a detalle con esto. Bien, ahora consideremos: int j, k; k = 2; j = 7; k = j; <-- lnea 1 <-- lnea 2
En lo de arriba, el compilador interpreta la j en la lnea 1 como la direccin de la variable j (su lvalue) y crea cdigo para copiar el valor 7 a esa direccin. En la lnea 2, sin embargo, la j es interpretada como su rvalue (ya que est del lado derecho del operador de asignacin =). Esto significa que aqu j hace referencia al valor alojado en la direccin de memoria asignado a j, 7 en este caso. As que el 7 es copiado a la direccin designada por el lvalue de k.
En estos ejemplos hemos estado usando enteros de 4 bytes para almacenar nmeros, as que al copiar rvalues de una direccin de alojamiento a otra es hecha copiando 4 bytes. Si estuviramos usando enteros de dos bytes, estaramos copiando 2 bytes en cada ocasin. Ahora, digamos que por alguna razn queremos que una variable almacene un lvalue (una direccin). El tamao requerido para almacenar un valor as depende del sistema. En ordenadores antiguos con 64Kb de memoria total, la direccin de cualquier lugar en la memoria puede ser contenida en 2 bytes. Computadores con ms memoria pueden requerir de ms bytes para almacenar una direccin. El tamao real requerido no es muy importante mientras podamos decirle al compilador que lo que queremos almacenar es una direccin.
2
Se usa la palabra objeto para referirse mas bien a un conjunto que consta de smbolo (nombre), valor y direccin. No se trata del paradigma de programacin objeto, usado en la programacin orientada a objetos. (Nota del traductor).
C-5
APENDICE C
Este tipo de variable es conocido como " variable apuntador" (por razones que esperamos resulten claras un poco ms tarde). En C cuando definimos una variable de apuntador lo hacemos cuando precedemos su nombre con un asterisco. En C adems le damos a nuestro apuntador un tipo, el cual, en este caso, hace referencia al tipo de dato que se encuentra guardado en la direccin que alojaremos en nuestro apuntador. Por ejemplo, consideremos la siguiente declaracin de una variable:
int *ptr;
ptr es el nombre de nuestra variable (tal y como k era el nombre de nuestra variable de tipo entero). El * informa al compilador que lo que queremos es una variable apuntador, es decir, que se reserven los bytes necesarios para alojar una direccin en la memoria. Lo de int significa que queremos usar nuestra variable apuntador para almacenar la direccin de un entero. Se dice entonces que dicho tipo de apuntador apunta a un entero. Sin embargo, ntese que cuando escribamos int k; no le asignamos un valor a k. Si la declaracin se hace fuera de cualquier funcin, los compiladores ANSI la inicializarn automticamente a cero. De modo similar, ptr no tiene un valor asignado, esto es, no hemos almacenado una direccin en la declaracin hecha arriba. En este caso, otra vez si la declaracin fuese hecha fuera de cualquier funcin, es inicializado a un valor garantizado de tal manera que no apunte a un objeto de C o a una funcin, un apuntador inicializado de este modo es definido como un apuntador null. Entonces se llama un apuntador nulo (null pointer).
El patrn real de bits para un apuntador nulo, puede o no evaluarse a cero, ya que depende especficamente del sistema en que est siendo desarrollado el cdigo. Para hacer el cdigo fuente compatible entre distintos compiladores en varios sistemas, se usa una macro para representar un apuntador nulo. Este macro recibe el nombre de NULL. As que, estableciendo el valor de un apuntador utilizando este macro, con una instruccin como ptr = NULL, garantiza que el apuntador sea un apuntador nulo. De modo similar cuando comprobamos el valor de cero en una variable entera, como en if (k==0) podemos comprobar un que un apuntador sea nulo usando if (ptr == NULL). Pero, volviendo de nuevo con el uso de n uestra nueva variable ptr. Supongamos ahora que queremos almacenar en ptr la direccin de nuestra variable entera k. Para hacerlo hacemos uso del operador unitario & y escribimos:
ptr = &k;
Lo que el operador & hace es obtener la direccin de k, an cuando k est en el lado derecho del operador de asignacin = y copia esa direccin en el contenido de nuestro apuntador ptr. Ahora, ptr es un puntero a k. Hay un operador ms que discutir: El operador de indireccin como sigue: (o de desreferencia) es el asterisco y se usa
*ptr = 7;
C-6
APENDICE C
esto copiar el 7 a la direccin a la que apunta ptr. As que como ptr apunta a (contiene la direccin de) k, la instruccin de arriba asignar a k el valor de 7. Esto es, que cuando usemos el '*' hacemos referencia al valor al que ptr est apuntando, no el valor de el apuntador en si. De modo similar podramos escribir: printf ("%d\n",*ptr);
para imprimir en la pantalla el valor entero que se encuentra alojado en la direccin a la que apunta ptr. Una manera de observar como todo esto encaja entre s sera ejecutar el siguiente programa, revisar el cdigo y la salida concienzudamente.
PROGRAMA 1.1
/* Program 1.1 from PTRTUT10.TXT #include <stdio.h> int j, k; int *ptr; int main (void) { j = 1; k = 2; ptr = &k; printf("\n"); printf("j tiene el valor: %d y printf("k tiene el valor: %d y printf("ptr tiene el valor: %p printf("El valor del entero al return 0; } Nota: An tenemos que discutir los aspectos de C que requieren el uso de la expresin (void *) usada aqu. Por el momento inclyela en el cdigo de prueba. Ya explicaremos las razones de esta expresin ms adelante. 6/10/97 */
esta alojado en: %p\n", j, (void *)&j); esta alojado en: %p\n", k, (void *)&k); y esta alojado en: %p\n", ptr, (void *)&ptr); que apunta ptr es: %d\n", *ptr);
Recordando:
Una variable es declarada dndole un tipo y un nombre (por ejemplo: int k;) Una variable apuntador es declarada dndole un tipo y un nombre (por ejemplo: int *ptr) en donde el asterisco le dice al compilador que la variable de nombre ptr es una variable apuntador. Y el tipo le dice al compilador a que tipo de variable va a apuntar nuestro apuntador (int en este caso).
C-7
APENDICE C
Una vez que una variable ha sido declarada, podemos obtener su direccin anteponiendo a su nombre el operador unitario &, como en &k. Podemos desreferenciar un apuntador, es decir, hacer referencia al valor contenido en la direccin a la que apunta, usando el operador unitario *, como en *ptr. Un "lvalue" de una variable es el valor de su direccin, es decir la posicin (direccin) de memoria en donde se encuentra alojado el valor que contiene. El "rvalue" de una variable es el valor alojado en esa en esa direccin.
Referencias en el captulo 1: [1] B. Kernighan and D. Ritchie, "The C Programming Language" 2nd Edition, Prentice Hall. ISBN 0-13-110362-8
C-8
APENDICE C
CAPITULO 2: TIPOS DE APUNTADORES Y ARREGLOS
Consideremos el porqu tenemos que identificar el "tipo" de variable a la que apunta un puntero como en: int *ptr; Una de las razones para hacer esto es que una vez que ptr apunta a algo y si escribimos: *ptr = 2;
El compilador sabr cuantos bytes va a copiar en la posicin de memoria a la que apunta ptr. Si ptr fuera declarado como un puntero a entero, se copiaran 4 bytes. De modo similar para nmeros de punto flotante (float) y enteros dobles (doubles), se copiara el nmero apropiado de bytes. Pero definir el tipo al que el apuntador apunta permite un cierto nmero de maneras interesantes en que el compilador puede interpretar el cdigo. Por ejemplo, consideremos un bloque de memoria consistente en 10 nmeros enteros en una fila. Eso es 40 bytes de memoria son reservados para colocar 10 enteros. Digamos que ahora apuntamos nuestro apuntador entero ptr al primero de estos nmeros enteros. Es ms, supongamos que este primer entero est almacenado en la posicin de memoria 100 (decimal). Entonces que pasa cuando escribimos: ptr + 1; Ya que el compilador sabe que este es un apuntador (que su valor es una direccin de memoria) y que apunta a un entero (su direccin actual: 100, es la direccin donde se aloja un entero), aade 4 a ptr en lugar de 1, as que ptr apunta al siguiente entero, en la posicin de memoria 104. Similarmente, si ptr fuera declarado como apuntador a entero corto, aadira 2 en lugar de 1. Lo mismo va para los otros tipos de datos como flotantes, dobles o an tipos definidos por el usuario como estructuras. No se trata obviamente del tipo normal de adicin a la que estamos acostumbrados. En C, se le conoce como adicin usando aritmtica de punteros, algo que veremos un poco ms adelante.
Igualmente, como ++ptr y ptr++ son equivalentes a ptr + 1 (aunque el momento en el programa cuando ptr es incrementado sea diferente), incrementar un apuntador usando el operador unitario de incremento ++, ya sea 3 pre- o post-, incrementa la direccin por la cantidad sizeof (tipo) donde tipo es el tipo de objeto al que se apunta (por ejemplo 4 si se trata de un entero). Y ya que un bloque de 10 enteros acomodados contiguamente en la memoria es, por definicin, un arreglo de enteros, esto nos revela una interesante relacin entre arreglos y apuntadores. Consideremos lo siguiente:
int mi_arreglo[] = {1,23,17,4,-5,100};
sizeof: Tamao de. Palabra clave de C que en una instruccin calcula el tamao en bytes de la expresin o tipo dados. (Nota del Traductor).
C-9
APENDICE C
Tenemos entonces un arreglo conteniendo seis enteros. Nos referimos a cada uno de estos enteros por medio de un subndice a mi_arreglo, es decir usando mi_arreglo[0] hasta mi_arreglo[5]. Pero podemos acceder a ellos de un modo alternativo usando un puntero de esta manera:
int *ptr; ptr = &mi_arreglo[0]; /* apuntamos nuestro apuntador al primer entero de nuestro arreglo */
Y entonces podemos imprimir los valores de nuestro arreglo, ya sea usando la notacin de arreglos o desreferenciando nuestro apuntador. El siguiente cdigo ilustra este concepto.
PROGRAMA 2.1
#include <stdio.h> int mi_arreglo[] = {1,23,17,4,-5,100}; int *ptr; int main(void) { int i; ptr = &mi_arreglo[0];
/* apuntamos nuestro puntero al primer elemento del arreglo*/
printf("\n\n"); for (i = 0; i < 6; i++) { printf("mi_arreglo[%d] = %d ", i, mi_arreglo[i]); printf("ptr + %d = %d\n",i, *(ptr + i)); } return 0; }
/*<-- A */ /*<-- B */
Compila y ejecuta el programa de arriba y nota como las lneas marcadas con A y B imprimen los mismos valores. Observa adems como desreferenciamos nuestro puntero ptr en la lnea B, primero le aadimos i y luego desreferenciamos el nuevo apuntador. Cambia la lnea B de tal modo que quede:
printf ("ptr + %d = %d\n", i, *ptr++);
Compila y ejecuta de nuevo, y luego vuelve a modificarla por:
printf(ptr + %d = %d\n, i, *(++ptr));
Compila y ejecuta una vez ms. Trata de predecir lo que saldr a pantalla cada vez y revisa con cuidado la salida real.
10
C-10
APENDICE C
En C, el estndar establece que donde usemos &nombre_de_la_variable[0] podemos reemplazarle con nombre_de_la_variable, esto en el cdigo de ejemplo lo que escribimos como: ptr = &mi_arreglo[0];
podemos escribirlo como: ptr = mi_arreglo;
y obtenemos el mismo resultado. Esto conduce a muchos textos a decir que el nombre de un arreglo es un apuntador. Si bien esto es cierto, prefiero pensar que el nombre de un arreglo es la direccin del primer elemento que contiene el arreglo. Muchos principiantes (incluyndome a mi cuando estuve aprendiendo) muestran tendencia a confundirse pensando en el como un puntero. Por ejemplo, si bien podemos hacer ptr = mi_arreglo; no podemos hacer:
mi_arreglo = ptr;
La razn es que mientras ptr es una variable, mi_arreglo es una constante. Esto es, la direccin en la que el primer elemento de mi_arreglo ser almacenado no puede ser cambiado una vez que mi_arreglo[] ha sido declarado. Anteriormente , al discutir el trmino lvalue, se estableci que: Un objeto es una regin de almacenamiento; Un lvalue es una expresin que hace referencia a un objeto. Esto plantea un problema interesante. Ya que mi_arreglo es una regin nominada de almacenamiento, Por qu no es mi_arreglo en la asignacin que se hace arriba el lvalue?. Para resolver este problema, algunos se refieren a cosas como mi_arreglo como un lvalue no modificable.
Modifiquemos el programa de ejemplo cambiando: por
ptr = &mi_arreglo [0];
ptr = mi_arreglo;
ejecuta de nuevo para verificar que los resultados son idnticos.
Profundicemos un poco ms con la diferencia entre los nombres ptr y mi_arreglo como hicimos arriba. Algunos escritores se refieren al nombre de un arreglo como un puntero constante. Qu queremos decir con esto? Bueno, para entender el trmino constante en este contexto, volvamos a nuestra definicin del trmino variable. Cuando declaramos una variable reservamos un lugar de la memoria para almacenar el valor del tipo apropiado. Una vez hecho esto, el nombre de la variable puede ser interpretado en una de dos maneras. Cuando es usada en el lado izquierdo del operador de asignacin, el compilador la interpreta como la direccin de memoria en la cual colocar el resultado de la evaluacin de lo que se encuentra al lado derecho del operador de asignacin. Pero cuando se usa del lado derecho del operador de asignacin, el nombre de una variable es
11
C-11
APENDICE C
interpretada de modo que representa el contenido de la direccin de memoria reservada para contener el valor de dicha variable. Con esto en mente analicemos la ms simple de las constantes, como en: int i, k; i = 2; Aqu, mientras i es una variable y ocupa un espacio en la seccin de datos de la memoria, 2 es una constante y como tal, en lugar de ocupar memoria en el segmento de datos, es embebida directamente en la seccin de cdigo de la memoria. Esto quiere decir que cuando escribimos algo como k = i; le decimos al compilador que cree cdigo que en el momento de ejecucin observar en la direccin &i para determinar el valor a ser movido a k, mientras que el cdigo creado al hacer algo como i = 2, simplemente pone el 2 en el cdigo (no se hace referencia al segmento de datos). Esto es porque ambos, k e i son objetos, pero 2 no es un objeto.
De modo similar a lo que ocurre arriba, ya que mi_arreglo es una constante, una vez que el compilador establece donde ser almacenado el arreglo en la memoria, ya sabe la direccin de mi_arreglo[0] y cuando encuentra: ptr = mi_arreglo; Simplemente usa esta direccin como una constante en el segmento de cdigo y no hace ms que eso (no se hace una referencia al segmento de cdigo). Este sera buen lugar para explicar el uso de la expresin (void *) usada en el programa 1.1 del captulo 1. Como ya hemos visto, podemos tener apuntadores de distintos tipos. Es ms, ya hemos discutido sobre apuntadores a enteros y a caracteres. En las siguientes lecciones veremos apuntadores a estructuras y an apuntadores a apuntadores. Ya hemos aprendido que en diferentes sistemas, el tamao de un apuntador puede variar. Tambin es posible que el tamao de un apuntador vare dependiendo del tipo de datos del objeto al que apunta. As que al igual que con los enteros donde podemos tener problemas al asignar, por ejemplo un valor entero largo a una variable del tipo entero corto, podemos igualmente encontrarnos con problemas al intentar asignar valores desde un cierto tipo de apuntador a un apuntador de otro tipo. Para reducir este problema C nos ofrece un apuntador de tipo void ( carente de tipo). Podemos declarar un apuntador de este tipo al escribir algo como: void *vptr; Un apuntador void es una especie de apuntador genrico. Por ejemplo, mientras C no permite la comparacin entre un apuntador del tipo entero con uno del tipo caracter, cada uno de estos puede ser comparado con un apuntador del tipo void. Por supuesto, como con los otros tipos de variables, las conversiones (casts) pueden ser utilizadas para convertir un tipo d apuntador en otro bajo las circunstancias apropiadas. En el P rograma 1.1 del captulo 1, e convert los punteros a enteros a punteros void, para hacerlos compatibles con la especificacin de conversin de %p. En captulos posteriores, otras conversiones sern realizadas por las razones que se han expuesto aqu. Bueno, han sido bastantes cosas tcnicas que digerir y no espero que un principiante entienda todo esto en la primera lectura. Con tiempo y experimentacin seguramente volvers a leer los primeros dos captulos. Pero por ahora, continuemos con la relacin existente entre apuntadores, arreglos de caracteres, y cadenas.
12
C-12
APENDICE C
CAPITULO 3: APUNTADORES Y CADENAS

El estudio de las cadenas es til para profundizar en la relacin entre apuntadores y arreglos. Facilita, adems la demostracin de cmo algunas de las funciones estndar de cadenas de C pueden ser implementadas. Finalmente ilustraremos cmo y cuando los apuntadores pueden y deben ser pasados a una funcin. En C, las cadenas son arreglos de caracteres. Esto no es necesariamente cierto para otros lenguajes. En Basic, Pascal, Fortran y en otros lenguajes, una cadena tiene definido su propio tipo de datos. Pero en C, esto no es as. En C una cadena es un arreglo de caracteres terminado con un carcter binario de cero (escrito como \0). Para comenzar nuestra discusin escribiremos algo de cdigo, el cual si bien es preferido para propsitos meramente ilustrativos, probablemente no lo escribirs en un programa real. Consideremos por ejemplo:
char mi_cadena[40]; mi_cadena mi_cadena mi_cadena mi_cadena [0] [1] [2] [3] = = = = 'T'; 'e'; 'd': '\0';
Si bien uno nunca construira cadenas de este modo, el resultado final es una cadena que es en realidad un arreglo de caracteres terminado con un caracter nul. Por definicin, en C, u cadena es un arreglo de na caracteres terminado con el carcter nul. Hay que tener cuidado con que nul no es lo mismo que NULL. El nul se refiere a un cero definido por la secuencia de escape \0. Esto es, que ocupa un byte de memoria. El NULL, por ot ra parte, es el nombre de la macro usada para inicializar apuntadores nulos. NULL est definido en un archivo de cabecera del compilador de C, mientras que nul puede no estar definido del todo. Ya que al estar escribiendo cdigo como el de arriba gastaramos mucho tiempo, C permite dos modos alternativos de llegar al mismo resultado. El primero sera escribir:
char mi_cadena [40] = {'T', 'e', 'd', '\0',};
Pero se lleva ms tecleado del que es conveniente. As que C permite:
char mi_cadena [40] = "Ted"; Cuando usamos las comillas dobles, en lugar de las simples usadas en los ejemplos anteriores, el carcter nul (\0) se aade automticamente al final de la cadena. En cualquiera de los casos descritos arriba sucede la misma cosa,. El compilador asigna un bloque continuo de memoria de 40 bytes de longitud para alojar los caracteres y los inicializa de tal manera que los primeros 4 caracteres son Ted\0.
13
C-13
APENDICE C
Veamos ahora el siguiente programa:
PROGRAMA 3.1
/* Program 3.1 from PTRTUT10.HTM #include <stdio.h> char strA[80] = "Cadena a usar para el programa de ejemplo"; char strB[80]; int main(void) { char *pA; char *pB; puts(strA); pA = strA; puts(pA); pB = strB; putchar('\n'); while(*pA != '\0') { *pB++ = *pA++; } *pB = '\0'; puts(strB); return 0; } /* /* /* /* /* /* /* /* un apuntador al tipo caracter */ otro apuntador al tipo caracter */ muestra la cadena strA */ apunta pA a la cadena strA */ muestra a donde apunta pA */ apunta pB a la cadena strB */ dejamos una lnea en blanco */ linea A (ver texto) */ 6/13/97 */
/* linea B (ver texto) */ /* linea C (ver texto) */ /* muestra strB en la pantalla */
Lo que hicimos arriba fue comenzar por definir dos arreglos de 80 caracteres cada uno. Ya que estos son definidos globalmente, son inicializados a \0 primeramente. Luego strA tiene sus primeros 42 caracteres inicializados a la cadena que est entre comillas. Ahora, yendo al cdigo, declaramos dos apuntadores a caracter y mostramos la cadena en pantalla. Despus apuntamos con el puntero pA a strA. Esto quiere decir que, por el significado de la operacin de asignacin, copiamos la direccin de memoria de strA[0] en nuestra variable apuntador pA. Usamos entonces puts() para mostrar lo que estamos apuntando con pA en la pantalla. Consideremos aqu que el prototipo de la funcin puts() es:
int puts(const char *s); Por el momento ignoremos eso de const. El parmetro pasado a puts() es un apuntador, esto es, el valor del un apuntador (ya que en C todos los parmetros son pasados por valor), y ya que el valor de un apuntador es la direccin de memoria a la que apunta, o , para decirlo simple: una direccin. As que cuando escribimos: puts(strA); como hemos visto, estamos pasando la direccin de strA[0]. De modo similar cuando hacemos: puts(pA); estamos pasando la misma direccin, ya que habamos establecido que pA = strA;
14
C-14
APENDICE C
Sigamos examinando el cdigo hasta el while() en la lnea A: - La lnea A indica: Mientras el caracter apuntado por pA ( es decir: *pA) no sea un caracter nul (el que es \0), haz lo siguiente - La lnea B indica: copia el caracter apuntado por pA (es decir *pA) al espacio al que apunta pB, luego incrementa pA de tal manera que apunte al siguiente caracter, de igual modo incrementa pB de manera que apunte al siguiente espacio Una vez que hemos copiado el ltimo caracter, pA apunta ahora a un caracter nul de terminacin de cadena y el ciclo termina. Sin embargo, no hemos copiado el caracter de terminacin de cadena. Y, por definicin: una cadena en C debe terminar en un caracter nul. As que agregamos nul con la lnea C. Resulta realmente didctico ejecutar este programa en un depurador (debugger), mientras se observa strA, strB, pA y pB e ir recorriendo cada paso del programa, tambin es bueno probar inicializando strB[] a una cadena en lugar de hacerlo simplemente declarndole; puede ser algo como:
strB[80] = "12345678901234567890123456789012345678901234567890"
Donde el nmero de dgitos sea mayor que la longitud de strA y luego repite la observacin paso a paso mientras observas el contenido de las variables. Intntalo! Volviendo al prototipo para puts() por un momento, la const usada como parmetro informa al usuario que la funcin no modificar a la cadena apuntada por s, es decir que se tratar a esa cadena como una constante. Desde luego, lo que hace el programa de arriba es una manera simple de copiar una cadena. Despus de jugar un poco con esto y una vez que tengas bien entendido lo que pasa, procederemos entonces a crear nuestro reemplazo para la funcin estndar strcpy() que viene con C. Sera algo como: char *mi_strcpy(char *destino, char *fuente) { char *p = destino; while (*fuente != '\0') { *p++ = *fuente++; } *p = '\0'; return destino; } En este caso he seguido el procedimiento usado en la rutina estndar de regresar un puntero al destino. De nuevo, la funcin esta diseada para aceptar valores de dos punteros a caracter, es decir las direcciones, y por esto en el programa anterior pudimos haber escrito: int main(void) { mi_strcpy(strB, strA); puts(strB); }
15
C-15
APENDICE C
Me he desviado ligeramente de la forma usada en la funcin estndar de C, la cual tiene por prototipo:
char *mi_strcpy(char *destino, const char *fuente); Aqu el modificador const es usado para asegurar que la funcin no modificar el contenido al que apunta el puntero de la fuente. Puedes probar esto modificando la funcin de arriba y su prototipo incluyendo el modificador const como hemos mostrado. Entonces dentro de la funcin puedes agregar cdigo que intente cambiar el contenido de lo que est apuntado por la fuente. Algo como: *fuente = 'X'; Lo que normalmente cambiara el primer caracter de la cadena por una X. El modificador constante hace que el compilador detecte esto como un error. Prueba y vers. Consideremos ahora algunas de las cosas que el ejemplo de arriba nos ha demostrado. En primera, consideremos el h echo de que *ptr++ se interpreta como que d evuelve el valor apuntado por ptr y luego incrementa el valor del apuntador. Esto tiene que ver con la precedencia de operadores. Si hubiramos escrito (*ptr)++ no estaramos incrementando el apuntador, sino lo que contiene!. Es decir que si lo usramos as con el primer caracter de la cadena del ejemplo, la C sera incrementada a una D. Puedes escribir cdigo sencillo para demostrar esto. Recordemos de nuevo que una cadena no es otra cosa ms que un arreglo de caracteres, siendo su ltimo caracter un \0. Lo que hemos hechos es ideal para copiar un arreglo. Sucede que lo hemos hecho con un arreglo de caracteres, pero la misma tcnica puede ser aplicada a un arreglo de enteros, dobles, etc. En estos casos, no estaramos tratando con cadenas y entonces el arreglo no tendra porque estar marcado por un valor especial como el caracter nul. Podemos implementar una versin que se basara en una terminacin especial para identificar el final. Por ejemplo, podramos copiar un arreglo de enteros positivos y sealar el final con un entero negativo. Por otra parte, es ms usual que cuando escribamos una funcin que copie un arreglo que no sea una cadena, indiquemos el nmero de elementos que sern copiados as como la direccin del arreglo. Por ejemplo algo como lo que indicara el siguiente prototipo:
void int_copy(int *ptrA, int *ptrB, int nbr);
Donde nbr es el nmero de elementos enteros que sern copiados. Puedes juguetear un poco con esta idea y crear un arreglo enteros y probar si puedes implementar una funcin copiadora de enteros int_copy() y hacer que trabaje bien. Esto permite el uso de funciones para manipular arreglos grandes. Por ejemplo, si tuviramos un arreglo de 5000 enteros que quisiramos manipular con una funcin, slo necesitaramos pasarle a esa funcin la direccin donde se encuentra alojado el arreglo (y alguna informacin auxiliar como el nbr de arriba, dependiendo de lo que vayamos a hacer). El arreglo en s no es pasado a la funcin, es decir, este no se copia y se pone en la pila (stack) antes de llamar a la funcin. Slo se enva la direccin donde se encuentra su primer elemento (la direccin de arreglo es pasada a la funcin) . Esto es diferente de pasar, digamos, un entero a una funcin (una variable int). Cuando nosotros pasamos una variable entera a una funcin, lo que sucede es que hacemos una copia de este entero, es decir, obtenemos su valor y lo ponemos en la pila. Dentro de la funcin cualquier manipulacin que se haga a esta variable no afectar al contenido de la variable original. Pero con arreglos y apuntadores podemos pasar a una funcin las direcciones de las variables y por tanto manipular los valores contenidos en las variables originales.
16
C-16
APENDICE C
CAPITULO 4: MS SOBRE CADENAS

Bien, hemos progresado bastante en corto tiempo. Retrocedamos un poco y veamos lo que hicimos en el captulo 3 al copiar cadenas, pero vindolo desde otra perspectiva. Consideremos la siguiente funcin:
char *mi_strcpy(char destino[], char fuente[]) { int i = 0; while (fuente[i] != '\0') { destino[i] = fuente[i]; i++; } destino[i] = '\0'; return destino; } Recordemos que las cadenas son arreglos de caracteres. Aqu hemos elegido usar la notacin de arreglos en lugar de la notacin de punteros para hacer la copia. El resultado es el mismo, esto es, la cadena es copiada de la misma manera usando esta notacin que como lo hizo antes. Esto expone algunos puntos interesantes que discutir. Ya que los parmetros son pasados por valor, ya sea pasando el apuntador de tipo caracter que apunta a la direccin del arreglo o el nombre del arreglo como arriba, lo que en realidad se est pasando es la direccin del primer elemento del arreglo para cada caso. Esto significa que el valor numrico del parmetro que se pasa es el mismo ya sea que pasemos un puntero tipo caracter o el nombre del arreglo como parmetro. Esto implicara de alguna manera que: fuente[i] es lo mismo que *(p+i); Lo cual es cierto, dondequiera que uno escriba a[i] se puede reemplazar por *(a + i) sin ningn problema. De hecho el compilador crear el mismo cdigo en cualquier caso. Por esto nos damos cuenta que la aritmtica de punteros es lo mismo que usar subndices con los arreglos. Cualquiera de las dos sintaxis produce el mismo resultado. Esto NO significa que apuntadores y arreglos sean lo mismo, porque no es as. Slo estamos exponiendo que para identificar un elemento dado de un arreglo tenemos la opcin de usar dos sintaxis diferentes, una usando subndices para arreglos y la otra es usando aritmtica de punteros, lo cual conduce a un mismo resultado. Ahora, analizando la ltima expresin, la parte de ella que dice : (a + i), es una simple adicin usando el operador + y las reglas de C dicen que una expresin as es conmutativa. Por lo que (a + i) es lo mismo que: (i + a), as que podemos escribir: *(i + a) al igual que *(a + i). Pero *(i + a) pudo venir de i[a] ! De todo esto obtenemos una verdad que resulta curiosa tal que si: char a[20]; int i;
17
C-17
APENDICE C
Escribir: Es lo mismo que:
a[3] = 'x'; 3[a] = 'x';
Prubalo! Inicializa un arreglo de caracteres, enteros, largos, etc. Y usando el mtodo convencional asigna un valor al 3er o 4to elemento e imprime ese valor para confirmar que esta almacenado. Luego invierte la notacin como se ha hecho arriba. Un buen compilador no se quejar con un mensaje de error o de advertencia y se obtendrn los mismos resultados. Una curiosidad y nada ms! Ahora volviendo a nuestra funcin de ms arriba, escribimos :
destino[i] = fuente[i];
Debido al hecho de que usar subndices en arreglos o aritmtica de punteros lleva a un mismo resultado, pudimos escribir lo anterior como:
*(destino + i) = *(fuente + i); Pero, esto implica 2 adiciones por cada valor que toma i. Las adiciones, generalmente hablando, se llevan ms tiempo que los incrementos (como los hechos usando ++ en i++). Esto no es necesariamente cierto con los modernos compiladores optimizados, pero uno no siempre puede estar seguro. As que es posible que la versin con punteros sea un poco ms rpida que la versin con arreglos. Otro mtodo para acelerar la versin de punteros sera cambiar: a simplemente
while (*fuente != '\0')
while (*fuente)
Ya que el valor dentro del parntesis se har cero (FALSO) al mismo tiempo en cualquiera de los dos casos. Llegado este momento tal vez quieras experimentar un poco escribiendo tus propios programas usando apuntadores. Manipular cadenas de texto es una buena idea para experimentar. Tal vez puedas implementar tu propia versin de las funciones de la librera estndar <string.h> como:
strlen(); strcat(); strchr();
y de cualquiera otras que tuvieras en tu sistema. Ya volveremos a ver cadenas y su manipulacin a travs de punteros en un captulo futuro. Por ahora sigamos avanzando y discutamos un poco sobre las estructuras.
18
C-18
APENDICE C
CAPITULO 5: APUNTADORES Y ESTRUCTURAS

Como sabrs, es posible declarar la forma de un bloque de datos conteniendo distintos tipos de datos por medio de la declaracin de una estructura. Por ejemplo, un archivo de personal contendra estructuras que seran algo como:
struct ficha{ char nombre[20]; char apellido[20]; int edad; float salario; }; /* /* /* /* nombre */ apellido */ edad */ por ejemplo 12.75 por hora */
Supongamos que tenemos muchas de estas estructuras en un archivo de disco y queremos leer cada una e imprimir el nombre y apellido de cada una, de modo que tengamos una lista con el nombre y apellido de cada persona que se encuentra en el archivo. La informacin restante no se imprimir. Queremos hacer esto por medio de una funcin a la que pasemos como parmetro un apuntador a la estructura. Para propsitos didcticos slo usar una estructura por ahora. Pero concentrmonos en que el objetivo es implementar la funcin, no leer desde un archivo de disco, lo que presumiblemente, sabemos cmo hacer. Recordemos que podemos acceder a los miembros de una estructura por medio del operador . (punto).
PROGRAMA 5.1
/* Program 5.1 from PTRTUT10.HTM #include <stdio.h> #include <string.h> struct ficha{ char nombre[20]; char apellido[20]; int edad; float salario; }; struct ficha mi_ficha; /* /* /* /* nombre */ apellido */ edad */ salario */ 6/13/97 */
/* declaramos mi_ficha como una estructura del tipo ficha */
int main(void) { strcpy(mi_ficha.nombre,"Jensen"); strcpy(mi_ficha.apellido,"Ted"); printf("\n%s ",mi_ficha.nombre); printf("%s\n",mi_ficha.apellido); return 0; }
19
C-19
APENDICE C
Ahora que esta estructura en particular es muy pequea comparada con aquellas usadas en muchos programas de C. A la de arriba tal vez quisiramos aadir (sin mostrar el tipo de datos en particular): -Direccin -Ciudad -Telfono -Estado Civil -Cdigo Postal -N del seguro social, etc.
Si tenemos una cantidad considerable de empleados, lo ideal sera manejar los datos dentro de estas estructuras por medio de funciones. Por ejemplo queremos implementar una funcin que imprimiera el nombre de los empleados, contenidos en cualquier estructura que le pasara. Sin embargo, en el lenguaje C original (Kernighan & Ritchie, 1 Edicin) no era posible pasar una estructura como parmetro a una funcin, slo un puntero que apuntara a una estructura. En el ANSI C, ahora es posible pasar una estructura completa. Pero, ya que nuestro objetivo es aprender sobre punteros, no iremos tras esto ahora. De cualquier modo, si pasramos la estructura completa significa que debemos copiar el contenido de la estructura desde la funcin que llama a la funcin llamada. En sistemas que usan pilas (stacks), esto se hace metiendo los contenidos de la estructura dentro de la pila. Con estructuras grandes esto puede representar un problema. Sin embargo pasar apuntadores usa un mnimo de espacio en la pila. Como sea, ya que estamos discutiendo apuntadores, discutiremos entonces como pasarle a una funcin un puntero que apunta a una estructura y cmo usarlo dentro de la funcin. Considera el caso descrito: queremos una funcin que acepte como parmetro un puntero a una estructura y dentro de esa funcin queremos acceder a los miembros de la estructura. Por ejemplo, queremos imprimir el nombre del empleado de nuestra estructura de ejemplo. Bien, como sabemos que nuestro apuntador va a apuntar a una estructura declarada usando struct ficha. Declaramos dicho apuntador con la declaracin:
struct ficha
*st_ptr;
Y hacemos que apunte a nuestra estructura de ejemplo con:
st_ptr = &mi_ficha; Ahora podremos acceder a un miembro de la estructura desreferenciando el puntero. Pero, Cmo desreferenciamos un puntero a estructura? Bueno, consideremos el hecho de que queramos usar el puntero para cambiar la edad del empleado. Para esto escribiramos:
(*st_ptr).edad = 63; Observa cuidadosamente. Dice, reemplaza lo que se encuentra entre parntesis por aquello a lo que st_ptr est apuntando, lo cual es la estructura mi_ficha. As que esto se reduce a lo mismo que mi_ficha.edad.
20
C-20
APENDICE C
Sin embargo, esta notacin no es muy usada y los creadores de C nos han brindado la posibilidad de utilizar una sintaxis alternativa y con el mismo significado, la cual sera:
st_ptr -> edad = 63; Con esto en mente, veamos el siguiente programa.
PROGRAMA 5.2
/* Program 5.2 from PTRTUT10.HTM #include <stdio.h> #include <string.h> 6/13/97 */
struct ficha{ char nombre[20]; char apellido[20]; int edad; float salario; }; /* /* /* /* nombre */ apellido */ edad */ salario */
struct ficha mi_ficha;
/* definimos mi_ficha del tipo estructura ficha */ /* prototipo de la funcin */
void show_name (struct tag *p);
int main(void) { struct ficha *st_ptr; /* un apuntador a una estructura del tipo ficha */ /* apuntamos el apuntador a mi_ficha */
st_ptr = &mi_ficha;
strcpy(mi_ficha.apellido,"Jensen"); strcpy(mi_ficha.nombre,"Ted"); printf("\n%s ",mi_ficha.nombre); printf("%s\n",mi_ficha.apellido); mi_ficha.edad = 63; show_name (st_ptr); /* Llamamos a la funcin pasndole el puntero */
return 0; }
21
C-21
APENDICE C
void show_name(struct tag *p) { printf("\n%s ", p -> nombre); printf("%s ", p -> apellido); printf("%d\n", p -> edad); } /* p apunta a una estructura */
De nuevo, esta es mucha informacin para absorber de una sola v ez. Sugiero al lector compilar y ejecutar los programas y de ser posible usar un depurador (debugger) para ver el e stado de las variables ejecutando el programa paso por paso a travs de la funcin principal (main()) y siguiendo el cdigo hasta la funcin show_name() para ver que es lo que sucede.
22
C-22
APENDICE C
CAPITULO 6: MS SOBRE CADENAS Y ARREGLOS DE CADENAS
Bien, regresemos con las cadenas. En lo consiguiente todas las declaraciones se entendern como hechas globalmente. Es decir, son hechas fuera de cualquier funcin, incluyendo main(). Habamos dicho en un captulo anterior que podamos hacer:
char mi_nombre[40] = "Ted";
Con lo cual reservaramos espacio para alojar un arreglo de 40 bytes y colocar la cadena dentro de los primeros 4 bytes del arreglo (3 para los caracteres entre comillas y uno ms para \0) Si realmente slo quisiramos un arreglo donde alojar el nombre Ted, podemos hacer:
char mi_nombre[] = "Ted"; Y el compilador contara los caracteres, dejando espacio para el caracter de terminacin nul y entonces guardar un total de 4 caracteres en la memoria, la direccin de la cual sera regresada por el nombre del arreglo, en este caso mi_nombre. En ocasiones, en lugar de cdigo como el de arriba encontraremos:
char *mi_nombre = "Ted"; Lo cual es una declaracin alterna. Existe alguna diferencia entre ellas? La respuesta es si. Usando la notacin de arreglo 4 bytes de almacenamiento en el bloque de memoria esttica son tomados, uno para cada caracter y uno para el caracter de terminacin nul. Pero en la notacin de apuntador los mismos 4 bytes son requeridos ms N bytes para alojar la variable apuntadora mi_nombre (donde N depende del sistema pero es usualmente un mnimo de 2 bytes y pueden ser 4 o ms). En la notacin de arreglo, mi_nombre es la forma corta de &mi_nombre[0] lo cual es la direccin del primer elemento del arreglo. Ya que la direccin en que se alojar el arreglo ser fijada durante el tiempo de ejecucin del programa, esto es una constante (no una variable). En la notacin de punteros, mi_nombre es una variable. Decidir el mtodo a utilizar y cual es el mejor depende de lo que se vaya a hacer en el resto del programa. Vayamos ahora un paso ms adelante y consideremos que pasara si cada una de estas declaraciones fueran hechas dentro de una funcin, de manera opuesta a lo global que es fuera de los dominios de cualquier funcin:
23
C-23
APENDICE C
void mi_funcion_A(char *ptr) { char a[] = "ABCDE"; . . }
void mi_funcion_B(char *ptr) { char *cp = "FGHIJ"; . . } En el caso de mi_funcion_A, el contenido, o valor(es), del arreglo a[] son considerados como los datos. Se dice que el arreglo ha sido inicializado a los valores ABCDE. En el caso de mi_funcion_B, el valor del apuntador cp se considera como dato. El puntero ha sido inicializado para apuntar a la cadena FGHIJ. En ambas funciones las definiciones son variables locales y por tanto la cadena ABCDE se guarda en la pila (stack), as como el valor del apuntador cp. La cadena FGHIJ se guarda en cualquier lugar que resulte adecuado. En mi sistema se guarda en el segmento de datos. Dicho sea de paso, la inicializacin por arreglo de variables automticas como se hizo en mi_funcion_A era ilegal en el viejo C de K&R y solo vino a darse en el nuevo ANSI C. Un factor que puede ser importante cuando se esta considerando la portabilidad y la compatibilidad hacia atrs. A la vez que vamos discutiendo las relaciones/diferencias entre apuntadores y arreglos, veamos algo sobre arreglos multidimensionales. Consideremos por ejemplo el arreglo:
char multi[5][10];
Qu hay con eso? Bien, vemoslo con otra perspectiva:
char multi[5][10]; Tomemos como el nombre del arreglo la parte subrayada. Luego entonces anteponindole char y posponiendo [10] tenemos entonces un arreglo de 10 caracteres. Pero el nombre multi[5] es en si un arreglo indicando que consta de 5 elementos los cuales a su vez constan de 10 caracteres cada uno. Por tanto tenemos un arreglo de 5 arreglos de 10 caracteres cada uno. Asumamos que hemos rellenado este arreglo bidimensional. En memoria tendramos algo similar a que si el arreglo bidimensional estuviera formado por 5 arreglos separados que hubiramos inicializado con algo como: multi[0] multi[1] multi[2] multi[3] multi[4] = = = = = {'0','1','2','3','4','5','6','7','8','9'} {'a','b','c','d','e','f','g','h','i','j'} {'A','B','C','D','E','F','G','H','I','J'} {'9','8','7','6','5','4','3','2','1','0'} {'J','I','H','G','F','E','D','C','B','A'}
24
C-24
APENDICE C
Al tiempo que podemos acceder a elementos individuales del arreglo usando la siguiente sintaxis: multi[0][3] = '3' multi[1][7] = 'h' multi[4][0] = 'J' Ya que los arreglos son continuos en memoria, nuestro bloque de memoria debe ser algo as en realidad:
0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA
Iniciando en la direccin &multi[0][0] Ntese que no escrib multi[0] = "0123456789". Si lo hubiera hecho de este modo un terminador de cadena \0 habra sido aadido al final, ya que dondequiera que haya comillas dobles un caracter nul se aade al final de los caracteres contenidos entre esas comillas. Si este fuera el caso habra tenido que declarar el arreglo de tal modo que hubiera espacio para 11 caracteres por rengln en lugar de 10. Esto porque este es un arreglo bidimensional de caracteres, NO un arreglo de cadenas. Ahora, el compilador sabe de cuantas columnas consta el arreglo de modo que puede interpretar multi+1 como la direccin de la a en el segundo rengln del arreglo de arriba. Esto es, aade 10, el nmero de columnas para obtener esta direccin. Si estuviramos trabajando con nmeros enteros y el arreglo fuera de las mismas dimensiones, el compilador aadira 10 * sizeof(int), lo que en mi mquina es un total de 20 (usando enteros de 2 bytes). As que, la direccin de el 9 en el cuarto rengln sera &multi[3][0] o *(multi + 3) en notacin de apuntadores. Para obtener el contenido del 2 elemento en el 4 rengln aadimos 1 a esta direccin y la desreferenciamos: *(*(multi + 3) + 1) Pensando un poco podemos observar que: *(*(multi + renglon) + columna) multi[renglon][columna] este modo de acceder a un elemento de la matriz y este otro son lo mismo.
El siguiente programa demuestra el uso de una matriz de enteros en lugar de una de caracteres.
PROGRAMA 6.1
/* Program 6.1 from PTRTUT10.HTM 6/13/97*/
#include <stdio.h> #define RENGLONES 5 #define COLUMNAS 10
int multi[RENGLONES][COLUMNAS];
25
C-25
APENDICE C
int main(void) { int renglon, columna; for (renglon = 0; renglon < RENGLONES; renglon++) { for (columna = 0; columna < COLUMNAS; columna++) { multi[renglon][columna] = renglon*columna; } } for (renglon = 0; renglon < RENGLONES; renglon++) { for (columna = 0; columna < COLUMNAS; columna++) { printf("\n%d ",multi[renglon][columna]); printf("%d ",*(*(multi + renglon) + columna)); } } return 0; }
Debido a la doble desreferencia requerida en la versin de apuntador, se dice que el nombre de una matriz bidimensional es equivalente a un apuntador a apuntador. Con arreglos de 3 dimensiones estaramos hablando de arreglos de arreglos de arreglos y entonces el nombre de tal seria el equivalente de un apuntador a apuntador a apuntador. Sin embargo, aqu hemos reservado inicialmente el bloque de memoria para el arreglo usando notacin de arreglos. Por lo que estamos manejando una constante, no una variable, esto significa que estamos hablando de una direccin fija. La desreferenciacin usada arriba nos permite acceder a cualquier elemento en el arreglo de arreglos sin necesidad de cambiar el valor de la direccin (la direccin de multi[0][0] es proporcionada por el smbolo multi).
26
C-26
APENDICE C
CAPTULO 7: MS SOBRE ARREGLOS MULTIDIMENSIONALES
En el captulo anterior notamos que una vez dados: #define RENGLONES 5 #define COLUMNAS 10 int multi[RENGLONES][COLUMNAS]; podemos acceder a elementos individuales del arreglo multi utilizando ya sea: multi[renglon][columna] *(*(multi + renglon) + columna) Para entender mejor lo que sucede, reemplacemos *(multi + renglon) con una X, tal que la expresin nos quede como *(X + columna) Ahora vemos que esta X es como un apuntador ya que la expresin se encuentra desreferenciada y sabemos que col es un entero. Aqu la aritmtica a utilizar es de un tipo especial llamada aritmtica de punteros. Eso significa que, ya que hablamos de un arreglo de enteros, la direccin a ser apuntada por (el valor de) X + columna + 1 debe ser mayor que la direccin de X + columna por una cantidad que es igual a sizeof(int) (el tamao del tipo de dato entero). Ya que sabemos la estructura de memoria para arreglos bidimensionales, podemos determinar que en la expresin multi + renglon como se hizo arriba, multi + renglon + 1 hace que esto se incremente por un valor igual al necesario para apuntar a el siguiente rengln, lo cual sera entonces COLUMNAS * sizeof (int). Esto nos dice que si la expresin *(*(multi + renglones) + columnas) va a ser evaluada correctamente en tiempo de ejecucin, el compilador debe generar cdigo que tome en consideracin el valor de COLUMNAS, es decir, la segunda dimensin. Debido a la equivalencia entre las dos formas de expresin, esto se hace cierto ya sea que usemos la sintaxis de punteros o la de arreglos multi[renglon][columna]. As que para evaluar cualquiera de estas dos expresiones, se deben conocer 5 valores: 1. 2. 3. 4. 5. La direccin del primer elemento del arreglo, la cual es conocida por la expresin multi, es decir, el nombre del arreglo. El tamao y el tipo de los elementos que conforman el arreglo, en este caso sizeof(int). La segunda dimensin del arreglo. El valor especfico del ndice para la primera dimensin, renglon en este caso. El valor especfico del ndice para la segunda dimensin, columna en este caso.
Una vez que conocemos esto, consideremos el problema de disear una funcin que manipula los elementos de un arreglo previamente declarado. Por ejemplo, uno que establecera un valor de 1 todos los elementos del arreglo multi.
27
C-27
APENDICE C
void set_value(int m_arreglo[][COLUMNAS]) { int renglon, columna; for (renglon = 0; renglon < RENGLONES; renglon++) { for (columna = 0; columna < COLUMNAS; columna++) { m_arreglo[renglon][columna] = 1; } } } Y para llamar a esta funcin usaramos entonces: set_value(multi); Dentro de esta funcin, hemos usado los valores establecidos por #define en RENGLONES y COLUMNAS, los cuales establecen los lmites para los ciclos. Pero dentro de lo que le concierne al compilador, estas son simples constantes, es decir, no hay nada que les relacione directamente con el tamao del arreglo dentro de la funcin. renglon y columna son variables locales, por supuesto. La definicin formal del parmetro le permite al compilador determinar las caractersticas del valor del puntero que ser pasado en tiempo de ejecucin. Realmente no necesitamos la primera dimensin y, como veremos ms adelante, habr ocasiones en las que preferiremos no declararla en la definicin de los parmetros de una funcin, no quiere decir que eso se vuelva un hbito o algo con lo que haya que ser consistente. Pero la segunda dimensin debe ser usada como se ha mostrado en la expresin del parmetro. La razn por la que la necesitamos es por la forma de la evaluacin de m_arreglo[renglon][columna]. Mientras que el parmetro define el tipo de datos (int en este caso) y las variables automticas para rengln y columna son definidas en los ciclos for, slo un valor puede ser pasado usando un nico parmetro. En este caso, es el valor de multi, como lo pasamos en la llamada a la funcin, es decir, la direccin de su primer elemento, ms bien referido como un apuntador al arreglo. As que la nica manera que tenemos de informar al compilador de la segunda dimensin es incluirlo explcitamente en la definicin del parmetro de la funcin. De hecho y por lo general todas las dimensiones de orden mayor que uno, necesitan de arreglos multidimensionales. Esto significa que si hablamos de arreglos de 3 dimensiones, la segunda y tercera dimensiones deben estar especificadas en la definicin del parmetro.
28
C-28
APENDICE C
CAPITULO 8: APUNTADORES A ARREGLOS

Por supuesto que los apuntadores pueden apuntar a cualquier tipo de dato, incluyendo a rreglos. Mientras que eso ya era evidente cuando discutamos el programa 3.1, es importante expandir como es que hacemos esto cuando se trata de arreglos multidimensionales. Para revisar, en el captulo 2, establecimos que, dado un arreglo de enteros podemos apuntar un puntero a entero a ese arreglo usando: int *ptr; ptr = &mi_arreglo[0]; /* apuntamos nuestro apuntador al primer elemento del arreglo */
Como habamos establecido, el tipo de la variable apuntadora debe coincidir con el tipo de el primer elemento en el arreglo. En adicin, podemos usar un puntero como un parmetro de una funcin que est diseada para manipular un arreglo. Ejemplo: Dados: int arreglo[3] = {1, 5, 7}; void a_func(int *p); Algunos programadores prefieren escribir el prototipo de una funcin as como: void a_func(int p[]); Lo que informara a otros que usaran esta funcin que la funcin sirve para manipular los elementos de un arreglo. Por supuesto, en cualquier caso, lo que realmente le estamos pasando a la funcin es un puntero al primer elemento del arreglo, independientemente de la notacin usada en el prototipo o definicin de la funcin . Ntese que si usamos la notacin de arreglos, no hay necesidad de pasar la dimensin real del arreglo, ya que no estamos pasando el arreglo completo, sino nicamente la direccin de su primer elemento. Pasemos al problema de tratar con un arreglo bidimensional. Como se estableci en el ltimo captulo, C interpreta un arreglo de 2 dimensiones como si se tratara de un arreglo que consta de un arreglo de una dimensin. En ese caso, el primer elemento de un arreglo de 2 dimensiones de enteros, es un arreglo unidimensional de enteros. Y un puntero a un arreglo de enteros de dos dimensiones debe apuntar a ese tipo de datos. Una manera de cumplir con esto es por medio del uso de la palabra clave typedef. typedef asigna un nuevo nombre para el tipo de datos especificado. Por ejemplo: typedef unsigned char byte; hace que el nombre byte signifique el tipo de datos unsigned char. Por tanto: byte b[10]; sera entonces un arreglo de 10 elementos del tipo unsigned char. Observemos cmo en la declaracin del typedef, la palabra byte ha reemplazado aquello que normalmente sera el nombre de nuestra variable unsigned char. Por tanto, la regla para usar typedef es que el nombre del nuevo tipo de datos sea el nombre usado en la definicin del tipo de datos. As que al declarar: typedef int Arreglo[10]; Arreglo se vuelve un nuevo tipo de datos para un arreglo de 10 enteros. Es decir Arreglo mi_arreglo, declara mi_arreglo como un arreglo de 10 enteros y Arreglo arr2d[5]; hace que arr2d sea un arreglo de 5 arreglos de 10 enteros cada uno.
29
C-29
APENDICE C
Ntese que al hacer Arreglo *p1d; hace de p1d un apuntador a un arreglo de 10 elementos. Debido a que *p1d apunta al mismo tipo de datos que arr2d, asignar la direccin de el arreglo bidimensional arr2d a p1d, el puntero a arreglo unidimensional de 10 enteros, es aceptable. Es decir, si hacemos tanto: p1d = &arr2d[0]; como p1d = arr2d; ambos son correctos. Ya que el tipo de datos que usamos para nuestro apuntador es un arreglo de 10 enteros, esperaramos que al incrementar p1d por 1 cambiara su valor por 10*sizeof(int), y lo hace. Esto es que sizeof(*p1d) es 40. puedes comprobar esto t mismo escribiendo un pequeo programa. El usar typedef hace las cosas ms claras para el lector y fciles para el programador, pero no es realmente necesario. Lo que se necesita es una manera de declarar un puntero como p1d sin usar la palabra clave typedef. Es posible hacerlo y que: int (*p1d)[10]; es la declaracin apropiada, es decir p1d es aqu un apuntador a un arreglo de 10 enteros tal y como era como cuando fue declarado usando el tipo de datos Arreglo. Observa que es diferente de hacer: int *p1d[10]; lo que hara de p1d el nombre de un arreglo de 10 apuntadores al tipo entero.
30
C-30
APENDICE C
CAPITULO 9: APUNTADORES Y GESTIN DINMICA DE MEMORIA

Hay veces en que resulta conveniente reservar memoria en tiempo de ejecucin usando malloc(), calloc(), o cualquier otra funcin de reservacin de memoria. Usar este mtodo permite posponer la decisin del tamao del bloque de memoria necesario para guardar, por ejemplo un arreglo, hasta el tiempo de ejecucin. O permitirnos usar una seccin de la memoria para guardar un arreglo de enteros en un tiempo determinado, y posteriormente, cuando esa memoria no sea necesaria, liberarla para otros usos, como para guardar un arreglo de estructuras. Cuando la memoria es reservada, las funciones de reservacin de memoria (como malloc() o calloc(), etc.) regresan un puntero. El tipo de este puntero depende del estamos usando un viejo compilador de K&R o uno de los nuevos compiladores con especificaciones ANSI. Con el tipo de compilador viejo, el puntero retornado es del tipo char, mientras que con los ANSI es del tipo void. Si usas uno de estos compiladores antiguos, y quieres reservar memoria para un arreglo de enteros, tienes que hacer la conversin (cast) del puntero tipo char a un puntero de tipo entero (int). Por ejemplo, para reservar espacio para 10 enteros, escribiramos: int *iptr; iptr = (int *)malloc(10 * sizeof(int)); if (iptr == NULL) { .. Rutina del manejo de error va aqu .. } Si estamos utilizando un compilador compatible con ANSI, malloc() regresa un apuntador del tipo void y ya que un puntero de este tipo puede ser asignado a apuntar a una variable de cualquier tipo de objeto, el cast convertidor (int *) mostrado en el cdigo expuesto arriba no es necesario. La dimensin del arreglo puede ser determinada en tiempo de ejecucin por lo que no es necesario conocer este dato en tiempo de compilacin. Esto significa que el 10 de arriba puede ser una variable leda desde un archivo de datos, desde el teclado, o calculada en bas e a una necesidad, en tiempo de ejecucin. Debido a la equivalencia entre la notacin de arreglos y la notacin de punteros, una vez que el apuntador iptr ha sido asignado como arriba, podemos usar la notacin de arreglos. Por ejemplo, uno puede escribir: int k; for (k = 0; k < 10; k++) ptr[k] = 2; para establecer el valor de todos los elementos a 2. An con un buen entendimiento de los apuntadores y de los arreglos, es usual que algo que hace tropezar a los novatos en C sea la asignacin dinmica de memoria para arreglos multidimensionales. En general, nos gustara ser capaces de acceder a los elementos de dichos arreglos usando notacin de arreglos, no notacin de punteros, siempre que sea posible. Dependiendo de la aplicacin podemos o no conocer las dimensiones de un arreglo en tiempo de compilacin. Esto nos conduce a una variedad de caminos a seguir para resolver nuestra tarea. Como hemos visto, cuando alojamos dinmicamente un arreglo unidimensional, su dimensin puede ser determinada en tiempo de ejecucin. Ahora que para el alojamiento dinmico de arreglos de orden superior, nunca necesitaremos conocer la primera dimensin en tiempo de compilacin. Si es que vamos a necesitar
31
C-31
APENDICE C
conocer las otras dimensiones depende de la forma en que escribamos el cdigo. Vamos a discutir sobre varios mtodos de asignarle espacio dinmicamente a arreglos bidimensionales de enteros. Para comenzar consideremos el caso en que la segunda dimensin es conocida en tiempo de compilacin: MET ODO 1: Una manera de enfrentar este problema es usando la palabra clave typedef. Para alojar arreglos de 2 dimensiones, recordemos que las siguientes dos notaciones dan como resultado la generacin del mismo cdigo objeto: multi[renglon][columna] = 1; *(*(multi + renglon) + columna) = 1;
Tambin es cierto que las siguientes dos notaciones dan el mismo resultado: multi[renglon] *(multi + renglon)
Ya que la que est a la derecha debe evaluarse a un apuntador, la notacin de arreglos a la izquierda debe hacerlo tambin. De hecho multi[0] retornar un puntero al primer entero en el primer rengln, multi[1] un puntero al primer entero del segundo rengln, etc. En realidad multi[n] se evala como un puntero a ese arreglo de enteros que conforma el n-simo rengln de nuestro arreglo bidimensional. Esto significa que podemos pensar en multi como un arreglo de arreglos y multi[n] como un puntero al n-simo arreglo de este arreglo de arreglos. Aqu la palabra puntero (apuntador) es usada para representar el valor de una direccin. Mientras que este uso es comn en los libros, al leer instrucciones de este tipo, debemos ser cuidadosos al distinguir entre la direccin constante de un arreglo y una variable apuntadora que es un objeto que contiene datos en si misma. Veamos ahora el:
PROGRAMA 9.1
/* Program 9.1 from PTRTUT10.HTM #include <stdio.h> #include <stdlib.h> #define COLUMNAS 5 typedef int Arreglo_de_renglones[COLUMNAS]; Arreglo_de_renglones *rptr; int main(void) { int nrenglones = 10; int renglon, columna; rptr = malloc(nrenglones * COLUMNAS * sizeof(int)); for (renglon = 0; renglon < nrenglones; renglon++) { for (columna = 0; columna < COLUMNAS; columna++) { rptr[renglon][columna] = 17; } } return 0; } 6/13/97 */
32
C-32
APENDICE C
He asumido que se ha usado un compilador ANSI, as que la conversin (cast) al puntero del sin tipo (void) regresado por la funcin malloc() no es necesaria. Si estas usando un compilador no compatible con ANSI, hay que hacer la conversin usando: rptr = (Arreglo_de_renglones *)malloc(.... etc. Usando este mtodo, rptr tiene todas las caractersticas del nombre de un arreglo (excepto que rptr es modificable), y la notacin de arreglo puede ser usada en el resto del programa. Esto significa tambin que si se pretende escribir una funcin para modificar los contenidos del arreglo, se debe usar COLUMNAS como parte del parmetro de esa funcin, tal y como se hizo al estar discutiendo el paso de arreglos bidimensionales a una funcin. MET ODO 2: En el mtodo 1 de arriba, rptr se volvi un apuntador del tipo arreglo unidimensional de COLUMNAS de enteros. Es evidente entonces que existe una sintaxis para usar este tipo sin la necesidad de usar la palabra clave typedef. Si escribimos: int (*xptr)[COLUMNAS]; las variable xptr tendra las mismas caractersticas que la variable rptr del mtodo 1, y no habremos usado la palabra clave typedef. Aqu xptr es un puntero aun arreglo de enteros y el tamao de ese arreglo est dado por la constante COLUMNAS. Los parntesis hacen que la notacin de punteros predomine, a pesar de que la notacin de arreglo tiene una mayor precedencia de evaluacin. Es decir que si hubiramos escrito: int *xptr[COLUMNAS]; habramos definido a xptr como un arreglo de apuntadores consistente en un nmero de apuntadores igual a la cantidad definida por COLUMNAS. Es obvio que no se trata de lo mismo. Como sea, los arreglos de apuntadores tienen utilidad al alojar dinmicamente arreglos bidimensionales, como veremos en los siguientes dos mtodos. METODO 3: Consideremos el caso en el que no conozcamos el nmero de elementos por cada rengln en tiempo de compilacin, es decir que el nmero de renglones y el nmero de columnas ser determinado en tiempo de ejecucin. Un modo de hacerlo sera crear un arreglo de apuntadores de tipo entero (int) y luego reservar memoria para cada rengln y apuntar estos apuntadores a cada rengln. Consideremos:
PROGRAMA 9.2
/* Program 9.2 from PTRTUT10.HTM #include <stdio.h> #include <stdlib.h> 6/13/97 */
int main(void) { int nrenglones = 5; /* Ambos, nrenglones y ncolumnas pueden ser */ int ncolumnas = 10; /* evaluados o ledos en tiempo de ejecucin */ int renglon; int **renglonptr; renglonptr = malloc(nrenglones * sizeof(int *)); if (renglonptr == NULL)
33
C-33
APENDICE C
{ puts("\nError al reservar espacio para apuntadores de renglon.\n"); exit(0); } printf("\n\n\nIndice Puntero(hex) Puntero(dec) Dif.(dec)");
for (renglon = 0; renglon < nrenglones; renglon++) { renglonptr[renglon] = malloc(ncolumnas * sizeof(int)); if (renglonptr[renglon] == NULL) { printf("\nError al reservar memoria para el renglon[%d]\n",renglon); exit(0); } printf("\n%d %p %d", renglon, renglonptr[renglon], renglonptr[renglon]); if (renglon > 0) printf(" %d",((int)renglonptr[renglon] (int)renglonptr[renglon-1])); } return 0; }
En el cdigo de arriba, renglonptr es un apuntador a apuntador de tipo entero. En este caso, apunta al primer elemento de un arreglo de apuntadores del tipo int. Consideremos el nmero de llamadas a malloc(): Para obtener nuestro arreglo de apuntadores: Para obtener espacio para los renglones: Total: 1 5 ------6 llamada llamadas llamadas.
Si optas por este mtodo, observa que mientras puedes usar la notacin de arreglos para acceder a elementos individuales del arreglo, por ejemplo: renglonptr[renglon][columna] = 17;, esto no significa que los datos en el arreglo bidimensional sean continuos en memoria. Puedes, sin embargo, usar la notacin de arreglos tal y como si los datos se encontraran en un bloque continuo de memoria. Por ejemplo, puedes escribir: renglonptr[renglon][columna] = 176; tal y como se hara si renglonptr fuera el nombre de un arreglo bidimensional creado en tiempo de compilacin. Por supuesto que los valores de [renglon] y [columna] deben estar dentro de los lmites establecidos del arreglo que se ha creado, igual que con un arreglo creado en tiempo de compilacin. Si lo que queremos es tener un bloque continuo de memoria dedicado al almacenamiento de los elementos del arreglo, puede hacerse del siguiente modo: MET ODO 4: Con este mtodo reservamos un bloque de memoria para contener primero el arreglo completo. Despus creamos un arreglo de apuntadores para apuntar a cada rengln. As, aunque estamos usando un arreglo de punteros, el arreglo real en memoria es continuo. El cdigo es este:
34
C-34
APENDICE C
PROGRAMA 9.3
/* Program 9.3 from PTRTUT10.HTM #include <stdio.h> #include <stdlib.h> int main(void) { int **rptr; int *aptr; int *pruebaptr; int k; int nrenglones = 5; int ncolumnas = 8; int renglon, columna; 6/13/97 */
/* Ambos, nrenglones y ncolumnas pueden ser */ /* evaluados o leidos en tiempo de ejecucion */
/* ahora reservamos memoria para el arreglo completo */ aptr = malloc(nrenglones * ncolumnas * sizeof(int)); if (aptr == NULL) { puts("\nError al reservar memoria para el arreglo completo."); exit(0); } /* ahora reservamos espacio para los apuntadores a renglones */ rptr = malloc(nrenglones * sizeof(int *)); if (rptr == NULL) { puts("\nError al reservar memoria para los punteros"); exit(0); } /* y ahora hacemos que los apuntadores apunten */ for (k = 0; k < nrenglones; k++) { rptr[k] = aptr + (k * ncolumnas); } /* Ahora demostramos que los punteros a renglones se han incrementado */ printf("\nDemostramos que los punteros a renglones se han incrementado:"); printf("\n\nIndice Apuntador(dec) Diferencia(dec)"); for (renglon = 0; renglon < nrenglones; renglon++) { printf("\n%d %d", renglon, rptr[renglon]); if (renglon > 0) printf(" %d",((int)rptr[renglon] (int)rptr[renglon-1])); } printf("\n\nY ahora mostramos el arreglo:\n"); for (renglon = 0; renglon < nrenglones; renglon++) { for (columna = 0; columna < ncolumnas; columna++) { rptr[renglon][columna] = renglon + columna; printf("%d ", rptr[renglon][columna]); } putchar('\n'); }
35
C-35
APENDICE C
puts("\n"); /* Y aqu es donde demostramos que efectivamente estamos manejando un arreglo bidimensional contenido en un bloque continuo de memoria */ printf("Demostrando que los elementos son continuos en memoria:\n"); pruebaptr = aptr; for (renglon = 0; renglon < nrenglones; renglon++) { for (columna = 0; columna < ncolumnas; columna++) { printf("%d ", *(pruebaptr++)); } putchar('\n'); } return 0; }
Consideremos de nuevo el nmero de llamadas a malloc(): Para reservar la memoria que contendr todo el arreglo: Para reservar la memoria para el arreglo de punteros: Total: 1 1 ------2 llamada llamada llamadas.
Bien, pues cada llamada a malloc() crea un gasto adicional de espacio ya que malloc() es por lo general implementada por el sistema operativo formando una lista enlazada que contiene los datos correspondientes al tamao del bloque. Pero lo ms importante es que con arreglos grandes (varios cientos de renglones), seguirle el rastro a la memoria que debe ser liberada en algn momento, puede llegar a ser engorroso. Este ltimo mtodo, combinado con la conveniencia de la continuidad del bloque de memoria, lo que nos permite la inicializacin de todo el bloque a ceros usando memset(), hara de esta alternativa la ms conveniente. Como ejemplo final sobre el tema de arreglos multidimensionales, demostraremos el alojamiento dinmico de un arreglo de 3D. Este ejemplo mostrar una cosa ms a tener en cuenta con este tipo de alojamiento. Por las razones expuestas arriba, usaremos el ltimo mtodo. Veamos pues el siguiente cdigo:
PROGRAMA 9.4
/* Program 9.4 from PTRTUT10.HTM #include <stdio.h> #include <stdlib.h> int X_DIM=16; int Y_DIM=5; int Z_DIM=3; int main(void) { char *espacio; char ***Arr3D; int y, z, diff; 6/13/97 */
36
C-36
APENDICE C
/* Primeramente reservamos el espacio necesario para el arreglo completo */ espacio = malloc(X_DIM * Y_DIM * Z_DIM * sizeof(char)); /* enseguida reservamos el espacio para un arreglo de apuntadores, los cuales eventualmente apuntaran cada uno al primer elemento de un arreglo bidimensional de apuntadores a apuntadores */ Arr3D = malloc(Z_DIM * sizeof(char **)); /* para cada uno de estos asignamos un apuntador a un recien asignado arreglo de apuntadores a renglon */
for (z = 0; z < Z_DIM; z++) { Arr3D[z] = malloc(Y_DIM * sizeof(char *)); /* y para cada espacio de este arreglo, colocados un apuntador el primer elemento de cada renglon es el espacio del arreglo originalmente alojado */ for (y = 0; y < Y_DIM; y++) { Arr3D[z][y] = espacio + (z*(X_DIM * Y_DIM) + y*X_DIM); } } /* Y, ahora, revisamos cada direccion en nuestro arreglo 3D para comprobar que los indices de nuestro apuntador Arr3d esten alojados de manera continua en memoria */ for (z = 0; z < Z_DIM; z++) { printf("Direccion del arreglo %d es %ph\n", z, *Arr3D[z]); for ( y = 0; y < Y_DIM; y++) { printf("El arreglo %d y el renglon %d comienzan en %ph", z, y, Arr3D[z][y]); diff = Arr3D[z][y] - espacio; printf(" dif = %ph ",diff); printf(" z = %d y = %d\n", z, y); } } return 0; }
Si has seguido este tutorial hasta este punto no debes tener problemas descifrando el cdigo del programa de arriba basndote en los comentarios. Hay un par de cuestiones que explicar de todos modos, comencemos por la lnea que dice: Arr3D[z][y] = espacio + (z*(X_DIM * Y_DIM) + y*X_DIM); Observa que aqu espacio es un apuntador de tipo caracter, que es el mismo tipo que Arr3D[z][y]. Es importante que, al agregar un entero, como el obtenido por la evaluacin de la expresin (z*(X_DIM * Y_DIM) + y * X_DIM), a un apuntador, el resultado es un nuevo valor de apuntador. Y cuando asignamos valores de apuntador a variables apuntadoras, los tipos de datos del valor y de la variable deben coincidir.
37
C-37
APENDICE C
CAPITULO 10: APUNTADORES A FUNCIONES

Hasta este punto hemos discutido el uso de apuntadores con objetos de datos. C permite tambin la declaracin de apuntadores a funciones. Los apuntadores a funciones tienen variedad de usos y algunos de estos sern expuestos aqu. Consideremos el siguiente problema real: Tenemos que escribir una funcin que sea capaz de ordenar virtualmente cualquier coleccin de datos que pueda ser contenida en un arreglo. Sea este un arreglo de cadenas, de enteros, flotantes, e incluso estructuras. El algoritmo de ordenacin puede ser el mismo para todos. Por ejemplo, puede ser un simple algoritmo de ordenacin por el mtodo de la burbuja, o el mucho ms complejo algoritmo de ordenacin quick sort o por shell sort. Usaremos un simple algoritmo de burbuja para nuestros fines didcticos. Sedgewick [1] ha descrito el algoritmo de ordenacin por burbuja usando cdigo C al establecer una funcin a la que, una vez que se le ha pasado el apuntador al arreglo, ordena el arreglo. Si le llamamos a esta funcin bubble(), un programa de ordenacin es descrito por bubble_1.c en el cdigo que sigue:
bubble_1.c
/* Program bubble_1.c from PTRTUT10.HTM #include <stdio.h> int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; void bubble(int a[], int N); int main(void) { int i; putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } bubble(arr,10); putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } return 0; } void bubble(int a[], int N) { int i, j, t; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) 6/13/97 */
38
C-38
APENDICE C
{ if (a[j-1] > a[j]) { t = a[j-1]; a[j-1] = a[j]; a[j] = t; } } } }
El mtodo de la burbuja es un algoritmo de ordenacin de los ms sencillos. El algoritmo busca en el arreglo desde el segundo hasta el ltimo elemento comparando cada uno con el que le precede. Si el elemento que le precede es mayor que el elemento actual, los elementos son intercambiados en su posicin de tal modo que el ms grande quede ms cerca del final del arreglo. En la primera pasada, esto resulta en que el elemento ms grande termina al final del arreglo. El arreglo est ahora limitado a todos los elementos, a excepcin del ltimo y el proceso se repite. Eso pone el siguiente elemento ms grande en el lugar que precede al elemento ms grande. El proceso se repite un nmero de veces igual al nmero total de elementos menos 1. El resultado final es un arreglo ordenado. Aqu nuestra funcin est diseada para ordenar un arreglo de enteros. As que en la lnea comparamos enteros y de la lnea 2 a la 4 usamos un almacn temporal de enteros para guardar enteros. Lo que queremos averiguar es que si podemos modificar este cdigo para que pueda usarse con cualquier tipo de datos, es decir que no est restringido a la ordenacin de enteros. Al mismo tiempo no deseamos modificar nuestro algoritmo ni el cdigo asociado a l cada vez que lo usamos. Comencemos por remover la comparacin dentro de la funcin bubble() para que nos sea relativamente fcil modificar la funcin de comparacin sin tener que re-escribir pedazos relacionados con el algoritmo de ordenacin en s. Esto nos trae como resultado el programa bubble_2.c:
bubble_2.c
/* Program bubble_2.c from PTRTUT10.HTM /* Separamos la funcin de comparacin */ 6/13/97 */
#include <stdio.h> int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; void bubble(int a[], int N); int compare(int m, int n);
int main(void) { int i; putchar('\n');
39
C-39
APENDICE C
for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } bubble(arr,10); putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } return 0; }
void bubble(int a[], int N) { int i, j, t; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) { if (compare(a[j-1], a[j])) { t = a[j-1]; a[j-1] = a[j]; a[j] = t; } } } }
int compare(int m, int n) { return (m > n); }
Si nuestro objetivo es hacer de nuestra rutina de ordenacin independiente del tipo de datos, una manera de lograrlo es usar apuntadores sin tipo (void) para que apunten a los datos en lugar de usar el tipo de datos enteros. Para dirigirnos a este objetivo, comenzaremos por modificar algunas cosas en nuestro programa de arriba, de modo que podamos usar apuntadores. Empecemos por meter apuntadores del tipo entero:
bubble_3.c
/* Program bubble_3.c from PTRTUT10.HTM #include <stdio.h> int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; void bubble(int *p, int N); int compare(int *m, int *n); 6/13/97 */
40
C-40
APENDICE C
int main(void) { int i; putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } bubble(arr,10); putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } return 0; }
void bubble(int *p, int N) { int i, j, t; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) { if (compare(&p[j-1], &p[j])) { t = p[j-1]; p[j-1] = p[j]; p[j] = t; } } } }
int compare(int *m, int *n) { return (*m > *n); }
Observa los cambios. Estamos ahora pasando un apuntador a un entero (o a un arreglo de enteros) a bubble(). Y desde dentro de bubble estamos pasando apuntadores a los elementos que queremos comparar del arreglo a nuestra funcin de comparacin. Y por supuesto estamos desreferenciando estos apuntadores en nuestra funcin compare() de modo que se haga la comparacin real entre elementos. Nuestro siguiente paso ser convertir los apuntadores en bubble() a apuntadores sin tipo de tal modo que la funcin se vuelva ms insensible al tipo de datos a ordenar. Esto se muestra en el programa bubble_4.c
bubble_4.c
/* Program bubble_4.c from PTRTUT10.HTM #include <stdio.h> int arr[10] = { 3,6,1,2,3,8,4,1,7,2}; 6/13/97 */
41
C-41
APENDICE C
void bubble(int *p, int N); int compare(void *m, void *n);
int main(void) { int i; putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } bubble(arr,10); putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } return 0; }
void bubble(int *p, int N) { int i, j, t; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) { if (compare((void *)&p[j-1], (void *)&p[j])) { t = p[j-1]; p[j-1] = p[j]; p[j] = t; } } } }
int compare(void *m, void *n) { int *m1, *n1; m1 = (int *)m; n1 = (int *)n; return (*m1 > *n1); }
Observa que, al hacer esto, en compare() tuvimos que introducir la conversin del puntero void pasado, al tipo de datos que realmente se est ordenando. Pero, como veremos ms tarde, eso est bien. Y ya que lo que se est pasando a bubble() es an un puntero a un arreglo de enteros, tuvimos que convertir esos punteros a punteros sin tipo cuando los pasamos como parmetros en nuestra llamada a la funcin compare().
42
C-42
APENDICE C
Tratemos ahora el problema de qu le vamos a pasar a bubble(). Queremos hacer que el primer parmetro de esta funcin sea un puntero sin tipo. Pero, eso significa que dentro de bubble() debemos hacer algo al respecto de la variable t, la que actualmente es de tipo entero. Adems, donde usamos t=p[j -1]; el tipo de p[j-1] necesita ser conocido en razn de saber cuantos bytes sern copiados a la variable t (o a cualquier otras cosa con la que reemplacemos a t). Hasta ahora, en bubble_4.c, el conocimiento dentro de bubble() del tipo de datos a ser ordenado (y por tanto el tamao individual de cada elemento) es obtenido de el hecho de que el primer parmetro es un puntero de tipo entero. Si queremos ser capaces de utilizar a bubble() para ordenar cualquier tipo de datos, necesitamos hacer de este parmetro un puntero del tipo void. Pero al hacer eso, perdemos la informacin respecto del tamao individual de los elementos dentro del arreglo. As que en bubble_5.c aadiremos un parmetro extra para manejar la informacin del tamao. Estos cambios desde bubble_4.c a bubble_5.c son, al parecer, un poco ms extensos que aquellos que hicimos antes. As que revisa cuidadosamente las diferencias:
bubble_5.c
/* Program bubble_5.c from PTRTUT10.HTM 6/13/97 */
#include <stdio.h> #include <string.h>
long arr[10] = { 3,6,1,2,3,8,4,1,7,2}; void bubble(void *p, size_t width, int N); int compare(void *m, void *n);
int main(void) { int i; putchar('\n'); for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } bubble(arr, sizeof(long), 10); putchar('\n'); for (i = 0; i < 10; i++) { printf("%ld ", arr[i]); } return 0; }
43
C-43
APENDICE C
void bubble(void *p, size_t width, int N) { int i, j; unsigned char buf[4]; unsigned char *bp = p; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) { if (compare((void *)(bp + width*(j-1)), (void *)(bp + j*width))) /* 1 */ { /* t = p[j-1]; */ memcpy(buf, bp + width*(j-1), width); /* p[j-1] = p[j]; */ memcpy(bp + width*(j-1), bp + j*width , width); /* p[j] = t; */ memcpy(bp + j*width, buf, width); } } } }
int compare(void *m, void *n) { long *m1, *n1; m1 = (long *)m; n1 = (long *)n; return (*m1 > *n1); }
Revisa que he cambiado el tipo de datos del arreglo de int a long para mostrar los cambios necesarios en la funcin compare(). Dentro de bubble() he construido un arreglo con la variable t (la cual hemos tenido que cambiar del tipo de datos int al tipo long). He aadido un buffer de tamao 4 de tipo unsigned char, el cual es el tamao requerido para almacenar un entero largo (esto cambiar en futuras modificaciones al cdigo). El apuntador *bp de tipo unsigned char es usado para apuntar al inicio del arreglo a ordenar, es decir al primer elemento del arreglo. Tuvimos tambin que modificar lo que se le p asa a compare(), y el modo en que hacamos el intercambio de elementos cuando la comparacin indicaba que se haca el intercambio. El uso de memcpy() y de la notacin de punteros va en funcin de reducir la sensibilidad al tipo de datos. De nuevo, el hacer una revisin cuidadosa de bubble_5.c con bubble_4.c puede resultar muy provechoso para entender lo que est sucediendo y porqu. Vamos ahora con bubble_6.c donde usamos la misma funcin bubble() que usamos en bubble_5.c ahora para ordenar cadenas en lugar de nmeros enteros. Por supuesto que hemos tenido que modificar la funcin de comparacin ya que el modo de comparar cadenas es diferente del modo en que se comparan nmeros enteros. Tambin en bubble_6.c hemos removido las lneas que dentro de bubble() estaban como comentarios en bubble_5.c
44
C-44
APENDICE C
bubble_6.c
/* Program bubble_6.c from PTRTUT10.HTM 6/13/97 */
#include <stdio.h> #include <string.h>
#define MAX_BUF 256
char arr2[5][20] = {
"Mickey Mouse", "Donald Duck", "Minnie Mouse", "Goofy", "Ted Jensen" };
void bubble(void *p, int width, int N); int compare(void *m, void *n);
int main(void) { int i; putchar('\n'); for (i = 0; i < 5; i++) { printf("%s\n", arr2[i]); } bubble(arr2, 20, 5); putchar('\n\n'); for (i = 0; i < 5; i++) { printf("%s\n", arr2[i]); } return 0; }
void bubble(void *p, int width, int N) { int i, j, k; unsigned char buf[MAX_BUF]; unsigned char *bp = p; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) { k = compare((void *)(bp + width*(j-1)), (void *)(bp + j*width));
45
C-45
APENDICE C
if (k > 0) { memcpy(buf, bp + width*(j-1), width); memcpy(bp + width*(j-1), bp + j*width , width); memcpy(bp + j*width, buf, width); } } } }
int compare(void *m, void *n) { char *m1 = m; char *n1 = n; return (strcmp(m1,n1)); }
Pero el hecho de que bubble() no fuera modificada de aquella que usamos en bubble_5.c indica que esta funcin es capaz de ordenar una amplia variedad de tipos de datos. Lo que entonces hay que hacer es pasarle a bubble() el nombre de la funcin de comparacin a usar para que esta sea realmente universal. Al igual que el nombre de un arreglo es la direccin de su primer elemento en el segmento de datos, el nombre de una funcin se interpreta como la direccin de esa funcin en el segmento de cdigo. As que necesitamos un apuntador a una funcin. En este caso, la funcin de comparacin. Los punteros a funciones deben coincidir a las funciones apuntadas en el nmero y tipos de parmetros y en el tipo del valor regresado por la funcin. En nuestro caso, declaramos nuestro apuntador de funcin como:
int (*fptr) (const void *p1, const void *p2); Considera que si lo hubiramos escrito como:
int *fptr(const void *p1, const void *p2); obtendramos el prototipo de un funcin que regresa un puntero de tipo entero. Debido a que en C los parntesis tienen un orden de precedencia mayor que el operador de punteros *, al poner entre parntesis la cadena (*fptr) estamos indicando que estamos declarando un apuntador a una funcin. Ahora modifiquemos nuestra declaracin de bubble() al aadirle como 4 parmetro, un apuntador a una funcin del tipo apropiado. Entonces su prototipo queda como: void bubble(void *p, int width, int N, int(*fptr)(const void *, const void *)); Cuando llamemos a bubble(), insertaremos el nombre de la funcin de comparacin a utilizar. bubble_7.c demuestra cmo este mtodo permite el uso de la misma funcin bubble() para ordenar datos de diferentes tipos.
46
C-46
APENDICE C
bubble_7.c
/* Program bubble_7.c from PTRTUT10.HTM #include <stdio.h> #include <string.h> 6/10/97 */
#define MAX_BUF 256
long arr[10] = { 3,6,1,2,3,8,4,1,7,2}; char arr2[5][20] = { "Mickey Mouse", "Donald Duck", "Minnie Mouse", "Goofy", "Ted Jensen" };
void bubble(void *p, int width, int N, int(*fptr)(const void *, const void *)); int compare_string(const void *m, const void *n); int compare_long(const void *m, const void *n);
int main(void) { int i; puts("\nAntes de ordenar:\n"); for (i = 0; i < 10; i++) { printf("%ld ",arr[i]); } puts("\n"); for (i = 0; i < 5; i++) { printf("%s\n", arr2[i]); } bubble(arr, 4, 10, compare_long); bubble(arr2, 20, 5, compare_string); puts("\n\nDespus de ordenar:\n"); for (i = 0; i < 10; i++) { printf("%d ",arr[i]); } puts("\n"); for (i = 0; i < 5; i++) { printf("%s\n", arr2[i]); } return 0; } /* mostramos los enteros largos */
/* mostramos las cadenas */
/* ordenamos los enteros largos */ /* ordenamos las cadenas */
/* mostramos los enteros largos ordenados */
/* mostramos las cadenas ya ordenadas */
47
C-47
APENDICE C
void bubble(void *p, int width, int N, int(*fptr)(const void *, const void *)) { int i, j, k; unsigned char buf[MAX_BUF]; unsigned char *bp = p; for (i = N-1; i >= 0; i--) { for (j = 1; j <= i; j++) { k = fptr((void *)(bp + width*(j-1)), (void *)(bp + j*width)); if (k > 0) { memcpy(buf, bp + width*(j-1), width); memcpy(bp + width*(j-1), bp + j*width , width); memcpy(bp + j*width, buf, width); } } } }
int compare_string(const void *m, const void *n) { char *m1 = (char *)m; char *n1 = (char *)n; return (strcmp(m1,n1)); }
int compare_long(const void *m, const void *n) { long *m1, *n1; m1 = (long *)m; n1 = (long *)n; return (*m1 > *n1); }
Referencias en el captulo 10: [1] Robert Sedgewick "Algorithms in C" Addison-Wesley ISBN 0-201-51425-7
48
C-48
APENDICE C
EPILOGO
Escrib el presente material para dar una introduccin sobre los apuntadores a los que comienzan en C. En C, entre ms entienda uno sobre apuntadores, mayor ser la flexibilidad que se adquiera para escribir cdigo. El contenido de este trabajo expande lo que fue mi primer esfuerzo que tena por nombre ptr_help.txt y que se encontraba en una de las primeras versiones de la coleccin de SNIPPETS de C de Bob Stout. El contenido de esta versin se ha actualizado de aquella encontrada como PTRTUTOT.ZIP incluida en el archivo SNIP9510.ZIP. Estoy siempre dispuesto a recibir crtica constructiva sobre el presente material, o revisiones o peticiones para la adicin de otro material importante. Por tanto, si tienes preguntas, comentarios, crticas, etc. respecto de lo que en este documento se ha expuesto, me agradara mucho que me contactaras por medio de email a:
tjensen@ix.netcom.com
49
C-49
Bibliografa:
BRASSARD, Gilles. Fundamentos de Algortmica. Edit. Prentice Hall. 1997. DEITEL, Harvey M. y Deitel, Paul J. Cmo Programar en C/C++. Edit. Prentice Hall. Mxico, 1999. 2a. edicin. FROSYTHE, Alexandra. Lenguajes de Diagramas de Flujo. Edit. Limusa. TERRENCE, W. Pratt. Lenguajes de Programacin. Edit. Prentice Hall. TREMBAY, Jean Paul. Introduccin a las Ciencias de las Computadoras, Enfoque Algortmico. Edit. Mc Graw Hill. AGUILAR, Joyanes Luis. Fundamentos de Programacin Algoritmos Y Estructura de Datos, Segunda Edicin Pgs. 714 ( 95- 161_ capitulo 4-) Edit. Mc Graw Hill. Salamanca 1996
Referencias:
http://users.domaindlx.com/hqrdksm/DATOS/Algoritmo.pdf http://www.elprisma.com/apuntes/curso.asp?id=10502 http://www.cimat.mx/~alram/cpa/pointersC.pdf
http://www. netcom.com/~tjensen/ptr/cpoint.htm tjensen@ix.netcom.com

ANTOLOGIA Programacion C

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

ANTOLOGIA Programacion C

Caricato da

Copyright:

Formati disponibili

Licenciaturas Ejecutivas L S C A

TIPOS DEFINIDOS POR EL USUARIO: ................................................................................... 27

Expresiones simples.......................................................................................................................... 38 Expresiones complejas...................................................................................................................... 39

ESTRUCTURA DE DECISIN .................................................................................................... 65

ESTRUCTURA DE SELECCIN MULTIPLE ........................................................................... 133

APENDICE A ...................................................................................................... A-1 INTRODUCCIN A LA PROGRAMACIN ESTRUCTURADA

APENDICE B........................................................................................................ B-1 APUNTADORES EN C y C++

APENDICE C......................................................................................................... C-1 TUTORIAL SOBRE APUNTADORES Y ARREGLOS EN C

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

: ALGORITMICA PARA PROGRAMACION : YAMIL ARMANDO CERQUERA ROJAS

TIPOS DEFINIDOS POR EL USUARIO: ................................................................................................27

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ESTRUCTURA DE DECISIN ...............................................................................................................65

ESTRUCTURAS CCLICAS ....................................................................................................................97

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

Intrpretes Editores Ensambladores Compiladores Administradores de bases de datos.

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

PARA QUE SIRVE LA PROGRAMACIN

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

QUE ES UN LENGUAJE DE PROGRAMACIN

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

NIVELES DE LOS LENGUAJES

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

EL SECRETO DE PROGRAMAR EST EN LA ESTRUCTURACIN

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ELEMENTOS BSICOS DE UN PROGRAMA

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ELEMENTOS BSICOS DE UN PROGRAMA EN C

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

#include<stdio.h> #include<conio.h> main()

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

clrscr(); gotoxy(20,10); printf("BIENVENIDO AL CURSO DE C ESTNDAR"); delay(2500); }

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas

ALGORITMICA PARA PROGRAMACION

Ing. Yamil Armando Cerquera Rojas