Estructuras de Control en Lenguaje C

Tema 6

Estructuras de Control en C

´
Indice
6.1. Introducciń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o 6-1
6.1.1. Representaciń de Algoritmos . . . . . . . . . . . . . . . . . . . . . 6-2
o
6.1.2. Programaciń Estructurada . . . . . . . . . . . . . . . . . . . . . . 6-3
o
6.2. Estructuras Secuenciales . . . . . . . . . . . . . . . . . . . . . . . 6-3
6.3. Estructuras Selectivas . . . . . . . . . . . . . . . . . . . . . . . . . 6-4
6.3.1. Estructura Selectiva Simple: if else . . . . . . . . . . . . . . . . 6-4
6.3.2. Sentencias Selectivas Simples Anidadas . . . . . . . . . . . . . . . 6-7
6.3.3. Estructura Selectiva M´ltiple: switch . . . . . . . . . . . . . . . . 6-7
u
6.4. Estructuras Repetitivas . . . . . . . . . . . . . . . . . . . . . . . . 6-11
6.4.1. Sentencia while . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-12
6.4.2. Sentencia do while . . . . . . . . . . . . . . . . . . . . . . . . . . 6-15
6.4.3. Sentencia for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-15
6.5. Ejemplos de Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-19
6.5.1. Lectura del teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-19
6.5.2. Soluciń de una ecuaciń de primer grado . . . . . . . . . . . . . . 6-20
o o
6.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6-20

6.1. Introducciń
o
En los ejemplos de programas que se han visto hasta ahora, las instrucciones segu´ ıan
una estructura secuencial: se ejecutaba una sentencia, tras la finalizaciń se ejecutaba la
o
siguiente, y as´ sucesivamente hasta alcanzar el final del programa.
ı
Evidentemente, esta estructura no es v´lida para todos los casos. Imaginemos que nece-
a
sitamos obtener la suma de los 100 primeros n´meros naturales. Con lo visto hasta ahora, la
u

6-1

6-2 2007–2008

unica posibilidad consiste en utilizar 100 instrucciones, una a continuaciń de otra, sumando
´ o
un n´mero diferente en cada una de ellas.
u
Otro ejemplo en el que no es suficiente con la estructura secuencial es aqu´l en el que
e
s´lo debemos realizar una operaciń si se cumple una condiciń previa: por ejemplo, un
o o o
programa que controla un cajero autom´tico, y s´lo entrega el dinero (y lo resta del saldo)
a o
si la cantidad solicitada es inferior o igual al saldo disponible.
Realmente, lo dif´ es encontrar un programa que pueda realizarse unicamente con la
ıcil ´
estructura secuencial. Por eso, el lenguaje C (y todos los lenguajes de programaciń en o
general) incorporan una serie de estructuras de control que permiten resolver fćilmente los
a
ejemplos mostrados anteriormente.

6.1.1. Representaciń de Algoritmos
o
Un algoritmo, segń el diccionario de la RAE, es un conjunto ordenado y finito de opera-
u
ciones que permite hallar la soluciń de un problema. Es evidente, a partir de la definiciń,
o o
que un algoritmo es independiente del lenguaje de programaciń que se utilice para realizar
o
la soluciń.
o
Por eso es muy conveniente separar la realizaciń de un programa en dos fases: elabo-
o
raciń del algoritmo que soluciona el problema, y traducciń del algoritmo al lenguaje de
o o
programaciń deseado (en nuestro caso el C).
o
De las diferentes tćnicas que existen para la representaciń de un algoritmo, la m´s
e o a
utilizada es la de los diagramas de flujo. En ellos se utilizan s´ ımbolos (cajas) unidos por
flechas (l´ıneas de flujo) que indican las operaciones a realizar y el orden o direcciń de flujo
o
del programa respectivamente. Como se puede comprobar es una forma gr´fica e intuitiva
a
de ver la estructura global de un algoritmo.
Algunos de los s´ımbolos utilizados en los diagramas de flujo son los siguientes:

falso
expresiń
o bloque

cierto

El primero representa una decisiń: en su interior se escribe una condiciń, y si la con-
o o
diciń se cumple se sigue uno de los flujos (el inferior en la figura) y si no se cumple el otro
o
(el de la derecha en la figura).
El segundo representa una conjunto de acciones a realizar, de forma secuencial.
El tercero se utiliza para agrupar flujos provenientes de distintos sitios para seguir un
camino unico.
´
Tambiń se pueden utilizar otros s´
e ımbolos para representar los dispositivos de entrada
y salida (teclado, pantalla, impresora, disco magn´tico). En el caso de que se utilizaran
e
posteriormente se indicar´ expresamente la representaciń de cada uno de ellos.
ıa o
Ahora vamos a estudiar las estructuras de control que propone o usa la programaciń o
estructurada, y luego veremos como se codifican en el lenguaje C.

Fund. de la Prog. 2007–2008 6-3

6.1.2. Programaciń Estructurada
o
La programaciń estructurada se basa en la utilizaciń de un reducido n´mero de es-
o o u
tructuras que permitan hacer que un programa sea sufucientemente legible, reduciendo con-
siderablemente el n´mero de errores, y facilitando enormemente la detecciń y soluciń de
u o o
´stos.
e
La caracter´
ıstica fundamental de la programaciń estructurada consiste en que todas las
o
estructuras tienen un unico punto de entrada y un unico punto de salida. Esto permite des-
´ ´
componer fćilmente un problema en subproblemas, reduciendo la complejidad y facilitando
a
la programaciń.
o
Las estructuras que incorpora el C basadas en la programaciń estructurada son:
o
secuenciales

selectivas

repetitivas
Se debe evitar el uso de cualquier otra estructura que no sea una de las anteriores, ya que
conduce a c´digo no estructurado. Contrariamente a lo que pudiera parecer en un primer
o
momento, esto no supone ninguna limitaciń a la hora de realizar un programa, ya que
o
se puede demostrar que cualquier programa se puede realizar utilizando unicamente estas
´
estructuras.
En concreto, est´ totalmente prohibido en el ambito de la asignatura la utilizaciń de
a ´ o
las sentencias goto (que realiza un salto incondicional) y continue (que fuerza una nueva
iteraciń dentro de de una estructura repetitiva), y s´lo se permite la utilizaciń de la sen-
o o o
tencia break (que fuerza la salida de una estructura selectiva o repetitiva) en el ´mbito de
a
la sentencia selectiva m´ltiple, que se estudiar´ m´s adelante.
u a a

6.2. Estructuras Secuenciales
En un programa en C, las sentencias se ejecutan una tras otra en el orden en el que estń
a
escritas. El fin de una sentencia marca el comienzo de la siguiente.
#include < stdio .h >

/* Obtiene en grados Celsius una temperatura dada en grados
Fahrenheit , seg´ n la expresi´ n o C = (5/9) * ( o F -32) */
u o

int main ()
{
float fahrenheit ;
float celsius ;

printf ( " Temperatura en grados Fahrenheit : " );
scanf ( " %f " , & fahrenheit );

6-4 2007–2008

celsius = ( fahrenheit - 32) * 5 / 9;

printf ( " %f grados fahrenheit son %f grados celsius n " ,
fahrenheit , celsius );

return 0;
}

Para poder considerar un grupo de sentencias como una sola, podemos encerrarlas entre
llaves. A esta construcciń se le denomina bloque, y puede aparecer en cualquier lugar en
o
el que puede aparecer una sentencia.

6.3. Estructuras Selectivas
Tambiń llamadas condicionales; permiten que ciertas sentencias se ejecuten o no en
e
funciń de una determinada condiciń.
o o
En C existen dos tipos de estructuras selectivas:
la simple: if else.
la m´ltiple: switch.
u

6.3.1. Estructura Selectiva Simple: if else
La estructura general de una estructura selectiva simple en C es la siguiente:
if ( expresion )
bloque_if
else
bloque_else

donde la parte correspondiente al else es opcional.
Utilizando diagramas de flujo, tendr´
ıamos lo siguiente:

=0 =0
expresiń
o expresiń
o

=0 =0
bloque else

bloque if bloque if

El funcionamiento de la estructura selectiva simple es el siguiente:

Fund. de la Prog. 2007–2008 6-5

1. se evalá la expresiń que acompaã a la clúsula if
u o n a

2. Si la expresiń es cierta (el valor de la expresiń es distinto de cero), se ejecuta la
o o
sentencia que sigue a continuaciń y se termina.
o

3. Si la expresiń es falsa (el valor de la expresiń es igual a cero) y existe la clúsula
o o a
else, se ejecuta la sentencia que sigue a la clúsula else y se termina.
a

o dicho de otra forma:

el bloque que sigue a la clúsula if s´lo se ejecuta si el valor de la expresiń es distinto
a o o
de cero.

si existe una clúsula else, el bloque que sigue a dicha clúsula s´lo se ejecuta si el
a a o
valor de la expresiń es igual a cero.
o


/* Calcula si un anio es bisiesto o no .
Un anio es bisiesto si es divisible por 4 pero no por 100 ,
excepto aquellos divisibles por 400. */

int main ()
{
int year = 0;

printf ( " Introduzca el anio : " );
scanf ( " %d " , & year );

if ((0 == year % 400) || ((0 == year % 4) && (0 != year % 100)))
printf ( " El anio %d es bisiesto n " , year );
else
printf ( " El anio %d NO es bisiesto n " , year );

return 0;
}

Ponga atenciń en que lo que sigue a un if o a un else es un bloque, y recuerde que
o
un bloque es o una unica sentencia, a un grupo de sentencias encerradas entre llaves. Un
´
problema muy comń cuando se utiliza una estructura selectiva simple consiste en utilizar
u
m´s de una sentencia (sin agruparlas en un bloque) bien en el bloque del if bien en el del
a
else:
if ( numero < 0)
negativo = 1;
suma -= 1;
else

6-6 2007–2008

negativo = 0;
suma += 1;

En el primer caso (varias sentencias en el bloque del if), el compilador detectar´ el pro-
ıa
blema, puesto que habr´ un else que no se corresponde con ningń if (tal y como est´ es-
ıa u a
crito, la sentencia selectiva simple terminar´ con la ejecuciń de la sentencia negativo =
ıa o
1). La soluciń, una vez detectado el problema, es simple: formar un bloque con las dos
o
sentencias encerrńdolas entre llaves:
a
if ( numero < 0)
{
negativo = 1;
suma -= 1;
}
else
negativo = 0;
suma += 1;

El segundo caso es m´s grave, ya que no es ningń error de sintaxis. Desde el punto de
a u
vista del compilador, la sentencia selectiva simple finalizar´ con la ejecuciń de la sentencia
ıa o
negativo = 0, y la siguiente sentencia se ejecutar´ siempre, independientemente de si
ıa
numero es menor o no que cero. En consecuencia, si numero es menor que cero, las sentencias
que se ejecutar´ ser´
ıan ıan:
negativo = 1;
suma -= 1;
suma += 1;

y si no es menor que cero:
negativo = 0;
suma += 1;

Encontrar este error, como se puede comprender, puede resultar muy laborioso. Por eso es
muy conveniente escribir los programas en algń editor que sea capaz de entender la sintaxis
u
de C e indente adecuadamente cada sentencia, en funciń del bloque al que pertenezca. Con
o
un editor de este tipo, el resultado que habr´
ıamos obtenido habr´ sido:
ıa
if ( numero < 0)
{
negativo = 1;
suma -= 1;
}
else
negativo = 0;
suma += 1;

donde puede observarse, por la situaciń de la sentencia suma += 1, que no pertene al
o
bloque de la clúsula else, como deber´
a ıa.

Fund. de la Prog. 2007–2008 6-7

La soluciń, al igual que en el caso anterior, pasa por encerrar entre llaves (y formar un
o
bloque) las sentencias que forman parte del ambito del else:
´
if ( numero < 0)
{
negativo = 1;
suma -= 1;
}
else
{
negativo = 0;
suma += 1;
}

6.3.2. Sentencias Selectivas Simples Anidadas
Dentro de los bloques del if o del else en una sentencia selectiva simple pueden utilizarse
a su vez sentencias selectivas simples, dando lugar a sentencias selectivas simples anidadas.
En este caso, hay que tener en cuenta que la sentencia else se asocia siempre al if m´s a
cercano.
Por ejemplo, en el siguiente fragmento de c´digo:
o
if ( n > 0)
if ( a > b )
z = a;
else
z = b;

la clúsula else se asocia a if (a > b). Si quisi´ramos que se aplicara al primer if,
a e
bastar´ con encerrar entre llaves el segundo if:
a
if ( n > 0)
{
if ( a > b )
z = a;
}
else
z = b;

De hecho es muy conveniente, en el caso de sentencias de selecciń simples anidadas,
o
encerrar siempre entre llaves los bloques correspondientes a cada una de las clúsulas if y
a
else que aparezcan, para dejar claro el ambito de cada una de ellas.
´

6.3.3. Estructura Selectiva M´ ltiple: switch
u
En la estructura selectiva m´ltiple, se puede seleccionar entra varias alternativas segń
u u
el valor de una expresiń. La forma general de la estructura selectiva m´ltiple es:
o u

6-8 2007–2008

switch ( expresion )
{
case exprConst1 :
listaProp1
case exprConst2 :
listaProp2
case exprConstN :
listaPropN
default :
propDefault
}

El diagrama de flujo de esta estructura ser´ el siguiente:
ıa

expresiń entera
o

=
valor 1 bloque 1

=

=
valor 2 bloque 2

=

=
default bloque por defecto

El funcionamiento de esta estructura es como sigue:
1. Se evalá la expresiń que acompaã al switch. Esta expresiń se evalá como expre-
u o n o u
siń entera.
o
2. Se compara el valor obtenido, secuencialmente, con los valores que acompaãn los
n
diferentes case, detenińdose en el primero que coincida. Estos valores deberń ser
e a
siempre expresiones constantes enteras.
Existe una etiqueta especial, default, que siempre es cierta, por lo que se utiliza para
contemplar el resto de casos que no se han considerado en los case anteriores. Por eso es

Fund. de la Prog. 2007–2008 6-9

muy importante que esta etiqueta se sité como la ultima del bloque, puesto que las que se
u ´
pongan detr´s de ella nunca serń consideradas (como se ha obtenido la coincidencia en una
a a
etiqueta, se deja de comprobar el resto de etiquetas).
El problema de esta estructura es que si la expresiń coincide con un case, se ejecuta ´se
o e
y todos los que hubiera por debajo (los case hacen las funciones de etiquetas), que no es lo
que habitualmente se desea. La soluciń consiste en poner un break como ultima proposiciń
o ´ o
dentro de cada case, lo que hace que se finalice la ejecuciń de la estructura switch:
o
switch ( expresion )
{
case exprConst1 :
listaProp1
break ;
case exprConst2 :
listaProp2
break ;
case exprConstN :
listaPropN
break ;
default :
propDefault
break ;
}

lo que se recoge en la siguiente figura:

expresiń entera
o

=
valor 1 bloque 1 break;

=

=
valor 2 bloque 2 break;

=

=
default: bloque por defecto break;

6-10 2007–2008


/* Programa que lea un n´ mero de mes ( en el rango de 1 a 12)
u
e indique el n´ mero de d´ as del mes . */
u ı

int main ()
{
int mes = 0;
int ndias = 0;

printf ( " Introduzca el numero de un mes (1 -12): " );
scanf ( " %2d " , & mes );

switch ( mes )
{
case 2:
ndias = 28;
break ;
case 4:
case 6:
case 9:
case 11:
ndias = 30;
break ;
default :
ndias = 31;
break ;
}
printf ( " tEl mes %d tiene %d dias . n " , mes , ndias );

return 0;
}

Observe c´mo tras la ultima sentencia de cada bloque aparece una sentencia break para
o ´
dar por finalizada la ejecuciń de la estructura selectiva m´ltiple (incluyendo el caso por
o u
defecto, default).
El caso por defecto (default) suele utilizarse para detectar caso no v´lidos o errńeos,
a o
evitando que se produzcan errores en la ejecuciń. El siguiente ejemplo determina si un
o
n´mero entre el 1 y el 10 es par o impar; el caso por defecto se ha utilizado en este programa
u
para los n´meros que estń fuera de ese rango:
u a

/* Determina si un n´ mero entre el 1 y el 10 es par o impar . */
u

int main ()

Fund. de la Prog. 2007–2008 6-11

{
int num = 0;

printf ( " nIntroduzca el n´ mero : " );
u
scanf ( " %d " , & num );

switch ( num )
{
case 1:
case 3:
case 5:
case 7:
case 9:
printf ( " n El n´ mero %d es impar n " , num );
u
break ;
case 2:
case 4:
case 6:
case 8:
case 10:
printf ( " n El n´ mero %d es par n " , num );
u
break ;
default :
printf ( " n FUERA DE RANGO n " , num );
break ;
}

return 0;
}

6.4. Estructuras Repetitivas
En este tipo de estructuras, se repite un conjunto de instrucciones en funciń de una condi-
o
ciń. La principal diferencia entre las diferentes estructuras repetitivas consiste en qu´ punto
o e
se realiza la comprobaciń de la condiciń.
o o
En C existen tres tipos de estructuras repetitivas:

while

do while

for

6-12 2007–2008

6.4.1. Sentencia while
La sintaxis de la sentencia while es la siguiente:
while ( expresion )
bloque

El diagram de flujo correspondiente es:

=0
expresiń
o

=0

bloque while

El funcionamiento es el siguiente:

1. se evalá la expresiń que acompaã a la clúsula while
u o n a

2. Si la expresiń es cierta (el valor de la expresiń es distinto de cero), se ejecuta el
o o
bloque que sigue a continuaciń.
o

3. se vuelve al primer paso, y se repite el proceso.

Algunos aspectos de inter´s sobre esta estructura ser´
e ıan:

Puede que el bloque que sigue al while no se ejecute ninguna vez. Si la primera vez que
se calcula la condiciń el resultado es cero (falso), no se pasar´ a ejecutar el bloque, y
o ıa
se pasar´ directamente a la sentencia que siga a la sentencia while.
ıa

Alguno de los valores que determinan la condiciń debe ser modificado dentro del
o
bloque. Si no fuera as´ y la condiciń fuera cierta (distinta de cero) la primera vez que
ı, o
la comprob´ramos, pasar´
a ıamos a ejecutar el bloque, y ya no saldr´ ıamos nunca de ´le
puesto que la condiciń seguir´ siendo cierta de forma indefinida.
o ıa

En la condiciń, es conveniente utilizar los operadores de rango (<, >, <= o >=) en
o
lugar de los operadores de igualdad y desigualdad (== o !=).

Al igual que suced´ en el caso de las sentencias selectivas simples, es un error muy comń
ıa u
querer utilizar m´s de una sentencia dentro del bloque del while pero no encerrarlas entre
a
llaves, como en el siguiente ejemplo:

Fund. de la Prog. 2007–2008 6-13


int main ()
{
int num = 0;
int suma = 0;

while (10 > num )
num ++;
suma += num ;
printf ( " La suma hasta el %d vale %d n " , num , suma );

return 0;
}

Si lo compilamos y ejecutamos, obtenemos el siguiente resultado:

local> gcc -W -Wall -o whileMal whileMal.c
local> ./whileMal
La suma hasta el 10 vale 10
local>

Como puede observarse, y en contra de lo que pudiera parecer a simple vista, el fragmento de
c´digo anterior no suma los diez primeros n´meros (del 1 al 10), sino unicamente el ultimo
o u ´ ´
(10); a pesar de que el compilador no ha detectado ning´n error. Eso es porque el bloque del
u
while est´ formado unicamente por la sentencia num++;, que es la que se repite 10 veces.
a ´
Una vez ﬁnalizado el bucle while es cuando se ejecuta la sentencia suma += num;, que
l´gicamente s´lo se ejecuta una vez. La forma correcta ser´ la siguiente:
o o ıa

int main ()
{
int num = 0;
int suma = 0;

while (10 > num )
{
num ++;
suma += num ;
}
printf ( " La suma hasta el %d vale %d n " , num , suma );

return 0;
}

6-14 2007–2008

Si lo compilamos y ejecutamos, obtenemos el siguiente resultado:

local> gcc -W -Wall -o whileBien whileBien.c
local> ./whileBien
La suma hasta el 10 vale 55
local>

Se pueden evitar estas confusiones si siempre agrupamos las sentencias que forman el
ambito de aplicaciń del while entre llaves, aunque sea una unica sentencia. O utilizando
´ o ´
un editor de textos que entienda la sintaxis de C e indente adecuadmanete cada sentencia,
en funciń del bloque a que pertenezca.
o

Valores Extremos en la Condiciń
o

En las estructuras repetitivas en general, y como caso particular en la sentencia while,
es muy importante comprobar que los valores extremos de la condiciń (el primer y el ultimo
o ´
valor para los que se ejecuta el bloque que acompaã a la clúsula while) son los adecuados.
n a
Para ello es de gran utilidad repasar mentalmente (o con ayuda de papel y l´piz) qu´ su-
a e
cede en la condiciń de la sentencia while la primera vez que se llega a ella y la ultima vez
o ´
que se realiza la comprobaciń (la vez que se termina la sentencia).
o
Vamos a utilizar como ejemplo para ver esto el del apartado anterior, de suma de los
10 primeros n´meros. La primera vez que llegamos al while, el valor de num vale 0 (lo
u
acabamos de inicializar), que cumple la condiciń (10 > num), por lo que entraremos a
o
ejecutar el bloque. Incrementamos el valor de num (que ahora pasar´ a valer 1) y lo sumamos.
a
Comprobamos pues que el primer valor del bucle es el correcto. Supongamos ahora que num
vale 9; la condiciń se sigue cumpliendo, y por tanto entramos en el bucle: incrementamos
o
num, que ahora pasa a valer 10, y lo sumamos. En la siguiente iteraciń, la condiciń no se
o o
cumple y saldremos de la sentencia while. Hemos comprobado por tanto que efectivamente
hemos sumado los n´meros del 1 al 10.
u
Lo anterior se resume en la siguiente tabla:

num Condiciń Valor sumado num
o
0 cierta 1 1
...
9 cierta 10 10
10 falsa

Modifique el programa del apartado anterior si el bloque de la sentencia while es:
suma += num ;
num ++;

Fund. de la Prog. 2007–2008 6-15

6.4.2. Sentencia do while

La sintaxis de la sentencia do while es la siguiente:

do
bloque
while ( expresion );

El diagrama de flujo de esta sentencia ser´
ıa:

bloque do-while

=0
expresiń
o

=0

A diferencia de la sentencia while, en esta estructura repetitiva primero se ejecuta el
bloque y posteriormente se comprueba la condiciń. Por tanto, el bloque de una sentencia
o
do while se ejecuta siempre al menos una vez.
Se recomienda usar siempre las llaves para delimitar el bloque de sentencias a ejecutar
dentro del bucle. Esto no es necesario cuando el bloque est´ formado por una unica sentencia.
a ´

6.4.3. Sentencia for

La sintaxis de la sentencia for es la siguiente:

for ( inicial ;
expresi´ n ;
o
final )
bloque

El diagrama de flujo de esta sentencia ser´
ıa:

6-16 2007–2008

inicial

=0
expresiń
o

=0

bloque for

final

El funcionamiento de esta sentencia es el siguiente:

1. se ejecuta el bloque inicial.

2. se evalá la expresiń.
u o

3. si es igual a cero, se finaliza la ejecuciń de la sentencia.
o

4. si es distinta de cero:

se ejecuta el bloque.
se ejecuta el bloque final.
se vuelve al paso 2.

En una sentencia for puede omitirse cualquiera de los tres campos, pero es imprescindible
mantener los ;. Si se omite el segundo campo, la condiciń se da por cierta, y se obtiene un
o
bucle infinito.

/* Programa que obtiene la suma de los n´ meros pares
u
comprendidos entre 2 y 1000. */

int main ()
{

Fund. de la Prog. 2007–2008 6-17

int i ;
int suma = 0;

for ( i = 2; i <= 1000; i += 2 )
suma += i ;
printf ( " La suma de los pares hasta 1000 es %d n " , suma );

return 0;
}

Pueden introducirse varias sentencias tanto en el bloque inicial como en el bloque
final. En ese caso, las sentencias van separadas por comas, ejecut´ndose de izquierda a
a
derecha:

/* Programa que obtiene la suma de los n´ meros pares
u
comprendidos entre 2 y 1000. */

int main ()
{
int i ;
int suma ;

for ( suma = 0 , i = 2; i <= 1000; suma += i , i += 2)
;
printf ( " La suma de los pares hasta 1000 es %d n " , suma );

return 0;
}

Obs´rvese el ; aislado que aparece tras la cl´usula for. Esto es necesario porque una sen-
e a
tencia for siempre incluye un bloque for. Si no hubi´ramos incluido ese ; (que representa
e
una sentencia vac´ el bloque del for lo hubiera constituido la sentencia printf, que se
ıa),
habr´ ejecutado 500 veces.
ıa

/* Calcula la potencia n de un n´ mero num */
u

int main ()
{
int num = 0;
int exponente = 0;
int potencia = 1;
int i = 0; /* var . de control del bucle */

6-18 2007–2008

printf ( " nIntroduzca el n´ mero y exponente : " );
u
scanf ( " %d %d " , & num , & exponente );

for ( i = 1; i <= exponente ; i ++)
potencia *= num ;

printf ( " %d elevado a %d vale %d n " , num , exponente , potencia );
/* Proponer modificaci´ n para c´ lculo del factorial !!
o a
en el tema siguiente se ver´ de forma recursiva */
a

return 0;
}

Estructuras Repetitivas Anidadas
Una estructura puede contener otra dentro, cumpliendo que estń totalmente anidadas:
e
for (......)
{
for (..........)
{
while (...)
{
...........
}
}
}

En bucles anidados cada alteraciń del bucle externo provoca la ejecuciń completa del
o o
bucle interno.

/* Imprime tablas de multiplicar */

int main ()
{
int i = 0;
int j = 0;

/* Primera aproximaci´ n */
o
for ( i = 1; i <= 10; i ++)
for ( j = 1; j <= 10; j ++)
printf ( " %d x %d = %d n " , i , j , i * j );

/* M´ s presentable */
a
for ( i = 1; i <= 10; i ++)

Fund. de la Prog. 2007–2008 6-19

{
printf ( " nTabla del %d n ============= n " , i );
for ( j = 1; j <= 10; j ++)
printf ( " %d x %d = %d " , i , j , i * j );
}

/* Ahora las tablas en paralelo .
OJO a como se recorren los ´ ndices . */
ı
for ( i = 1; i <= 10; i ++)
{
printf ( " n " );
for ( j = 1; j <= 10; j ++)
printf ( " %d x %d = %d t " , i , j , i * j );
}
printf ( " n " );

return 0;
}

6.5. Ejemplos de Uso
6.5.1. Lectura del teclado
El siguiente programa lee desde el teclado carćter a carćter, mediante la funciń
a a o
getchar, y escribe lo le´ en la pantalla mediante la funciń putchar. El proceso finaliza
ıdo o
cuando se recibe el carćter de fin de entrada, EOF, que se obtiene pulsando simultńea-
a a
mente las teclas Ctrl y D.

/* Programa que copia la entrada estandar a la salida estandar */

int main ()
{
int c = 0; /* Almacena caracteres */

c = getchar ();
while (( c = getchar ()) != EOF )
putchar ( c );

return 0;
}

6-20 2007–2008

6.5.2. Soluciń de una ecuaciń de primer grado
o o
El siguiente programa calcula la soluciń de una ecuaciń de primer grado del tipo
o o

ax + b = 0

Para ello solicita los dos par´metros necesarios, y resuelve la ecuaciń considerando de forma
a o
separada los casos especiales.

/* Resuelve una ecuaci´ n de primer grado :
o
0 = ax + b
a <> 0 = > x = -b / a
a == 0 y b <> 0 = > soluci´ n imposible
o
a == 0 y b == 0 = > sol . indeterminada */

int main ()
{
int a = 0; /* Coeficiente de la variable independiente */
int b = 0; /* T´ rmino independiente */
e
float x = 0; /* Soluci´ n */
o

printf ( " nIntroduzca los coeficientes a y b : " );
scanf ( " %d %d " , &a , & b );
if (0 != a )
{
x = -( float ) b / a ;
/* Razonar el resultado sin la conversi´ n forzada */
o
printf ( " nLa soluci´ n es %f n " , x );
o
}
else if ( b )
/* La condici´ n anterior equivale a esta otra : 0 != b */
o
printf ( " n Soluci´ n imposible n " );
o
else
printf ( " n Soluci´ n indeterminada n " );
o

return 0;
}

6.6. Ejercicios
1. El siguiente programa imprime los 10 primeros enteros utilizando una sentencia for:

Fund. de la Prog. 2007–2008 6-21

#define MAX 10

/* Representaci´ n de un bucle desde con mientras y
o
hacer - mientras . */

int main ()
{
int i = 0; /* Variable ´ ndice o de control */
ı

printf ( " n Bucle DESDE con for n " );
for ( i = 1; i <= MAX ; i ++)
printf ( " %d t " , i );

return 0;
}

Escriba un programa que realice la misma funci´n utilizando un bucle while. Repita
o
el ejercicio utilizando un bucle do-while.
2. El siguiente c´digo determina si un n´mero es par o impar:
o u

/* Determina si un n´ mero cualquiera ( incluso negativo )
u
es par o impar . */

int main ()
{
int num = 0;

printf ( " nIntroduzca el n´ mero : " );
u
scanf ( " %d " , & num );
switch ( num % 2)
{
case 0:
printf ( " n El n´ mero %d es par n " , num );
u
break ;
case 1:
case -1:
printf ( " n El n´ mero %d es impar n " , num );
u
break ;
default :
printf ( " n El m´ dulo es distinto de 0 , 1 , -1 n " );
o
break ;
}

return 0;

6-22 2007–2008

}

Modificarlo sustituyendo el bloque switch por una simple sentencia selectiva if.

3. Realizar un programa que pida un n´mero positivo y escriba el cuadrado del mismo si
u
dicho n´mero se encuentra comprendido dentro del rango de 0 a 100, en caso contrario
u
dar un mensaje.

4. Programa que calcule el valor medio de los n´meros del 100 al 1000.
u

5. El siguiente programa (que denominaremos cuentaLineas.c ) lee el n´mero de l´
u ıneas
de texto que se escriben por teclado:

/* Programa que lee el numero de lineas a la entrada .
El texto de entrada es una secuencia de lineas , cada una de
ellas terminada con un ’ n ’ ( caracter nueva linea ).
El caracter que marca el final del texto es EOF , que en los
terminales se consigue con Ctrl - D . */

int main ()
{
int c = 0; /* Almacena caracteres */
int nl = 0; /* Cuenta lineas */

c = getchar ();
while ( c != EOF )
{
if ( c == ’ n ’)
++ nl ;
c = getchar ();
}
printf ( " El numero de l´ neas es %d n " , nl );
ı

return 0;
}

Modificar el c´digo para que cuente todos los caracteres.
o

6. Modificar cuentaLineas para que cuente palabras.

7. Escriba un programa que pida un n´mero y un exponente, ambos enteros, y calcule
u
el valor del n´mero elevado al exponente, utilizando la propiedad de que elevar un
u
n´mero a un exponente equivale a multiplicar el n´mero tantas veces como indique el
u u
exponente.

Fund. de la Prog. 2007–2008 6-23

8. Escribir un programa que lea n´meros enteros del teclado y los sume. El programa
u
terminar´ cuando se introduzca un n´mero negativo, imprimińdose la suma.
a u e

9. Realizar un programa que multiplique, sume o reste dos n´meros en funciń de la
u o
opciń elegida.
o

Estructuras de Control en Lenguaje C

Más contenido relacionado

La actualidad más candente (20)

Similar a Estructuras de Control en Lenguaje C (20)

Más de Marvin Romero (20)

Último (20)

Estructuras de Control en Lenguaje C