UNIVERSIDAD DE EL SALVADOR FACULTAD DE INGENIERA Y ARQUITECTURA ESCUELA DE INGENIERA ELCTRICA INTRODUCCIN A LA INFORMTICA

GUIA # 6: ESTRUCTURAS DE CONTROL

Alumnos: Jos Edgardo Escobar Hernndez EH10002 David Alexander Portillo Rodrguez PR10059 Jonathan Amlcar Mendoza Ortiz MO10019 Nstor Gabriel Vsquez Lpez VL10008 Grupo de Laboratorio: 05

Instructor: Br. Ral Alvarenga

Ciudad Universitaria, Mayo 2012.

INDICE

Introduccin 3

Objetivos.. 4

Marco Terico...........................................................................................................5

Asignacin...............................................................................................................13

Conclusiones20

Bibliografa..21

INTRODUCCION
Las estructuras de control permiten modificar el uso de ejecucin de las instrucciones de un algoritmo o programa. Se utilizan cuando en el desarrollo de la solucin de un problema se hace necesario ejecutar una serie de instrucciones un numero repetido de veces, por ejemplo sumar los enteros desde 0 hasta 100, sumar los pares que estn desde 0 hasta 100 o sumar los primos que se encuentran desde 0 hasta 100, este tipo de aplicaciones se requiere saber sumar y aunque la accin es simple se convierte en tediosa el hacerla muchas veces.

Otra aplicacin podra ser: en un proceso industrial se debe estar tomando lecturas de presin, temperatura, velocidad de las bandas transportadoras y peso de cierto producto y cada medida ya que hacerla cada dos segundo y por cada diez minutos se debe presentar la media aritmtica y la desviacin estndar de cada uno de estos parmetros, aqu no se tiene otra salida de utilizar una computadoras que tenga instalado un programa que sea capaz de aceptar esta informacin y procesarla.

Para este tipo de aplicaciones ANSI C presenta muchas ventajas en relacin a otros lenguajes de programacin, lo que se debe dominar es el uso de las sentencias while, for y do... while, razn por la cual son cubiertas en la presente gua de laboratorio. En principio, las sentencias de un programa en C se ejecutan secuencialmente, esto es, cada una a continuacin de la anterior empezando por la primera y acabando por la ltima. El lenguaje C dispone de varias sentencias para modificar este flujo secuencial de la ejecucin.

Las ms utilizadas se agrupan en dos familias: las bifurcaciones, que permiten elegir entre dos o ms opciones segn ciertas condiciones, y los bucles, que permiten ejecutar repetidamente un conjunto de instrucciones tantas veces como se desee, cambiando o actualizando ciertos valores.

OBJETIVOS

OBJETIVO GENERAL: Que los /las participantes dominen el control de flujo de un programa escrito en ANSI C.

OBJETIVOS ESPECIFICOS:

Utilizar los bucles o lazos, para optimizar el cdigo de un programa. Escribir algunos pequeos programas que permitan evaluar los comandos y directivas de control de flujo. Conocer las caractersticas que cada estructura de repeticin posee. Desarrollar programas utilizando, cuando sea necesario, cualquiera de las estructuras de repeticin.

Mejorar las destrezas en la escritura de cdigos, as como su depuracin, necesarias para la correcta compilacin y ejecucin de cdigos.

MARCO TEORICO Bucles

Los bucles nos ofrecen la solucin cuando queremos repetir una tarea un nmero determinado de veces. Supongamos que queremos escribir 100 veces la palabra hola. Con lo que sabemos hasta ahora haramos:

#include <stdio.h> int main() { printf( "Hola\n"); printf( "Hola\n"); printf( "Hola\n"); printf( "Hola\n"); printf( "Hola\n"); ... (y as hasta 100 veces) }

Sera una locura! Y si queremos repetirlo ms veces nos quedara un programa de lo ms largo. Sin embargo, usando por ejemplo un bucle for, el programa quedara: #include <stdio.h> int main() { int i; for ( i=0 ; i<100 ; i++ ) { printf( "Hola\n" ); } }

Con lo que tenemos un programa ms corto.

El bucle While
En lenguaje C, para escribir una instruccin repetitiva mientras se utiliza la sintaxis: while ( <expresin_lgica> ) { <bloque_de_instrucciones> }

Cuando el <bloque_de_instrucciones> slo contiene una instruccin, los caracteres abrir llave ({) y cerrar llave (}) son opcionales. Por otra parte, al igual que en las instrucciones alternativas doble y simple, a la <expresin_lgica> de una instruccin repetitiva while, tambin se le llama condicin. Para que se ejecute el <bloque_de_instrucciones>, la condicin tiene que ser verdadera. Por el contrario, si la condicin es falsa, el <bloque_de_instrucciones> no se ejecuta. Por tanto, cuando el flujo de un programa llega a un bucle while, existen dos posibilidades: 1. Si la condicin se evala a falsa, el bloque de instrucciones no se ejecuta, y el bucle while finaliza sin realizar ninguna iteracin. 2. Si la condicin se evala a verdadera, el bloque de instrucciones s que se ejecuta y, despus, se vuelve a evaluar la condicin, para decidir, de nuevo, si el bloque de instrucciones se vuelve a ejecutar o no. Y as sucesivamente, hasta que, la condicin sea falsa. El <bloque_de_instrucciones> de un bucle while puede ejecutarse cero o ms veces (iteraciones). Si el <bloque_de_instrucciones> se ejecuta al menos una vez, seguir ejecutndose repetidamente, mientras que, la condicin sea verdadera. Pero, hay que tener cuidado de que el bucle no sea infinito. Cuando la condicin de un bucle while se evala siempre a verdadera, se dice que se ha producido un bucle infinito, ya que, el programa nunca termina. Un bucle infinito es un error lgico. Es importante hacer hincapi en el hecho de que, en un bucle while, primero se evala la condicin y, en el caso de que sta sea verdadera, entonces se ejecuta el bloque de instrucciones. Veremos que, en el bucle do...while, el procedimiento es al revs. En l, primero se ejecuta el bloque de instrucciones y, despus, se evala la condicin. Para que un bucle while no sea infinito, en el bloque de instrucciones debe ocurrir algo para que la condicin deje de ser verdadera. En la mayora de los casos, la condicin se hace falsa al cambiar el valor de una variable. En resumen, una instruccin repetitiva while permite ejecutar, repetidamente, (cero o ms veces) un bloque de instrucciones, mientras que, una determinada condicin sea verdadera. Ejemplo 1: Se quiere escribir un programa que muestre por pantalla los primeros diez nmeros naturales: 1 2 3 4 5 6 7 8 9 10

En lenguaje C, para resolver el problema de este ejemplo se puede escribir: #include <stdio.h> int main() { int contador; printf( "\n " ); contador = 1; /* Inicializacin del contador */ while ( contador <= 10 ) /* Condicin */ { printf( "%d ", contador ); /* Salida */ contador++; /* Incremento del contador */ } return 0; }

El bucle DoWhile
En lenguaje C, para escribir una instruccin repetitiva hacer...mientras se utiliza la sintaxis:

do { <bloque_de_instrucciones> } while ( <expresin_lgica> );

Cuando el <bloque_de_instrucciones> slo contiene una instruccin, los caracteres abrir llave ({) y cerrar llave (}) son opcionales. Adems, como se puede apreciar, la instruccin repetitiva do...while, tambin hace uso de una condicin. En un bucle do...while, primero se ejecuta el bloque de instrucciones y, despus, se evala la condicin. En el caso de que sta sea verdadera, se vuelve a ejecutar el bloque de instrucciones. Y as sucesivamente, hasta que, la condicin sea falsa.

Por consiguiente, cuando el flujo de un programa llega a un bucle do...while, existen dos posibilidades: 1. Se ejecuta el bloque de instrucciones y, despus, si la condicin se evala a falsa, el bloque de instrucciones no se vuelve a ejecutar, de manera que, el bucle do...while finaliza, habiendo realizado una sola iteracin. 2. Se ejecuta el bloque de instrucciones y, a continuacin, si la condicin se evala a verdadera, el bloque de instrucciones se vuelve a ejecutar. Y as sucesivamente, hasta que la condicin sea falsa. El <bloque_de_instrucciones> de un bucle do...while puede ejecutarse una o ms veces (iteraciones). Tambin hay que prevenir que el bucle no sea infinito. En resumen, una instruccin repetitiva do...while permite ejecutar repetidamente (una o ms veces) un bloque de instrucciones, mientras que, una determinada condicin sea verdadera. Ejemplo 1: De modo que, utilizando un bucle do...while, el problema del ejemplo anterior, se puede resolver con el cdigo: #include <stdio.h> int main() { int contador; printf( "\n " ); contador = 1; /* Inicializacin del contador */ do { printf( "%d ", contador ); /* Salida */ contador++; /* Incremento */ } while ( contador <= 10 ); /* Condicin */ return 0; } Como ya se ha dicho, el bucle do...while puede iterar una o ms veces, por tanto, cuando un bloque de instrucciones debe iterar al menos una vez, generalmente, es mejor utilizar un bucle do...while que un bucle while.

El bucle For
En lenguaje C, para escribir una instruccin repetitiva para se utiliza la sintaxis: for ( <expresin_1> ; <expresin_2> ; <expresin_3> ) { <bloque_de_instrucciones> }

Cuando el <bloque_de_instrucciones> slo contiene una instruccin, los caracteres abrir llave ({) y cerrar llave (}) son opcionales. Por otro lado, el bucle for es ideal usarlo cuando, de antemano, ya se sabe el nmero de veces (iteraciones) que tiene que ejecutarse un determinado bloque de instrucciones. El bucle para es una variante del bucle mientras y, al igual que ste, puede iterar cero o ms veces. Sin embargo, el bucle for slo se suele usar cuando se conoce el nmero exacto de veces que tiene que iterar el bucle. ste es el caso del problema planteado en el ejemplo 1, en el cual, se sabe de antemano que el bucle tiene que iterar, exactamente, diez veces. Ejemplo 1: Por tanto, dicho problema, se puede resolver con una instruccin repetitiva for de la siguiente forma: #include <stdio.h> int main() { int contador; printf( "\n " ); for ( contador = 1 ; contador <= 10 ; contador++ ) printf( "%d ", contador ); return 0; } En este caso, <expresin_1>, <expresin_2> y <expresin_3>, se corresponden, respectivamente, con:

la inicializacin de la variable contador, la condicin de salida del bucle y el incremento de la variable contado de una instruccin repetitiva mientras.

En otros lenguajes, como Basic, la sentencia for es muy rgida. En cambio en C es muy flexible. Se puede omitir cualquiera de las secciones (inicializacin, condiciones o incrementos). Tambin se pueden poner ms de una variable a inicializar, ms de una condicin y ms de un incremento. Por ejemplo, el siguiente programa sera perfectamente correcto:

#include <stdio.h> int main() { int i, j; for( i=0, j=5 ; i<10 ; i++, j=j+5 ) { printf( "Hola " ); printf( "Esta es la lnea %i", i ); printf( "j vale = %i\n", j ); } return 0; }

Como vemos en el ejemplo tenemos ms de una variable en la seccin de inicializacin y en la de incrementos. Tambin podamos haber puesto ms de una condicin. Los elementos de cada seccin se separan por comas. Cada seccin se separa por punto y coma.

10

Cundo usar un bucle u otro? A la hora de elegir un bucle u otro, debemos hacernos la siguiente pregunta:

Se conoce, de antemano, el nmero de veces (iteraciones) que tiene que ejecutarse un determinado bloque de instrucciones?

Si la respuesta es afirmativa, habitualmente se usa un bucle for. En caso contrario, nos plantearemos la siguiente pregunta:

El bloque de instrucciones debe ejecutarse al menos una vez?

En este caso, si la respuesta es afirmativa, generalmente haremos uso de un bucle do...while, y si la respuesta es negativa, usaremos un bucle while.

Sentencias de salto: break y continue:

Hay dos sentencias que modifican el orden del flujo de instrucciones dentro de una estructura de iteracin. Son las sentencias break y continue. Ambas sentencias, en una estructura de iteracin, se presentan siempre condicionadas.

brake:
Una sentencia break dentro de un bloque de instrucciones de una estructura de iteracin interrumpe la ejecucin de las restantes sentencias iteradas y abandona la estructura de control, asignando al contador de programa la direccin de la siguiente sentencia posterior a la llave que cierra el bloque de sentencias de la estructura de control. Por ejemplo, podemos hacer un programa que solicite al usuario que vaya introduciendo nmeros por teclado hasta que la entrada sea un nmero par. En ese momento el programa abandonar la solicitud de datos e indicar cuntos enteros ha introducido el usuario hasta introducir uno que sea par. El cdigo podra quedar as:

#include <stdio.h> void main(void) { short i, num; for(i = 1 ; ; i++) { printf("Introduzca un entero ... "); scanf("%hd",&num); if(num % 2 == 0) break; } printf("Ha introducido el entero par %hd",num); printf(" despus de %hd impares. ",i - 1); }

11

Se habrn introducido tantos enteros como indique la variable i. De ellos, todos menos el ltimo habrn sido impares. Desde luego, el cdigo sera igualmente vlido si la expresin que condiciona al break se hubiese colocado en el segundo espacio que ofrece la sintaxis del for: all donde se colocan las condiciones de permanencia. Habitualmente esta sentencia break siempre podr evitarse con un correcto diseo de la estructura de control. En la medida de lo posible, es mejor no habituarse a usar esta sentencia de salto que interrumpe el flujo habitual del cdigo. A veces, sin embargo, el cdigo adquiere mayor claridad si se utiliza el break.

continue:
Una sentencia continue dentro de un bloque de instrucciones de una estructura de iteracin interrumpe la ejecucin de las restantes sentencias iteradas y vuelve al inicio de las sentencias de la estructura de control, si es que la condicin de permanencia as lo permite. Funciona de forma similar a break. Sin embargo, en vez de forzar la terminacin, continue fuerza una nueva iteracin del bucle y salta cualquier cdigo que exista entremedias. Para el bucle for, continue hace que se ejecuten las partes de prueba condicional y de incremento del bucle. Para los bucles while y do-while, el control del programa pasa a la prueba condicional.

Veamos, por ejemplo, un programa que muestra por pantalla los 100 primeros enteros pares positivos. Un modo de resolver ese programa podra ser el siguiente:

#include <stdio.h> void main(void) { short i; for(i = 1 ;i <= 100 ; i++) { if(i % 2) continue; printf("%4hd\t",i); } }

Cuando el resto de la divisin entera entre el contador i y el nmero 2 es distinto de cero, entonces el nmero es impar y se solicita que se ejecute la sentencia continue. Entonces se abandona la ejecucin del resto de las sentencias del bloque iterado y, si la condicin de permanencia en la iteracin as lo permite, vuelve a comenzar la iteracin por su primera sentencia del bloque iterado.

12

ASIGNACION
1. La constante pi esta definida por la serie que se muestra a continuacin. Desarrollar un programa escrito en ANSI C que utilizando lazos while calcule el valor de p. El lazo se romper cuando la diferencia del trmino anterior y actual sea menor que 0.0000000005.

#include <stdio.h> int main() { double pi = 4.0 ,k = 2; printf("\nEste programa calcula la constante pi."); while ( 1.0 ) { if ( (int) k % 2 ) pi += 4/(2*k-1); else pi -= 4/(2*k-1); if ( ( 4./(2.*(k -1.)-1. ) - 4./(2.*k-1.) ) < 0.00000000005 ) break; k++; } printf("\n\n\npi = %0.15f\n\n\n", pi); return 0; }

13

2. Para la siguiente serie considerar slo los primeros 40 trminos. Utilizar lazos for's para resolver la serie y do... while para la validacin de datos.

#include <stdio.h> #include <stdlib.h> int main() { double t, num = 1, den = 2, d = 1; int n; do{ printf("Inserte un valor 't' para calcularle el valor del seno inverso\n\n"); scanf("%lf", &t); }while((t < -1) || (t > 1)); double arcsin = t, pot = t; for(n = 1; n <= 100; n++) { pot = pot * t * t; den = den * ( d + 2); arcsin = arcsin + ((num * pot) / den); d = d + 2; num = num * d; } printf("El valor del seno inverso de: %lf es: %lf \n", t, arcsin); system("pause"); return 0; }

14

3. Mientras el trmino sea mayor que 0.0000000001 se continuar iterando. Aplicar lazos while's para desarrollar la siguiente:

#include <stdio.h> #include <stdlib.h> int main(){ float x, suma = 0, serie = 0, term = 1, signo = 1; float den = 3, num = 2, k = 2, d = 3, h = 3; do{ printf("Introduzca un valor para x: \n"); scanf("%f", &x); }while((x <= -1) || (x > 1)); float pot = 1, tab = x * x; while(term > 0.0000000001) { suma = (x/3) + 1; serie = suma; signo = signo * (-1); pot = pot * tab; den = den * (d + 3); serie = serie + ((pot * signo * num) / (den)); num = num * (h + 2); h = h + 2; d = d + 3; term = (pot * num) / den; if(term < 0) term = term * (-1); } printf("El valor de %f evaluado en la funcion es: %f \n\n", x, serie); system("pause"); return 0; }

15

16

4. Utilizando lazos do... while resolver la siguiente serie, utilizar una precisin de 0.0000000001.

#include <stdio.h> #include <stdlib.h> int main() { float x, suma = 0, num = 1, d = 1, signo = -1, term = 0; do{ printf("Asignele un valor a 'x' para evaluar la funcion ((Ln(1+x))/1+x)\n"); scanf("%f", &x); }while((x <= -1) || (x >= 1)); float serie = 0, pot = 1; do{ signo *= -1; suma = suma + (1 / d); pot = pot * x; serie = serie + signo*suma*pot; d += 1; term = term + 0.00000000000000001; }while(term <= 0.0000000001); printf("El resultado obtenido de la evaluacion de %f en la funcion ((Ln(1+x))/1+x) es: %f \n", x, serie); system("pause"); return 0; }

17

5. Utilizando lazos de su preferencia hacer una tabla en la que se imprima los primeros 15 nmeros de Euler.

//Este programa muestra los Primeros 15 Numeros de Euler #include <stdio.h> #include <stdlib.h> #define pi 3.1415926536 int main() { double k=1.0, pot=1.0, fact=1.0, q=1.0, signo=1.0, suma=0.0, term=1.0,E=0.0; int a=0, n=1, i=1; printf("\n\t Numeros de Euler\n"); for(n=1;n<=15;n+=1) { pot=1.0, fact=1.0, q=1.0, suma=0.0, term=1.0, k=0.0, signo=1.0; for(i=1;(2*n+2)>=i;i+=1) { pot*=2; } for(i=1;(2*n)>=i;i+=1){ fact*=i; } for(i=1;(2*n+1)>=i;i+=1){ q*=pi; } do{ suma+=term*signo; signo*=-1; k++; term=1; for(i=1;(2*n+1)>=i;i+=1){ term*=(1/(2*k+1)); } } while(term>0.0000000001) ; E=((pot*fact)/q)*suma; a++; printf("Cuando n = %d \t el numero de Euler es: %.9f\n", a,E); } system("pause"); return 0; }

18

19

CONCLUSIONES
Hasta ahora los programas que hemos visto eran lineales. Comenzaban por la primera instruccin y acababan por la ltima, ejecutndose todas una sola vez. . Lgico no? Pero resulta que muchas veces no es esto lo que queremos que ocurra. Lo que nos suele interesar es que dependiendo de los valores de los datos se ejecuten unas instrucciones y no otras. O tambin puede que queramos repetir unas instrucciones un nmero determinado de veces. Para esto estn las sentencias de control de flujo.

El lenguaje C dispone de varias sentencias para modificar este flujo secuencial de la ejecucin. Las ms utilizadas se agrupan en dos familias: las bifurcaciones, que permiten elegir entre dos o ms opciones segn ciertas condiciones, y los bucles, que permiten ejecutar repetidamente un conjunto de instrucciones tantas veces como se desee, cambiando o actualizando ciertos valores. Para este tipo de aplicaciones ANSI C presenta muchas ventajas en relacin a otros lenguajes de programacin, lo que se debe dominar es el uso de las sentencias while, for y do... while.

Dichas sentencias nos ayudan a optimizar nuestros programas, es decir nos ahorran muchas lneas de cdigo, con lo cual ahorramos espacio de memoria en nuestra computadora, adems de hacer mucho ms legibles y fciles de entender y tambin de depurar.

20

BIBLIOGRAFIA
MURRAY R. SPIEGEL Manual de Formulas y Tablas Matemticas McGraw Hill, Mxico, 1995.

DEITEL, HARVEY M. y DEITEL, PAUL J. Cuarta Edicin Como programar en C/C++ y Java PEARSON EDUCACION, Mxico ,2004.

Aprenda lenguaje ANSI C como si estuviera en Primero Escuela Superior de Ingenieros Industriales Universidad de Navarra.

Sitios de Internet www.wikipedia.com www.monografias.com www.mailxmail.com www.elrincondelc.com www.apuntes.rincondelvago.com

21