Capítulo 5 - Sentencias de Control de C.pdf

ITSON Manuel Domitsu Kono

Capítulo 5

Sentencias de Control de C Ya se mencionó, en el Capítulo 4: Estructura de un programa en C, que una sentencia compuesta es un conjunto de instrucciones que la computadora ejecuta en secuencia. Sin embargo hay ocasiones en que es deseable alterar esa secuencia. En estos casos se utilizan las sentencias de control. C tiene tres grupos de sentencias de control: Las sentencias de selección o condicionales, las sentencias de iteración o repetitivas y las sentencias de salto.

Sentencias de Selección o Condicionales Hay ocasiones en las que deseamos que, dependiendo del valor de una expresión, la computadora ejecute una de dos o más sentencias compuestas. Las sentencias que nos permiten realizar tal tarea se conocen como sentencias de selección o condicionales. En C existen dos sentencias condicionales: La sentencia if y la sentencia switch.

Sentencia if La sentencia if nos permite seleccionar entre ejecutar una de dos sentencias compuestas, dependiendo del resultado de una expresión. La sintaxis de la sentencia if es la siguiente: if(expresión) sentencia1 [else sentencia2] expresión debe ser de cualquier tipo entero. sentencia1 y sentencia2 son sentencias compuestas. Primero se evalúa expresión, si su valor es verdadero (diferente de cero), se ejecuta sentencia1 y después el programa continúa con la sentencia que sigue a la sentencia if; si el valor de expresión es falso (cero) se ejecuta sentencia2 y luego continúa con la sentencia después de la sentencia if. Si else sentencia2 no aparece, entonces si expresión es verdadera se ejecuta sentencia1 y el programa continúa con la sentencia después de la sentencia if. De

66 Sentencias de Control de C


otro modo no se ejecuta sentencia1 y el programa salta a ejecutar la sentencia después de la sentencia if. Una sentencia if puede estar anidada dentro de otra sentencia if, por ejemplo: if(expresión1) if(expresión2) sentencia1 else sentencia2 else if(expresión3) sentencia3 else sentencia4; ó escalonados como en el siguiente ejemplo: if(expresión1) sentencia1 else if(expresión2) sentencia2 else if(expresión3) sentencia3 else sentencia4; Esta última construcción se acostumbra escribir de la siguiente manera para que los sangrados no crezcan demasiado: if(expresión1) sentencia1 else if(expresión2) sentencia2 else if(expresión3) sentencia3 else sentencia4 En los casos donde tenemos sentencias if anidadas podría surgir la pregunta de a qué if le corresponde cuál else. La regla en estos casos es que un else se asocia con el if anterior más cercano si es que no está ya asociado con un else.

Ejemplos sobre la Sentencia if

1. Escribe el código de un programa, que lea tres números enteros y escriba el mayor de ellos.

En el Capítulo 2: Algoritmos, Pseudocódigos y Programación Estructurada se escribió el pseudocódigo para este programa:

lee a, b, c si(a > b) mayor = a otro mayor = b si(c > mayor) mayor = c escribe mayor

La codificación en C del pseudocódigo anterior es directa. Las instrucciones lee y escribe se traducen a las llamadas a las funciones printf() y scanf(). La sentencia condicional si corresponde a la sentencia if. La codificación en C del programa anterior queda como:

Capítulo 5 Sentencias de Control de C 67


/* * File: mayorDe3.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 02:33 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa encuentra el mayor de 3 números enteros. * * Este programa ilustra el uso de la sentencia if. */ int main(void) { int a, b, c, mayor; printf("\nEste programa encuentra el mayor de 3 numeros entero\n"); // Lee los tres números enteros printf("\nDame tres numeros enteros: "); scanf("%d%d%d", &a, &b, &c); // Encuentra el mayor de los dos primeros if(a > b) mayor = a; else mayor = b; /* Encuentra el mayor del mayor anterior y el tercero */ if(c > mayor) mayor = c; // Escribe el mayor de los tres numeros printf("\nEl mayor de %d, %d y %d, es %d\n\n", a, b, c, mayor); return (EXIT_SUCCESS); }

2. Escribe el código de un programa, que realice las cuatro operaciones

fundamentales de la aritmética. El programa deberá leer el primer número, el carácter que representa la operación deseada y el segundo número. El programa desplegará el resultado.

El pseudocódigo para este programa es:

lee resultado lee operador lee operando si(operador == '+') resultado = resultado + operando otro si(operador == '-') resultado = resultado - operando otro si(operador == '*') resultado = resultado * operando otro si(operador == '/') si(operando != 0.0) resultado = resultado / operando otro escribe "Error: División entre cero" otro escribe "Error: Operador desconocido" escribe resultado



La codificación en C del pseudocódigo anterior es:

/* * File: calcula1.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 04:21 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa realiza las cuatro operaciones aritméticas fundamentales. * * Este programa ilustra el uso de la sentencia if. */ int main(void) { float resultado, operando; char operador; printf("\nEste programa realiza las cuatro operaciones”); printf("\naritméticas fundamentales\n"); // Lee el primer operando printf("\nEscribe la operacion sin separaraciones: "); scanf("%f", &resultado); // Lee el operador operador = getchar(); // Lee el segundo operando scanf("%f", &operando); // Realiza la operacion if(operador == '+') resultado += operando; else if(operador == '-') resultado -= operando; else if(operador == '*') resultado *= operando; else if(operador == '/') if(operando != 0.0) resultado /= operando; else printf("\nError: División entre cero\n"); else printf("\nError: Operador desconocido\n"); // Escribe el resultado printf("\n%f\n\n", resultado); return (EXIT_SUCCESS); }

Ejercicios sobre la Sentencia if

1. El costo de un telegrama ordinario es de $1000 si el número de palabras es hasta 10, por cada palabra adicional se cobra $200. Si el telegrama es urgente los costos son de $2000 y $400 respectivamente. Escribir un programa que lea el tipo del telegrama (una sola letra, 'O' para ordinario y 'U' para urgente) y el número de palabras del telegrama y escriba el costo de éste.



2. Escribir un programa que lea tres números positivos suministrados en orden ascendentes los cuales representan las longitudes de los lados de un triángulo. El programa deberá determinar si los tres lados forman un triángulo y su tipo.

Sentencia switch Un caso especial de una construcción con varios if escalonados y que aparece con bastante frecuencia en los programas, tiene la siguiente forma:

if(expresión == cte1) sentencia1 else if(expresión == cte2) sentencia2 else if(expresión == cte3) sentencia3 ... else sentencia

donde expresión es una expresión de tipo entero, cte1, cte2, cte3, ... son constantes de tipo entero y sentencia1, sentencia2, ... , sentencia son sentencias compuestas. La construcción anterior puede simplificarse utilizando la sentencia switch. La sintaxis de una sentencia switch es la siguiente:

switch(expresión) { case cte1: [sentencia1] [break;] [case cte2: [sentencia2] [break;]] ... [default: [sentencia] [break;]] }

expresión es una expresión de tipo entero o entero sin signo y se conoce como el selector del switch. cte1, cte2, ... son constantes de tipo carácter, entero corto o entero con o sin signo. En una sentencia switch no puede haber dos constantes iguales. Primero se evalúa expresión y luego se ejecuta la sentencia compuesta que está asociada a la constante que es igual al valor de expresión. Después de ejecutar esa sentencia, se ejecutan en secuencia todas las sentencias que le siguen hasta encontrar una sentencia break. Al encontrarse con una sentencia break, el programa continúa con la sentencia después de la sentencia switch. Si ninguna constante coincide con el valor de expresión entonces se ejecuta la sentencia asociado con la etiqueta default. Si ésta no existe, el programa continúa con la sentencia después del switch.



La sentencia asociada a la etiqueta default no tiene que ser la última sentencia dentro de una sentencia switch. Puede ir en cualquier lugar, por ejemplo:

switch(expresión) { case cte1: [sentencia1] [break;] case cte2: [sentencia2] [break;] default: [sentencia] [break;] case cte3: [sentencia3] [break;] case cte4: [sentencia4] }

ó

switch(expresión) { default: [sentencia] [break;] case cte1: [sentencia1] [break;] [case cte2: [sentencia2] [break;]] ... }

Ejemplos sobre la Sentencia switch

1. Repetir el ejemplo 2 sobre la sentencia if usando la sentencia switch. Si substituimos las sentencias if escalonadas por una sentencia switch,

tenemos:

/* * File: calcula2.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 04:50 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa realiza las cuatro operaciones * aritméticas fundamentales. * * Este programa ilustra el uso de la sentencia switch. */ int main(void) { float resultado, operando; char operador; printf("\nEste programa realiza las cuatro operaciones”); printf("\naritméticas fundamentales\n"); // Lee el primer operando



printf("\nEscribe la operacion sin separaraciones: "); scanf("%f", &resultado); // Lee el operador operador = getchar(); // Lee el segundo operando scanf("%f", &operando); // Realiza la operacion switch(operador) { case '+': resultado += operando; break; case '-': resultado -= operando; break; case '*': resultado *= operando; break; case '/': if(operando != 0.0) resultado /= operando; else printf("\nError: División entre cero\n"); break; default: printf("\nError: Operador desconocido\n"); } // Escribe el resultado printf("\n%f\n\n", resultado); return (EXIT_SUCCESS); }

Escribe el código de un programa, que lea un carácter tecleado por el usuario y

escriba si el carácter tecleado es carácter alfanumérico (una letra o un dígito) o un separador (un espacio, un carácter de tabulación, un punto, dos puntos, coma o un punto y coma).

El programa pedido utiliza una sentencia switch para determinar si el carácter es

alfanumérico o separador.

/* * File: caracter.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 07:35 PM */ #include <stdio.h> #include <stdlib.h> #include <ctype.h> /* * Este programa lee un carácter del teclado y determina * si es un carácter alfanumérico o un separador. * * Este programa ilustra el uso de la sentencia switch. */ int main(void) { char c; printf("\nEste programa lee un caracter del teclado y determina"); printf("\nsi es un caracter alfanumerico o un separador\n"); // Lee un caracter del teclado



printf("\nPresiona una tecla: "); c = getchar(); // Lee un caracter del teclado switch(c) { case ' ' : // Espacio case '\t': // Carácter de tabulación case '.' : case ':' : case ',' : case ';' : printf("\nEs un separador\n\n"); break; // Determina si el caracter es alfanumerico default : c = toupper(c); if(c >= 'A' && c <= 'Z' || c >= '0' && c <= '9') printf("\nEs alfanumerico\n\n"); else printf("\nEs otra tecla\n\n"); } return (EXIT_SUCCESS); }

Sentencias de Iteración o Repetitivas Hay ocasiones que se requiere que una sentencia compuesta se ejecute varias veces, posiblemente cambiando los valores de las expresiones contenidas en ésta. Por ejemplo, supongamos que deseamos crear una tabla del capital acumulado de una cantidad invertida a una tasa de interés anual y recapitalizado mensualmente. En este ejemplo, para cada mes es necesario determinar el capital acumulado e imprimir el resultado. Este proceso se repetirá tantas veces como el número de meses que deseemos tabular. Las sentencias que nos permiten realizar tal tarea se conocen como sentencias de iteración o repetitivas. En C existen tres tipos de sentencias repetitivas: La sentencia while, la sentencia for y la sentencia for - while.

Sentencia while La sentencia while nos permite ejecutar una sentencia compuesta, mientras se cumpla una condición. La sintaxis para esta sentencia es la siguiente:

while(expresión) sentencia expresión debe ser de cualquier tipo entero. sentencia es una sentencia compuesta. La sentencia while opera de la siguiente manera: Primero se evalúa expresión. Si su valor es verdadero (diferente de cero), se ejecuta sentencia y expresión es evaluada de nuevo, repitiéndose el ciclo hasta que expresión resulta falsa (cero). Cuando esto último ocurre el ciclo termina y el programa continúa con la siguiente instrucción después del ciclo.



Si expresión es falsa al principio del ciclo, sentencia no se ejecuta ni una vez.

Ejemplos sobre la Sentencia while

1. Escribir un programa que genere una tabla que muestre el capital acumulado de una inversión, a una tasa de interés anual, con recapitalización mensual. El programa deberá leer el monto de capital que se desea invertir, la tasa de interés anual y el número de meses que se desea tabular. La salida del programa será una tabla de la forma:

Mes Capital --------------- 1 dddd.dd 2 dddd.dd ...

En el Capítulo 2: Algoritmos, Pseudocódigos y Programación Estructurada se

escribió el pseudocódigo para este programa:

lee capital, tasa y meses mes = 1 mientras(mes <= meses) { capital = capital * (1 + tasa/12) escribe mes y capital mes = mes + 1 }

La codificación en C del pseudocódigo anterior es directa. Las instrucciones lee y

escribe se traducen a las llamadas a las funciones printf() y scanf(). La sentencia condicional mientras corresponde a la sentencia while. La codificación en C del programa anterior queda como:

/* * File: capital1.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 07:52 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa genera una tabla del capital acumulado * de una inversión depositada a una tasa de interés dada. * * Este programa ilustra el uso de la sentencia while. */ int main(void) { int mes, meses; float capital, tasa;



printf("\nEste programa genera una tabla del capital acumulado"); printf("\nde una inversion depositada a una tasa de interes dada\n"); // Lee el capital inicial, tasa de interés anual y meses a tabular printf("\nCapital, tasa y meses a tabular: "); scanf("%f%f%d", &capital, &tasa, &meses); // Escribe el encabezado de la tabla printf("\nMes Capital"); printf("\n------------------"); // Inicializa el contador de meses mes = 1; // Mientras haya meses a tabular while(mes <= meses) { // Calcula el nuevo capital capital *= (1 + tasa/12); // Escribe mes y capital printf("\n%3d%12.2f", mes, capital); // Nuevo mes mes++; } printf("\n------------------\n\n"); return (EXIT_SUCCESS); }

2. Modifique el programa del ejemplo 1 sobre la sentencia switch para que la

calculadora sea capaz de realizar operaciones consecutivas, desplegando los resultados parciales. Si deseamos que el programa termine presionaremos la tecla [=].

La modificación que hay que hacerle al programa del ejemplo 1 sobre la sentencia switch es encerrarlo dentro de un ciclo while a fin de que realice la operaciones en forma repetitiva.

/* * File: calcula3.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 08:04 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa realiza las cuatro operaciones * aritméticas fundamentales en secuencia. * * Este programa ilustra el uso de la sentencia while. */ int main(void) { float resultado, operando;



char operador; printf("\nEste programa realiza las cuatro operaciones"); printf("\naritmeticas fundamentales\n"); // Lee el primer operando printf("\nEscribe las operaciones sin separaraciones, terminando en =: "); scanf("%f", &resultado); // Mientras el operador no sea = para terminar while((operador = getchar()) != '=') { // Lee el siguiente operando scanf("%f", &operando); // Realiza la operaciòn switch(operador) { case '+': resultado += operando; break; case '-': resultado -= operando; break; case '*': resultado *= operando; break; case '/': if(operando != 0.0) resultado /= operando; else printf("\nError: División entre cero\n"); break; default: printf("\nError: Operador desconocido\n"); } } // Escribe el resultado printf("\n%f\n\n", resultado); return (EXIT_SUCCESS); }

Ejercicios sobre la Sentencia while

1. Escribir el código para un programa que lea las edades de un grupo de alumnos y encuentre la edad promedio.

2. Escribir un programa que determine el número de meses necesario para que una

inversión, colocada a una tasa de interés anual dada y con recapitalización mensual, se duplique.

Sentencia for Una construcción que utiliza la sentencia while y que aparece con mucha frecuencia es la siguiente:

[sentencia1] while(expresión2) { sentencia [sentencia3] }

donde sentencia1 y sentencia3 deben ser sentencias de expresión o sentencias compuestas formadas por sólo sentencias de expresión. C nos permite escribir esa



construcción en forma más compacta utilizando la sentencia for. La sentencia for tiene la siguiente sintaxis:

for([expresión1]; [expresión2]; [expresión3]) sentencia Aquí las sentencias sentencia1 y sentencia3 se han convertido a las expresiones expresión1 y expresión3. Una sentencia de expresión se transforma a una expresión simplemente quitándole el punto y coma (;):

Sentencia Expresión expresión; → expresión

Una sentencia compuesta formada por sólo sentencias de expresión se transforma a una expresión substituyendo los punto y coma (;) que marcan el fin de cada sentencia por el operador coma (,)

Sentencia Expresión expresiónA; expresiónB; → expresiónA, expresiónB, ... , expresiónN ... expresiónN;

La sentencia for opera de la siguiente manera:

1. Se evalúa expresión1.

2. Se evalúa expresión2. Si el resultado es verdadero (diferente de cero) entonces se ejecuta la sentencia compuesta, sentencia y luego se evalúa expresión3.

3. Repite el paso 2 hasta que el resultado de la comparación es falso (cero), en cuyo

caso el programa brinca a la siguiente sentencia después de la sentencia for. Si inicialmente el valor de expresión2 es falso, sentencia no se ejecuta ni una sola vez y el ciclo termina. En la sentencia for, cualesquiera de las tres expresiones se pueden omitir. En particular si omitimos expresión2 se considera que es verdadera y tendremos un ciclo infinito. A continuación se muestran algunas construcciones usando la sentencia for:

for(i = 0; i < N; i++) { ... /* Uso más común */ } for(i = 0, j = 1; i < N; i++, j += 3) { ... /* Doble inicialización y doble incremento */ } for( ; getche() != 'N'; ) { ... /* Expresiones 1 y 3 vacías */ }



for( ; ; ) { ... /* Un ciclo infinito */ }

Ejemplos sobre la Sentencia for

1. Modifica el ejemplo 1 sobre la sentencia while para que utilice en su lugar una sentencia for.

Si en código del ejemplo 1 sobre la sentencia while, hacemos que sentencia1 sea: mes = 1; y sentencia3 sea: mes++;, entonces el código puede reescribirse como:

/* * File: capital2.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 08:31 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa genera una tabla del capital acumulado * de una inversión depositada a una tasa de interés dada. * * Este programa ilustra el uso de la sentencia for. */ int main(void) { int mes, meses; float capital, tasa; printf("\nEste programa genera una tabla del capital acumulado"); printf("\nde una inversion depositada a una tasa de interes dada\n"); // Lee el capital inicial, tasa de interés anual y meses a tabular printf("\nCapital, tasa y meses a tabular: "); scanf("%f%f%d", &capital, &tasa, &meses); // Escribe el encabezado de la tabla printf("\nMes Capital"); printf("\n---------------"); // Para cada mes de la tabla for(mes = 1; mes <= meses; mes++) { // Calcula el nuevo capital capital *= (1 + tasa/12); // Escribe mes y capital printf("\n%3d%12.2f", mes, capital); } printf("\n---------------\n\n"); return (EXIT_SUCCESS); }



2. Crea un programa que calcule el área bajo la curva y = x2 y que se encuentra entre las rectas x = xi y x = xf. Aproxime el área bajo la curva como la suma de las áreas de n rectángulos inscritos bajo la curva. El programa deberá pedir los valores de xi y xf, así como el número de rectángulos a usarse.

Un pseudocódigo para este programa es:

lee xi, xf, n base = (xf - xi)/n sumaH = 0 x = xi mientras(x < xf) { y = x2 sumaH = sumaH + y x = x + base } área = sumaH * base escribe área

El código en C de este algoritmo es:

/* * File: area1.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 08:42 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa calcula el área bajo la curva y = x^2 * entre las abscisas x = xi y x = xf. * * Este programa ilustra el uso de la sentencia for. */ int main(void) { int n; float x, xi, xf, base, sumaH, area; printf("\nEste programa calcula el área bajo la curva y = x^2"); printf("\nentre las abscisas x = xi y x = xf\n"); // Lee las abscisas inicial y final y el número de rectángulos printf("\nValores de xi, xf y n: "); scanf("%f%f%d", &xi, &xf, &n); // Calcula la base de un rectángulo base = (xf - xi) / n; // Inicializa el acumulador de alturas sumaH = 0; // Calcula y acumula las alturas for (x = xi; x < xf; x += base) sumaH += x * x;



// Calcula el área area = sumaH * base; // Escribe el area printf("\nEl area bajo la curva es %.8f\n\n", area); return (EXIT_SUCCESS); }

Ejercicios sobre la Sentencia for

1. Modifica el ejercicio 1 sobre la sentencia while para que utilice en su lugar una sentencia for.

2. El resultado que genera el programa del ejemplo 2 sobre la sentencia for tiene un

error debido a la diferencia que hay entre el área bajo la curva y el área cubierta por los rectángulos. Este error se disminuye conforme se aumenta el número n de rectángulos empleados para aproximar el área. Modifica el programa del ejemplo 2 sobre la sentencia for para que genere una tabla de los valores del área bajo la curva en función de n. El programa debe de pedir adicionalmente, el valor inicial, el valor final y los incrementos de n.

Sentencia do - while La sentencia do - while es otra variante de la sentencia while cuya sintaxis es la siguiente:

do sentencia while(expresión) expresión debe ser de tipo entero. sentencia es una sentencia compuesta. La sentencia do - while opera de la siguiente manera: Primero se ejecuta sentencia y luego se evalúa expresión, si su valor es verdadero (diferente de cero), se ejecuta sentencia y expresión es evaluada de nuevo, repitiéndose el ciclo hasta que expresión resulta falsa (cero). Cuando esto último ocurre el ciclo termina y el programa continúa con la siguiente instrucción después del ciclo. La diferencia básica entre las sentencias do - while y while es que la sentencia compuesta en el ciclo do - while se ejecuta por lo menos una vez, ya que la prueba sobre expresión se realiza hasta que la sentencia compuesta se ha ejecutado; mientras que la sentencia compuesta en la sentencia while no se ejecutará si expresión es falsa desde el principio.



Ejemplo sobre la Sentencia do - while Repite el ejemplo 1 sobre la sentencia while, usando en su lugar la sentencia do - while. Substituyendo la sentencia do - while en lugar de la sentencia while, tenemos: /* * File: capital3.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 09:13 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa genera una tabla del capital acumulado de * una inversión depositada a una tasa de interés dada. * * Este programa ilustra el uso de la sentencia do - while. */ int main(void) { int mes, meses; float capital, tasa; printf("\nEste programa genera una tabla del capital acumulado"); printf("\nde una inversion depositada a una tasa de interes dada\n"); // Lee el capital inicial, tasa de interés anual y meses a tabular printf("\nCapital, tasa y meses a tabular: "); scanf("%f%f%d", &capital, &tasa, &meses); // Escribe el encabezado de la tabla printf("\nMes Capital"); printf("\n---------------"); // Inicializa el contador de meses mes = 1; // Hacer do { // Calcula el nuevo capital capital *= (1 + tasa/12); // Escribe mes y capital printf("\n%3d%12.2f", mes, capital); // Nuevo mes mes++; } // mientras haya meses a tabular while(mes <= meses); printf("\n---------------\n\n"); return (EXIT_SUCCESS); }



Ejercicio sobre la Sentencia do - while Modifica el ejemplo sobre la sentencia do - while, para que en vez de terminar el programa una vez que ha desplegado los resultados, le pregunte al usuario si desea volver a repetir los cálculos. Si la respuesta es si, se repetirán los cálculos y el programa solo terminará si el usuario contesta que no.

Sentencias De Salto Hay ocasiones en que es conveniente que el programa salte de una instrucción a otra en forma incondicional, esto es, no sujeto a una condición como lo vimos con las sentencias de selección y de iteración. En C existen cuatro sentencias de salto: Las sentencias goto, break, continue y return. En este tema se estudiarán las sentencias break y continue. En el Capítulo 6: Funciones se estudiará la sentencia return. La sentencia goto no se trata en este curso.

Sentencia break Cuando estudiamos la sentencia switch vimos que la sentencia break transfiere el control del programa a la siguiente sentencia después de la sentencia switch. Esto es, termina la ejecución de una sentencia switch. La sentencia break también se utiliza para terminar en forma incondicional la ejecución de cualquier sentencia de iteración. La sintaxis de esta sentencia es: break; La ejecución de una sentencia break se encuentra dentro de una sentencia switch o iterativa que a su vez está dentro de otra sentencia switch o iterativa, sólo termina la sentencia switch o iterativa más interna.

Ejemplo sobre la Sentencia break Escribe un programa que lea un número entero y determine si es primo. Un número es primo sólo si es divisible entre 1 y si mismo. Para determinar si un número n es primo podemos probar si es divisible entre i, donde i = 2, 3, ... , n-1. Si encontramos que el número es divisible entre uno de los valores de i, el número ya no es primo y no es necesario seguir probando para los valores restantes de i. El código para el programa es el siguiente.



/* * File: primo.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 09:23 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa determina si un número entero es primo. * * Este programa ilustra el uso de las sentencias for y break. */ int main(void) { int n, i; printf("\nEste programa determina si un número entero es primo\n"); // Lee un entero printf("\nDame un numero entero: "); scanf("%d", &n); // Para i en [2, n) for(i = 2; i < n; i++) { // Si n es divisible entre i if(!(n % i)) { // Escribe "n no es primo" printf("\n%d no es primo\n\n", n); /* Como el número no fue primo, no es necesario verificar si es divisible entre los restantes valores de i y podemos terminar el ciclo */ break; } } // Si no fue divisible escribe "n es primo" if(i == n) printf("\n%d es primo\n\n", n); return (EXIT_SUCCESS); }

Sentencia continue La sentencia continue sólo se utiliza con las sentencias de iteración. La sintaxis de esta sentencia es: continue; Al ejecutarse la sentencia continue, genera un salto al final de la última sentencia dentro del cuerpo de una sentencia de iteración. En las sentencias while y do - while, la sentencia continue hace que el programa salte a evaluar la expresión de control del ciclo. En la sentencia for la sentencia continue hace que el programa salte a evaluar la tercera expresión y luego la expresión de control del ciclo.



La ejecución de una sentencia continue que se encuentra dentro de una sentencia iterativa que a su vez está dentro de otra sentencia iterativa, sólo termina la sentencia iterativa más interna.

Ejemplo sobre la Sentencia continue Escribe un programa que lea un número entero y halle todos sus factores primos. El código para el programa es el siguiente. /* * File: factoresPrimos.c * Author: mdomitsu * * Created on 5 de septiembre de 2009, 10:04 PM */ #include <stdio.h> #include <stdlib.h> /* * Este programa determina los factores primos de un número entero. * * Este programa ilustra el uso de las sentencias for y continue. */ int main(void) { int n, i, j; printf("\nEste programa determina los factores"); printf("\nprimos de un numero entero\n"); // Lee un entero printf("\nDame un numero entero: "); scanf("%d", &n); // Escribe el encabezado de la lista printf("\nLos factores primos de %d son:\n", n); // Los enteros j, en [2, n] pueden ser factores primos for (j = 2; j <= n; j++) { // Determina, primero, si j es primo // Para i en [2, j] for (i = 2; i <= j; i++) { // Si j es divisible entre i no es primo, rompe el ciclo if (!(j % i)) break; } /* Si el posible factor no es primo (el ciclo anterior no terminó y por lo tanto i ¡= j) prueba el siguiente número */ if (i != j) continue; /* Si j es primo, prueba si es un factor de n. Si j es un factor de n, n será divisible entre j. El ciclo es para detectar si j es un factor repetido de n */ while (!(n % j)) { /* Si j es un factor primo, factoriza n para buscar el siguiente factor primo */ n /= j;



// Escribe el factor primo printf("%d, ", j); } } printf("\n\n"); return (EXIT_SUCCESS); }

Problemas 1. Un año bisiesto es aquel año que es divisible entre 4 pero no es divisible entre

100 a menos que sea divisible entre 400 en cuyo caso si es bisiesto. Crea un programa que determine si un año dado es un año bisiesto o no.

2. La capacitancia de un capacitor de placas paralelas con vacío por dieléctrico está

dada por:

dAC 0ε=

Donde ε0 = 8.85 × 10-12 F/m es la permitividad del vacío, A es el área de una de las placas del capacitor y d es la distancia entre las placas.

Crea un programa que calcule la capacitancia de un capacitor de placas paralelas. Las placas paralelas pueden tener forma rectangular o circular. El programa pedirá el tipo de placas del capacitor, ‘R’ o ‘C’ y dependiendo del tipo las dimensiones a y b de los lados del rectángulo o el radio r. Adicionalmente el programa pedirá la distancia d, entre placas. El resultado se desplegará en notación flotante con cuatro cifras decimales.

3. Un año bisiesto es aquel año que es divisible entre 4 pero no es divisible entre 100,

a menos que sea divisible entre 400 que si lo es. Crea un programa que lea dos años y que encuentre y escriba todos los años bisiestos entre esos dos años.

4. Sea r un número real positivo y sea xi una secuencia de números reales definida

por:

... 2, 1, = i para )xr + (x

21 = x 1, = x

iii 10 +

Se puede demostrar matemáticamente que:

∞→→ i cuando r xi

este algoritmo se deriva del método de Newton-Raphson. Escribe un programa que lea un número r y calcule su raíz cuadrada. El programa debe desplegar una tabla



que muestra el número de la iteración y el valor de xi convergiendo hacia la raíz cuadrada. Utilice variables dobles y despliegue las raíces a la máxima precisión posible.

5. Crea un programa que tabule la función:

y = x3 - 2x + 3

El programa deberá pedir los límites inferior, superior y el incremento. Aparte de la tabla con la tabulación, el programa deberá desplegar los valores máximo y mínimo en el intervalo. Todos los valores se desplegarán en notación fija con cuatro cifras decimales.

6. Crea un programa que calcule el promedio de cada alumno de un grupo, para lo

cual se leerán su matrícula y cuatro calificaciones. Indicar fin de datos con matrícula = 0. El programa deberá imprimir la matrícula, las cuatro calificaciones y el promedio de cada alumno. Al final deberá imprimir la calificación promedio global del grupo.

Capítulo 5 - Sentencias de Control de C.pdf

Documents

Transcript of Capítulo 5 - Sentencias de Control de C.pdf