Tema 3.1.3.

Técnicas de Programación
3.1.- Lenguaje de programación C
Tema 3.1.3.- Sentencias de control de programa
Introducción
Son sentencias que permiten romper el orden de ejecución del programa. Sin este tipo de sentencias la
ejecución se realiza en el orden en que se han escrito. Así mismo, en muchas ocasiones es necesario
ejecutar un conjunto de sentencias un número determinado de veces, o bien hasta que se cumpla una
determinada condición. Este tipo de sentencias son las repetitivas. Estas instrucciones o sentencias se
dividen en tres categorías:
0.- Instrucciones condicionales: if() y switch()
1.- Instrucciones repetitivas: for, while, do-while
2.- Instrucción de salto incondicional: goto
En este tema aprenderemos a utilizar estas sentencias para que los programas tomen decisiones y
para que sean capaces de ejecutar bloques de sentencias repetitivas.
1.- Instrucciones condicionales
Una característica muy poderosa de cualquier ordenador es la capacidad que tiene de tomar
decisiones, es decir, que al comparar dos alternativas diferentes pueda tomar una decisión basada en
la evaluación de alguna condición impuesta por el programador. Es por tanto necesario que un
lenguaje de programación tenga instrucciones que permitan formar estas condiciones e instrucciones
que pueden evaluarlas.
Tema 3.1.3.- Sentencias de control de programa
1
1.- Instrucciones condicionales
El formato general de una instrucción condicional genérica es:
Instrucción condicional (condición)
si condición cierta
{grupo de instrucciones para verdadero}
si condición falsa
{grupo de instrucciones para falso}
Observamos cuatro partes bien diferenciadas:
1. La propia instrucción condicional;
2. La condición;
3. El grupo de instrucciones para verdadero; y
4. El grupo de instrucciones para falso.
Cuando el ordenador evalúa una condición solo puede hacerlo de dos maneras: o la condición es
cierta o verdadera (true) o la condición es falsa (false), lo que dependerá del valor que tenga asignado o
que se haya capturado para la variable que está en la condición, y dependiendo del resultado de la
evaluación se ejecutarán las instrucciones de la parte cierta o las de la parte falsa de la condición.
En general todas las condiciones simples se forman con variables, operadores de relación o
relacionales, constantes o variable. Una condición simple se define como el conjunto de variables y/o
constantes unidas por los llamados operadores relacionales.
Debemos tener especial cuidado con el operador de igualdad (=) y el operador relacional de
comparación por igualdad (==), es decir:
dato = 10: se carga o asigna el valor 10 a la variable dato.
dato == 10: se compara el valor de la variable dato con el numero 10.
Solo este ultimo formato es valido dentro de una condición, en una instrucción condicional.
Tema 3.1.3.- Sentencias de control de programa
2
1.- Instrucciones condicionales
La instrucción if. La instrucción condicional más usada es la sentencia if, que vamos a analizar
seguidamente. Su sintaxis es la siguiente:
if (condición)
{grupo de instrucciones para verdadero;}
else
{grupo de instrucciones para falso;};
Debemos tener muy presentes las siguiente observaciones:
1ª. Obsérvese donde van y donde no van los puntos y comas
2ª. La condición va entre paréntesis
3ª. Si un if no tiene un grupo de instrucciones para falso se omite el else, y la llave antes de else si
terminaría con punto y coma.
El proceso de ejecución de una sentencia if es el siguiente:
1º. Se evalúa la condición, que puede ser una expresión numérica, relacional o lógica.
2º. Si el resultado de evaluar la condición es verdadero (resultado distinto de cero) se ejecutará lo
indicado por la sentencia de grupo de instrucciones para verdadero.
3º. Si el resultado de evaluar la condición es falso (resultado cero) se ejecutará lo indicado por la
sentencia de grupo de instrucciones para falso, siempre que se haya especificado la clausula else.
4º. Si el resultado de evaluar la condición es falso y se ha omitido la clausula else se ignora la
sentencia de grupo de instrucciones para verdadero.
5º. En cualquiera de los casos la ejecución del programa continúa por la siguiente sentencia
ejecutable.
if (condicion)
Ejemplo de sentencia if simple.
Veamos algunos ejemplos
{
Se evalúa condicion. Si el resultado es true se
de sentencias if que nos
sentencia1;
ejecuta el grupo sentencia1, sentencia2, ...; y si
aclaren lo descrito:
sentencia2;
el resultado es false se salta el grupo y se
...
prosigue en la línea sentencia.
}
sentencia;
Tema 3.1.3.- Sentencias de control de programa
3
1.- Instrucciones condicionales
if (condicion)
sentencia1;
else
sentencia2;
sentencia;
Ejemplo de sentencia if con else.
Se evalúa condicion. Si el resultado es true se ejecuta sentencia1 y se
prosigue en la línea sentencia y si el resultado es false se ejecuta sentencia2 y
se prosigue en la línea siguiente (sentencia). Tanto sentencia1 como
sentencia2 pueden ser grupos.
Existe una forma especial de sentencia if ... else que podemos denominar múltiple y que permite
realizar una ramificación múltiple del programa según se cumpla una condición entre muchas
condiciones. La forma general de esta es:
if (condicion1)
sentencia o grupos de sentencias 1; Se evalúa condicion1. Si el resultado es true, se ejecuta
else if (condicion2)
sentencia o grupo 1. Si el resultado es false, se salta sentencia
sentencia o grupos de sentencias 2; o grupo 1 y se evalúa condicion2. Si el resultado es true se
else if (condicion3)
ejecuta sentencia o grupo 2, mientras que si es false se evalúa
sentencia o grupos de sentencias 3; condicion3 y así sucesivamente. Si ninguna de las
else if (...)
expresiones o condiciones es true se ejecuta sentenciaN que
...
es la opción por defecto (puede ser una sentencia nula, y en
[else
ese caso puede eliminarse junto con el else que la precede.
sentenciaN;]
Veamos otro ejemplo:
if (x) // Es lo mismo que if (x!= 0)
b=a/x;
b=b+1;
La sentencia b=a/x se ejecutará si la expresión es verdadera (x ≠ 0) y no se ejecutará si es falsa (x=0).
En cualquier caso la ejecución continua por la sentencia b=b+1.
Tema 3.1.3.- Sentencias de control de programa
4
1.- Instrucciones condicionales
Es posible crear una situación del siguiente tipo: En cualquiera de los grupos de instrucciones para
verdadero o falso se puede escribir otra sentencia if...else. Si esto es así, es decir que se ejecuta una
sentencia if...else dentro de otra hablamos de sentencias anidadas if...else. Su sintaxis general es la
siguiente:
if (condición 1)
{
If (condición 2)
grupo de instrucciones 1;
}
else
{grupo de instrucciones 2;};
La forma de evaluación de este anidamiento es como sigue:
● Si condición 1 es falso se pasa a ejecutar el grupo de instrucciones 2, aunque el resultado de evaluar
condición 2 sea verdadero.
● Si condición 1 es verdadero y condición 2 es falso no se ejecutan ni grupo de instrucciones 1 ni
grupo de instrucciones 2, luego se continúa por la siguiente sentencia ejecutable del programa.
● Si condición 1 es verdadero y condición 2 es verdadero se ejecuta grupo de instrucciones 1
continuando el flujo del programa en función de este grupo de instrucciones, que a su vez pueden
contener otro anidamiento de sentencias if...else.
Veamos un sencillo ejemplo que se puede resolver, entre otras formas, anidando sentencias if.
Ejemplo 10.- Cual es el menor de tres números con if anidados
Realizar un programa que sea capaz de decidir cual es el menor de tres números reales que
introduzcamos por teclado. Llamamos a los números datoA, datoB y datoC y declaramos otra variable
que llamamos Resultado, de forma que el siguiente fragmento de código nos resuelve el problema:
Tema 3.1.3.- Sentencias de control de programa
5
1.- Instrucciones condicionales
Ejemplo 10.- Cual es el menor de tres números con if anidados
if (datoA < datoB)
{
if (datoA < datoC) //if anidado para opción true del primer if
Resultado = datoA;
else
Resultado = datoC;
}
else
{
if (datoB < datoC) //if anidado para opción false del primer if
Resultado = datoB;
else
Resultado = datoC;
}
Un posible resultado en tiempo de ejecución es:
Tema 3.1.3.- Sentencias de control de programa
6
1.- Instrucciones condicionales
Condiciones compuestas
En muchas ocasiones es necesario presentar mas de una condición para su
evaluación hablando entonces de condición compuesta, que se define como dos o más condiciones
simples unidas por operadores lógicos.
Para que una condición compuesta que contiene el operador lógico "AND" se evalúe como cierta las
dos condiciones simples deben ser ciertas.
Para que una condición compuesta que contiene el operador lógico "OR" se evalúe como cierta basta
con que una de las condiciones simples sea cierta.
La cantidad total de casos posibles cuando se unen dos o más condiciones simples es de 2n, donde n
es la cantidad de condiciones. Una condición compuesta formada por dos condiciones simples unidas
por los operadores lógicos AND u OR originan 22 = 4 casos posibles según las tablas de verdad de las
operaciones lógicas correspondientes.
Vamos a construir una tabla de verdad para una condición compuesta de tres condiciones simples,
recordando que:
1.- La cantidad posible de casos es 23 = 8 casos posibles.
2.- Para evaluar una condición triple, primero se evalúan las dos primeras incluyendo su operador, bajo
las reglas ya descritas y luego se evalúa, el resultado parcial contra la ultima condición, y ultimo
operador, para obtener la evaluación final.
Por ejemplo: sea una condición compuesta de tres condiciones simples, donde el primer operador
lógico es el "AND" y el segundo operador lógico es el "OR". Es decir, se trata de evaluar una condición
compuesta como:
1ª Cond.Simple AND 2ª Cond.Simple OR 3ª Cond.Simple
La tabla de verdad la vemos en la página siguiente.
Tema 3.1.3.- Sentencias de control de programa
7
1.- Instrucciones condicionales
Condiciones compuestas
1ª Cond.Simple AND 2ª Cond.Simple OR 3ª Cond.Simple
1ª Cond.Simple
2ª Cond.Simple
Eval. Parcial AND
true
true
true
true
false
false
false
true
false
false
false
false
3ª Cond.Simple
Eval. Final OR
true
true
false
true
true
true
false
false
true
true
false
false
true
true
false
false
Instrucción switch
La instrucción switch() es una instrucción de decisión múltiple que permite ejecutar una de varias
acciones en función del valor de una expresión. Se trata de comparar el valor contenido en una variable
contra una lista de constantes tipo int o char, de forma que al encontrar la igualdad entre variable y
constante, se ejecuta el grupo de instrucciones asociados a dicha constante. Si no se encuentra
igualdad entre variable y constante, entonces se ejecuta un grupo de instrucciones asociados a default,
aunque este ultimo es opcional.
Tema 3.1.3.- Sentencias de control de programa
8
1.- Instrucciones condicionales
Instrucción switch
La sintaxis de esta instrucción es la siguiente:
switch (expresion) // variable int o char
{
case constante 1:
grupo de instrucciones 1;
break;
case constante 2:
grupo de instrucciones 2;
break;
case constante 3:
grupo de instrucciones 3;
break;
…
default:
grupo de instrucciones n;
};
Los grupos de instrucciones pueden ser sentencias simples o compuestas.
La instrucción switch evalúa la expresión entre paréntesis comparando su valor con las constantes de
cada case, ejecutándose el grupo de instrucciones del case cuya constante coincida con el valor de
expresión, continuando hasta el final del bloque o hasta una instrucción que transfiera el control fuera
del bloque switch, como por ejemplo break.
Si no existe ninguna contante igual al valor de la expresión se ejecuta el grupo de instrucciones a
continuación de default, si ha sido especificado.
Si eliminamos los break y el resultado de la evaluación de expresión coincide, por ejemplo, con
constante 2 se ejecuta grupo de instrucciones 2 seguido de grupo de instrucciones 3, y así
sucesivamente hasta que se llegue al final o se encuentre una sentencia de ruptura como break.
Tema 3.1.3.- Sentencias de control de programa
9
1.- Instrucciones condicionales
Instrucción switch
Ejemplo 11.- Ejemplo de sentencia switch.
Queremos escribir un programa que nos pida el número (como dato tipo entero) correspondiente
a un día de la semana (consideraremos el Lunes como primer día y el Domingo como el último) y que
nos presente en pantalla el nombre en forma de texto (como dato tipo cadena) que se corresponda con
el día introducido. Además si introducimos un número menor que 1 o mayor que siete debe
mostrarnos un mensaje de error como por ejemplo “Numero de día incorrecto”.
Para resultado correcto
Para resultado incorrecto
Ejemplo 12.- Analizar un ejemplo de sentencia switch. Analizar el siguiente código de programa
{
case 'a':printf("Opcion A\n"); break;
#include <stdio.h>
case 'b':printf("Opcion B\n"); break;
#include <conio.h>
case 'c':
int main ()
case 'd':printf("Opcion C o D\n"); break;
{
default: printf("Opcion ?\n");
char c;
}
printf( "\nIntroducir un caracter a,b,c o d o cualquier otro: " );
}
scanf( "%s", &c );
printf("\nUna tecla para salir");
{
getch();
switch(c)
return 0;
}
Tema 3.1.3.- Sentencias de control de programa
10
1.- Instrucciones condicionales
Instrucción switch
Podemos obtener resultados similares a:
Al introducir una opción cualquiera
Opción con break
Opción sin break
2.- Instrucciones repetitivas: for, while, do-while
En lenguaje C existen también sentencias que permiten repetir una serie de veces la ejecución de unas
líneas de código. Esta repetición se puede realizar:
● Un número determinado de veces
● Hasta que se cumpla una determinada condición lógica o aritmética.
De una forma genérica, a estas instrucciones o sentencias repetitivas o cíclicas se les denomina
bucles.
La instrucción for. Permite repetir una cantidad conocida y exacta de veces la ejecución de una
instrucción simple o compuesta. Su sintaxis general es:
for ([<inicializacion>] ; [<condicion>] ; [<incremento>])
{
instrucción o instrucciones simples o compuestas;
};
Pudiendo en inicializacion representar varias variables de control iniciadas con sus correspondientes
valores y separadas por comas.
Condición representa una expresión booleana que si se omite se supone verdadera.
Incremento es una o más expresiones separadas por comas cuyos valores evolucionan en el sentido
que se cumpla la condición.
Tema 3.1.3.- Sentencias de control de programa
11
2.- Instrucciones repetitivas: for, while, do-while
Probablemente la forma más sencilla de explicar esta sentencia sea con un sencillo ejemplo. Sea la
instrucción:
for(x=1 ; x<=10 ; x=x+1)
Vemos la sintaxis:
1.- Se inicializa la variable x, implicando la carga de la variable de control con un valor inicial.
2.- La condición es una expresión relacional que evalúa la variable de control contra un valor final o de
parada que determina cuando debe acabar el bucle.
3.- El incremento define la manera en que la variable de control debe cambiar cada vez que el computador
repite un bucle.
4.- Los tres argumentos se deben separar con punto y coma.
Se ejecuta de la siguiente forma: Una vez inicializado el bucle (x=1) se evalúa la condición (x<=10) que resulta
ser true por lo que se pasa a incrementar la variable (x=x+1, x=1+1=2). Se vuelve a evaluar la condición
(x<=10) que resulta ser nuevamente true por lo que se pasa a incrementar la variable (x=x+1, x=2+1=3).De
esta forma se sigue evaluando la condición hasta que sea false, momento en el que la ejecución del
programa prosigue en la sentencia siguiente a la construcción for.
Casos Particulares de sentencias for
1º. Caso general: El ciclo comienza en uno y se incrementa de uno en uno.
2º. Valor inicial diferente de uno, por ejemplo:
for(x=6 ; x<=25 ; x=x+1)
3º. Valor inicial negativo, por ejemplo:
for (x=-8 ; x=8 ; x=x+1)
4º. Incrementos diferentes de uno, por ejemplo:
for (x=1 ; x<=20 ; x=x+3)
5º. Decrementos, por ejemplo:
for (x=50 ; x >= 10; x= x - 4)
En este caso el valor inicial de la variable debe ser mayor que el valor final y debemos cambiar el
sentido de la condición.
6º. Solamente en los casos de incrementos o decrementos de una en una unidad podemos sustituir en
el for el x=x+1 por x++ y el x=x-1 por x --.
Tema 3.1.3.- Sentencias de control de programa
12
2.- Instrucciones repetitivas: for, while, do-while
Ejemplos de sentencia for
int i;
for (i = 1 ; i <= 100 ; i++)
{
grupo de instrucciones simples o compuestas;
};
int m;
for (m = 5 ; m <= 125 ; m += 5)
{
grupo de instrucciones simples o compuestas;
};
int j, k;
for (j = 3, k = 6 ; j+k < 40 ; j++,k +=2)
{
grupo de instrucciones simples o compuestas;
};
char caracter;
for (caracter = ‘z’ ; caracter >= ‘a’ ; caracter --)
{
grupo de instrucciones simples o compuestas;
};
Tema 3.1.3.- Sentencias de control de programa
13
2.- Instrucciones repetitivas: for, while, do-while
Sentencia for
Ejemplo 13.- Sentencia for
Realizar un programa que muestre por pantalla los 10 primeros números naturales para obtener
un resultado similar a:
Ejemplo 14.- Pares e impares con sentencia for
Realizar un programa que muestre por pantalla en dos columnas los números pares e impares
comprendidos 0 y 20 para obtener un resultado como:
Tema 3.1.3.- Sentencias de control de programa
14
2.- Instrucciones repetitivas: for, while, do-while
Sentencia for
Para finalizar con la sentencia for vamos a exponer un ejemplo comentado de como realizar la misma
tarea de formas diferentes. Se trata realizar la operación 4! = 4x3x2x1 = 24 para lo que el código puede
ser el siguiente:
#include <stdio.h>
#include <conio.h>
int main () {
int i=1, fact=1; /*********** Primera forma ***********/
for (;i<=4;)/*La instrucción for contiene sólo el chequeo de la variable*/
{
fact *= i;
++i;
}
printf("Factorial de 4 con la primera forma = %d\n", fact);
/*********** Segunda forma ***********/
fact=1; /* Inicializamos la variable */
for (i=1; i<=4; ++i) /*Forma más habitual de expresar un bucle*/
fact*=i;
printf("Factorial de 4 con la segunda forma = %d\n", fact);
/*********** Tercera forma ***********/
for(i=1, fact=1; i<=4 ; ++i, fact*=i)
/*Se ejecuta antes el incremento de la variable que el chequeo y la
operación se ejecuta en lugar de 4 veces 5 dando como resultado 120 en lugar de 24.*/
;
printf("Factorial de 4 con la tercera forma = %d\n", fact);
/*********** Cuarta forma ***********/
for(i=1, fact=1; i<=4 ; fact*=i, ++i)
/*Forma muy parecida a la tercera pero con las operaciones en el orden correcto*/
;
printf("Factorial de 4 con la cuarta forma = %d\n", fact);
printf("\n\nUna tecla para salir");
getch();
return 0; }
Tema 3.1.3.- Sentencias de control de programa
15
2.- Instrucciones repetitivas: for, while, do-while
Instrucción o sentencia while
La instrucción while se ejecuta mientras una condición permanezca como verdadera terminando el
ciclo o bucle en el momento en que la condición se convierte en falsa. Su sintaxis es la siguiente:
Inicializamos la variable para la condición;
while(condicion) //Condicion es una expresión numérica, relacional o lógica.
{
grupo de instrucciones;
};
La instrucción while se ejecuta según el siguiente proceso:
Ejemplo de sentencia while:
1º. Se evalúa condicion.
int x=1;
2º. Si el resultado es falso (cero) no se ejecuta grupo
while(x<=10)
de instrucciones pasando el control a la siguiente
{
sentencia del programa.
printf("%d\tCadena de caracteres\n",x);
Si el resultado es verdadero (distinto de cero) se
x++;
ejecuta grupo de instrucciones repitiéndose el
};
proceso desde el primer punto.
Ejemplo 15.- Tablas de multiplicar
Realizar un programa en el que se solicite al
usuario el número del que desea obtener la tabla de
multiplicar y el número de items que quiere obtener
de la misma. El resultado puede ser:
Tema 3.1.3.- Sentencias de control de programa
16
2.- Instrucciones repetitivas: for, while, do-while
Bucles anidados con while
Cuando incluimos una sentencia while dentro de otra sentencia while estamos hablando de lo que se
conoce como bucle anidado. En general se habla de anidamiento tanto en sentencia while como en
sentencias do o for. La estructura general de un anidamiento con while es la siguiente:
Se inicializan las variables
while(condicion)
{
grupo de instrucciones externas;
while(condicion)
{
grupo de instrucciones internas;
}
};
Se ejecuta la sentencia while externa y por cada vez que se ejecuta lo hará el interno tantas veces
como imponga su condición.
Ejemplo 16.- Pitagoras
Se trata de realizar mediante sentencias while anidadas un programa que resuelva el teorema de
Pitagoras calculando la hipotenusa para valores enteros positivos comprendidos entre +1 y +50
presentando por pantalla solamente los resultados exactos.
El código del programa es el siguiente:
#include <stdio.h>
#include <conio.h>
#include <math.h> //Necesario para calcular raíces cuadradas
int main ()
{
unsigned int Cc = 1, Co = 1, h = 0; //Declaramos variables y las inicializamos
printf("h\tCc\tCo\n"); //Mostramos por pantalla una cabecera con tres columnas usando tabuladores
printf("-------------------");
Tema 3.1.3.- Sentencias de control de programa
17
2.- Instrucciones repetitivas: for, while, do-while
Bucles anidados con while
Ejemplo 16.- Pitagoras -- continuación
while (Cc <= 50) //Primer bucle que dará valor de 1 a 50 a Cc
{
// Calculamos la hipotenusa h.
h = (int)sqrt(Cc * Cc + Co * Co); //Usamos el operador cast para asegurar tipo int
//Como h es un entero se almacena la parte entera de la raíz cuadrada.
while (Co <= 50 && h <= 50) //bucle anidado con condición compuesta AND.
{
/* Si la raíz cuadrada anterior es exacta imprimimos resultado */
if (h * h == Cc * Cc + Co * Co)
{
printf("\n%d\t%d\t%d",h,Cc,Co);
};
Co = Co + 1; //incrementamos bucle interno hasta que valga 50
h = (int)sqrt(Cc * Cc + Co * Co);
} //Fin bucle anidado
Cc = Cc + 1; //Incrementamos bucle externo
Co = Cc; //Incializamos bucle interno
}
printf("\n\nUna tecla para salir");
getch();
return 0;
}
El bucle interno se ejecutará hasta que Co alcance el valor 50 para cada
incremento del bucle externo que a su vez se ejecutará hasta alcanzar el
mismo valor.
Tema 3.1.3.- Sentencias de control de programa
18
2.- Instrucciones repetitivas: for, while, do-while
Instrucción o sentencia do while
La diferencia con el bucle while es que la prueba de condición se realiza al finalizar el ciclo, es decir:
las instrucciones se ejecutan al menos una vez, porque primero se ejecutan las instrucciones y al final
se evalúa la condición. Su formato general es :
Definimos e inicializamos la variable de condicion;
do {
grupo de instrucciones para cierto;
Instrucción(es) de ruptura de ciclo;
} while (condicion);
Por ejemplo, el código:
int x=1;
do {
printf("%d lineas\n",x);
x++;
}while (x<=10);
mostrará 10 líneas por pantalla, como vemos:
Si cambiamos la condición para que sea falsa (x<1) el bucle se ejecuta una vez, como observamos
abajo.
Decidir que tipo de bucle debemos usar es decidir que opciones de las siguientes se ajusta a las necesidades
de nuestro problema:
• Si conocemos la cantidad exacta de veces que se debe que se ejecute el bucle, o el programa puede
calcularla ese número de veces, usaremos for.
• Si desconocemos la cantidad de veces a repetir el bucle o se quiere mayor control sobre la salida o
terminación del mismo entonces usaremos while.
• Si queremos que el bucle se ejecute al menos una vez usaremos do-while.
Tema 3.1.3.- Sentencias de control de programa
19
2.- Instrucciones repetitivas: for, while, do-while
Instrucción o sentencia do while
Si por ejemplo, tenemos el código:
#include <stdio.h>
#include <conio.h>
int main ()
{
int Numero, Entrada, Suma=0;
do {
printf("Introducir un numero entero: ");
scanf("%d", &Entrada);
Numero = Entrada;
fflush(stdin);
Suma += Numero;
printf("\nSuma = %d\n",Suma);
}while (Entrada !=0);
printf("\nUna tecla para salir");
getch();
return 0;
}
Su ejecución nos estará solicitando datos hasta
introducir el número. Cada vez se muestra el
resultado de la suma tanto con números
positivos como negativos. En la figura vemos
un resultado posible:
Tema 3.1.3.- Sentencias de control de programa
20
2.- Instrucciones repetitivas: for, while, do-while
Finalizacíon de un bucle
De forma natural se sale de un bucle cuando se completan todos los ciclos o cuando lo indica la
instrucción condicional.
A veces, en el interior de la estructura de un bucle, pueden darse condiciones que precisen su
terminación, bien saliendo del bucle o pasando a ejecutar un nuevo ciclo.
La tarea descrita la realiza la sentencia continue, y para ver como se aplica recurriremos al código del
ejemplo anterior. Reformamos el código en los apartados destacados.
#include <stdio.h>
#include <conio.h>
int main ()
{
int Numero, Entrada, Suma=0;
do {
printf("Introducir un numero entero: ");
scanf("%d", &Entrada);
Numero = Entrada;
if (Numero < 0)
continue;
Las nuevas líneas de código implican que se ignoren los
fflush(stdin);
números negativos y la terminación del ciclo se sigue
Suma += Numero;
produciendo cuando se introduce un cero. Es decir, la sentencia
printf("\nSuma = %d\n",Suma);
continue nos ha permitido saltar parte del bucle saltando al ciclo
}while (Entrada !=0);
siguiente sin ejecutar las sentencias que hay a continuación,
printf("\nUna tecla para salir");
pero sin que se interrumpa el proceso repetitivo.
getch();
Si lo que necesitamos es romper el proceso utilizaremos la
return 0;
sentencia break, asociado a una sentencia condicional como lo
}
está continue. Si en el ejemplo anterior sustituimos una por otra
conseguiremos
también
salir
del
introduzcamos un número negativo.
Tema 3.1.3.- Sentencias de control de programa
programa
cuando
21
3.- Instrucción de salto incondicional: goto
En C existe una sentencia llamada goto que sirve para realizar una transferencia de control de
ejecución a un punto distinto del programa.
El uso principal que tiene, acompañada de una instrucción if, es la de simular bucles condicionales.
La instrucción realiza una llamada a una etiqueta, que es un identificador valido de lenguaje C seguida
de dos puntos.
Un ejemplo de esta sentencia podría ser:
#include <stdio.h>
#include <conio.h>
int main ()
{
int x=1;
Etiqueta:
printf("%d lineas\n",x);
x++;
if(x<=10)
goto Etiqueta;
printf("\nUna tecla para salir");
getch();
return 0;
}
Este ejemplo producirá exactamente el mismo resultado que el que hemos empleado para el ejemplo
de do-while.
No parece muy apropiado usar esta sentencia cuando C permite crear bucles condicionales.
Relación de ejercicios para resolver:
Ejemplo 17.- Restar dos números
Realizar un programa en C capaz de restar dos números de tipo float estableciendo un
determinado número de decimales.
Tema 3.1.3.- Sentencias de control de programa
22
Relación de ejercicios para resolver:
Ejemplo 18.- Suma y media aritmética
Realizar un programa en C para realizar la suma y calcular la media aritmética de tres números
de tipo float estableciendo un determinado número de decimales.
Ejemplo 19.- Ecuación de segundo grado completa
Realizar un programa en C para resolver la ecuación de segundo grado haciendo el cálculo del
discriminante y obtener mediante sentencias if ... else las raíces reales, las complejas o las raíces
iguales. Probar con los siguientes valores:
a=1, b=12 y c=35; a=1, b=6 y c=5; a=1, b=-6 y c=13; a=-1, b=6 y c=-9;
Ejemplo 20.- Conversión de temperaturas
Sabiendo que (Tª en ºF) = 32 + 1.8 * (Tª en ºC) realizar
un programa en C que nos presente un menú como el
siguiente:
1 - Grados Fahrenheit a centigrados
2 - Grados centigrados a Fahrenheit
3 - Salir
Escoger opcion:
Las opciones las solucionaremos con una sentencia
switch y en cada caso nos debe preguntar por un dato
denominado incremento. Se trata de presentar a modo de
tabla las equivalencias entre ambas temperaturas para
grupos de valores comprendidos entre 0 y 300 variando
según ese incremento. Una de las opciones la
resolveremos con while y la otra con for. Cada vez que se
ejecute una opción debemos limpiar la pantalla (función
clrscr();) y mostrar de nuevo el menú. Debemos ver algo
similar a la figura.
Tema 3.1.3.- Sentencias de control de programa
23
a
l
e
d
Fin
s
e
r
p
n
ó
i
c
a
t
en
Tema 3.1.3.- Sentencias de control de programa
24