previo arriba siguiente contenido
Previo: 3. Estructuras Condicionales Arriba: Manual de C Siguiente: 5. Arreglos y cadenas
Regresar

Subsecciones

4. Iteración

En este capítulo se revisan los mecanismos de C para repetir un cojunto de instrucciones hasta que se cumple cierta condición.

4.1 La sentencia for

La sentencia for tiene el siguiente formato:

for ( expresion1; expresion2; expresion3)
sentencia;
o { bloque de sentencias }

En donde expresion1 se usa para realizar la inicialización de variables, usando una o varias sentencias, si se usan varias sentencias deberá usarse el operador , para separarlas. Por lo general, establece el valor de la variable de control del ciclo. expresion2 se usa para la condición de terminación del ciclo y expresion3 es el modificador a la variable de control del ciclo cada vez que la computadora lo repite, pero también puede ser más que un incremento.

Por ejemplo:

int X;

main()
{
    for( X=3; X>0; X--)
    {
        printf("X=%d\n",X);
    }
}

genera la siguiente salida a pantalla ...

X=3
X=2
X=1

Todos las siguientes sentencias for son válidas en C. Las aplicaciones prácticas de tales sentencias no son importantes aquí, ya que tan sólo se intenta ilustrar alguanas características que pueden ser de utilidad:

for ( x=0; ( (x>3) && (x<9) ); x++ )

for ( x=0, y=4; ( (x>3) && (x<9) ); x++, y+=2)

for ( x=0, y=4, z=4000; z; z/=10)

En el segundo ejemplo se muestra la forma como múltiples expresiones pueden aparecer, siempre y cuando estén separadas por una coma ,

En el tercer ejemplo, el ciclo continuará iterando hasta que z se convierta en $0$.

4.2 La sentencia while

La sentencia while es otro ciclo o bucle disponible en C. Su formato es:

while ( expresion) sentencia;

donde sentencia puede ser una sentencia vacía, una sentencia única o un bloque de sentencias que se repetirán. Cuando el flujo del programa llega a esta instrucción, primero se revisa si la condición es verdad para ejecutar la(s) sentencia(s), y después el ciclo while se repetirá mientras la condición sea verdadera. Cuando llega a ser falsa, el control del programa pasa a la línea que sigue al ciclo.

En el siguiente ejemplo se muetra una rutina de entrada desde el teclado, la cual se cicla mientras no se pulse A:

main()
{
    char carac;

    carac = '\0';
    while( carac != 'A') carac = getchar();
}

Antes de entrar al ciclo se inicializa la variable carac a nulo. Después pasa a la sentencia while donde se comprueba si carac no es igual a 'A', como sea verdad entonces se ejecuta la sentencia del bucle (carac = getchar();). La función getchar() lee el siguiente carácter del flujo estándar (teclado) y lo devuelve, que en nuestro ejemplo es el caracter que haya sido tecleado. Una vez que se ha pulsado una tecla, se asigna a carac y se comprueba la condición nuevamente. Después de pulsar A, la condición llega a ser falsa porque carac es igual a A, con lo que el ciclo termina.

De lo anterior, se tiene que tanto el ciclo for, como el ciclo while comprueban la condición en lo alto del ciclo, por lo que el código dentro del ciclo no se ejecuta siempre.

A continuación mostramos otro ejemplo:

main()
{
    int x=3;

    while( x>0 ) 
    {
        printf("x = %d\n", x);
        x--;
    }
}

que genera la siguiente salida en pantalla:

x = 3
x = 2
x = 1

Como se observa, dentro del ciclo tenemos más de una sentencia, por lo que se requiere usar la llave abierta y la llave cerrada { ... } para que el grupo de sentencias sean tratadas como una unidad.

Como el ciclo while pueda aceptar también expresiones, y no solamente condiciones lo siguiente es válido:

while ( x-- );

while ( x = x + 1 );

while ( x += 5 );

Si se usan este tipo de expresiones, solamente cuando el resultado de x--, x=x+1 o x+=5 sea cero, la condición fallará y se podrá salir del ciclo.

De acuerdo a lo anterior, podemos realizar una operación completa dentro de la expresión. Por ejemplo:

main()
{
    char carac;

    carac = '\0';
    while ( (carac = getchar()) != 'A' )
        putchar(carac);
}

En este ejemplo se usan las funciones de la biblioteca estándar getchar() -- lee un caracter del teclado y putchar() escribe un caracter dado en pantalla. El ciclo while procederá a leer del teclado y lo mostrará hasta que el caracter A sea leído.

4.3 La sentencia do-while

Al contrario de los ciclos for y while que comprueban la condición en lo alto del bucle, el bucle do ... while la examina en la parte baja del mismo. Esta característica provoca que un ciclo do ... while siempre se ejecute al menos una vez. La forma general del ciclo es:

do {
sentencia;
} while (condición);

Aunque no son necesarias las llaves cuando sólo está presente una sentencia, se usan normalmente por legibilidad y para evitar confusión (respecto al lector, y no del compilador) con la sentencia while.

En el siguiente programa se usa un ciclo do ... while para leer números desde el teclado hasta que uno de ellos es menor que o igual a 100:

main()
{
    int num;

    do 
    {	
        scanf("%d", &num);
    } while ( num>100 );
}

Otro uso común de la estructura do ... while es una rutina de selección en un menú, ya que siempre se requiere que se ejecute al menos una vez.

main()
{
    int opc;

    printf("1. Derivadas\n");
    printf("2. Limites\n");
    printf("3. Integrales\n");

    do 
    {
        printf("   Teclear una opcion:  ");
        scanf("%d", &opc);

        switch(opc)
        {
            case 1:
                printf("\tOpcion 1 seleccionada\n\n");
                break;
            case 2:
                printf("\tOpcion 2 seleccionada\n\n");
                break;
            case 3:
                printf("\tOpcion 3 seleccionada\n\n");
                break;
            default:
                printf("\tOpcion no disponible\n\n");
                break;
        }
    } while( opc != 1  &&  opc != 2  &&  opc != 3);
}

Se muestra un ejemplo donde se reescribe usando do ... while uno de los ejemplos ya mostrados.

main()
{
    int x=3;

    do  
    {
        printf("x = %d\n", x--);
    }
    while( x>0 ) ;
}

4.4 Uso de break y continue

Como se comento uno de los usos de la sentencia break es terminar un case en la sentencia switch. Otro uso es forzar la terminación inmediate de un ciclo, saltando la prueba condicional del ciclo.

Cuando se encuentra la sentencia break en un bucle, la computadora termina inmediatamente el ciclo y el control del programa pasa a la siguiente sentecia del ciclo. Por ejemplo:

main()
{
    int t;
    for(t=0; t<100; t++)
    {
        printf("%d ", t);
        if (t==10) break;
    }
}

Este programa muestra en pantalla los números del 0 al 10, cuando alcanza el valor 10 se cumple la condición de la sentencia if, se ejecuta la sentencia break y sale del ciclo.

La sentencia continue funciona de manera similar a la sentencia break. Sin embargo, en vez de forzar la salida, continue fuerza la siguiente iteración, por lo que salta el código que falta para llegar a probar la condición. Por ejemplo, el siguiente programa visualizará sólo los números pares:

main()
{
    int x;
    
    for( x=0; x<100; x++)
    {
        if (x%2) 
            continue;
        printf("%d ",x);
    }
}

Finalmente se considera el siguiente ejemplo donde se leen valores enteros y se procesan de acuerdo a las siguientes condiciones. Si el valor que sea leído es negativo, se desea imprimir un mensaje de error y se abandona el ciclo. Si el valor es mayor que 100, se ignora y se continua leyendo, y si el valor es cero, se desea terminar el ciclo.

main()
{
    int valor;

    while( scanf("%d", &valor) == 1 && valor != 0)
    {
        if ( valor<0 )
        {
            printf("Valor no valido\n");
            break;
            /* Salir del ciclo */
        }

        if ( valor>100)
        {
            printf("Valor no valido\n");
            continue;
            /* Pasar al principio del ciclo nuevamente */
        }

        printf("Se garantiza que el valor leido esta entre 1 y 100");
    }
}

4.5 Ejercicios

  1. Escribir un programa que lea 5 números y encuentre el promedio, el máximo y el mínimo de esos valores.
  2. Escribir un programa que lea números hasta que se encuentre el cero. El segundo número se sumará al primero, luego el tercero se restará, el cuarto se sumará, y así se deberá seguir alternado hasta que se llegue al cero. Cuando se llegue a esta condicion deberá imprimir el resultado, el total de operandos de la operación (sin incluir el cero), y la suma de los operandos que se restaron.

  3. Escribir un programa que lea un valor entero que será la base para un sistema numérico (binario, octal o decimal), después que lea un entero positivo en esa base y que imprima su valor en base 10. Se debe validar que el número pertenezca a esa base. La base será menor que o igual a 10. El programa podría tener la siguiente salida:
            Entrada          Salida
        Base   Numero      
        ==============     =========
          10    1234          1234
           8      77            63
           2    1111            15
    

  4. Escribir un programa que lea un número en base 10 y lo convierta a base 2, base 8 y base hexadecimal.

  5. Leer tres valores representando lo siguiente: Calcular los valores de la suma del capital y el interes compuesto para un período dado de años. Para cada año el interes es calculado como: interes = capital * tasa_interes / 100;

    el cual se suma al capital

    capital += interes;

    Imprimir los valores de moneda con una precisión de dos decimales. Imprimir los valores del interés compuesto para cada año al final del período. La salida puede ser como la siguiente:

    Capital inicial 35000.00 con tasa del 12.50 en 10 años
     Año    Interes     Suma
    -----+-----------+---------
      1   4375.00    39375.00
      2   4921.88    44296.88
      3   5537.11    49833.98
      4   6229.25    56063.23
      5   7007.90    63071.14
      6   7883.89    70955.03
      7   8869.38    79824.41
      8   9978.05    89802.45
      9  11225.31   101027.76
     10  12628.47   113656.23
    

  6. Leer un valor positivo, y hacer la siguiente secuencia: si el número es par, dividirlo entre 2; si es non, multiplicarlo por 3 y sumarle 1. Repetir lo anterior hasta que el valor sea 1, imprimiendo cada valor, también se deberá imprimir cuantas operaciones de estas son hechas.

    Una salida podría ser la siguiente:

    El valor inicial es 9
    El siguiente valor es 28
    El siguiente valor es 14
    El siguiente valor es  7
    El siguiente valor es 22
    El siguiente valor es 11
    El siguiente valor es 34
    El siguiente valor es 17
    El siguiente valor es 52
    El siguiente valor es 26
    El siguiente valor es 13
    El siguiente valor es 40
    El siguiente valor es 20
    El siguiente valor es 10
    El siguiente valor es  5
    El siguiente valor es 16
    El siguiente valor es  8
    El siguiente valor es  4
    El siguiente valor es  2
    Valor fina1 1, numero de pasos 19.
    

    Si el valor ingresado es menor que 1, imprimir un mensaje que contenga la palabra

    Error

    y haga

    exit(0)


previo arriba siguiente contenido
Anterior: 3. Estructuras Condicionales Subir: Manual de C Siguiente: 5. Arreglos y cadenas   Índice General
Última modificación : 2005-08-12
Héctor Tejeda V
<- htejeda@fismat.umich.mx