Saltar al contenido principal
LibreTexts Español

7.3: Bucle

  • Page ID
    81990
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    Hay tres construcciones en bucle en C. Son while (), do-while () y for (). do-while () es realmente solo un while () con la prueba de continuación de bucle al final en lugar del comienzo. Por lo tanto, siempre obtienes al menos una iteración. La prueba de continuación sigue las mismas reglas que el constructo if (). Aquí están las plantillas while () y do-while ():

    while( test condition(s)... )
    {
        //...statements to iterate...
    }
    
    do {
        //..statements to iterate...
    } while( test condition(s)... )
    

    Aquí hay algunos ejemplos:

    while( a<10 )
    {
        /* Perhaps a is incremented in here.
           If a starts off at 10 or more, this loop never executes */
    }
    
    do {
        /* Perhaps a is incremented in here.
           If a starts off at 10 or more, this loop executes once */
    } while( a<10 )
    
    while( a<10 && b )
    {
        /* This loop continues until a is 10 or more, or b is zero.
           Either condition will halt the loop. Variable a must be
           less than 10 and b must be non-zero for the loop to
           continue */
    }
    

    Por lo general, los bucles usan algún tipo de contador. La forma obvia de implementar un contador es con una declaración como:

    a=a+1;    /* add one to the current value of a */
    

    C tiene operadores de incremento y decremento, ++ y , para que puedas decir cosas como:

    a++;    /* add one to the current value of a */
    a--;    /* subtract one from the current value of a */
    

    C también tiene un modo de acceso directo para la mayoría de las operaciones. Aquí hay dos ejemplos:

    a+=1; /* equivalent to a=a+1; or a++; */
    a*=2; /* equivalent to a=a*2; */
    

    Verás las tres formas de incremento en ejemplo y código de producción, aunque generalmente se prefieren los operadores de incremento y decremento.

    La construcción for () se prefiere generalmente sobre while () si se conoce un número específico de iteraciones. La plantilla es:

    for( initialization(s); termination test(s); increment(s) )
    {
        ..statements to iterate..
    }
    

    Aquí hay un ejemplo usando la variable a como un contador que comienza en 0 y pasa a 9 agregando uno cada vez. El bucle itera 10 veces.

    for( a=0; a<10; a++ ) {
        /* stuff to do ten times */
    }
    

    El siguiente ejemplo es similar, pero agrega 2 en cada bucle, iterando así 5 veces.

    for( a=0; a<10; a+=2 )
    {
        /* stuff to do five times */
    }
    

    El siguiente ejemplo usa múltiplos. Tenga en cuenta el uso de comas.

    for( a=0, b=1; a<10; a++, b*=3 )
    {
        /* stuff to do ten times */
    }
    

    En este caso se inicializan dos variables. Además, en cada finalización de bucle, a se incrementa en 1 y b se multiplica por 3. Tenga en cuenta que b no se usa en la sección de terminación, aunque podría serlo.

    Si el bloque iterado dentro de las llaves consiste en una sola declaración, las llaves pueden quedar fuera (al igual que en la construcción if/else). Los bucles pueden anidarse y contener cualquier declaración C legal incluyendo asignaciones, condicionales, llamadas a funciones y similares. También pueden ser rescindidos anticipadamente mediante el uso de la declaración break. Al igual que en la construcción switch/case, el comando break redirige el flujo del programa a la llave de cierre. Aquí hay un ejemplo:

    for( a=0, b=2; a<7; a++ )
    {
        while( b<a*10 )
            b*=2;
    
        if( b > 50 )
            break;
    }
    

    Tenga en cuenta que el if () no es parte del while (). Esto se ve reforzado visualmente por el uso de sangrías y espaciado, pero eso no es lo que lo hace así. El código se comportaría igual aunque se ingresara así:

    for( a=0, b=2; a<7; a++ ){ while( b<a*10 ) b*=2; if( b>50 ) break;}
    

    Obviamente, el estilo anterior es mucho más fácil de leer que el posterior. Se recomienda encarecidamente que sigas el primer estilo cuando escribas código.

    Bien, ¿qué hace el fragmento de código? Primero, establece a 0 y b a 2. Entonces, el while () comprueba si b es menor que 10 veces a. 2 no es menor que 0, por lo que while () no itera. A continuación, el if () comprueba para ver si b es mayor a 50. No lo es, así que el break no se ejecuta. Con eso concluye la primera iteración. Para la segunda iteración, a se incrementa a 1 y se comprueba para ver si aún es menor que 7. Lo es, así el bucle continúa y entra en el while (). b es menor que 10 veces a (2<10), por lo que b se duplica a 4. Esto es aún más pequeño por lo que se duplica de nuevo a 4, y nuevamente a 8. Por último, se duplica a 16. Ahora es más grande que 10 veces a por lo que el bucle while () sale. El if () no es cierto ya que 16 no es mayor que 50 por lo que no se toma el descanso. Terminamos terminando la iteración dos incrementando a a 2. El bucle while () comienza porque b (16) es menor que 10 veces a (ahora 20). El bucle sólo se ejecutará una vez, dejando b en 32. Esto sigue siendo inferior a 50, por lo que se ignora el descanso. El for () cierra incrementando a a 3. En la siguiente iteración tanto while () como if () se ignoran ya que b es menor que 10 veces a, así menor que 50. Todo eso sucede a medida que a se incrementa a 4. Ahora que a es 4, el while () vuelve a comenzar (32<40). b se duplica a 64. Eso es mayor a 10 veces a, así que sale el while (). b es ahora mayor a 50 por lo que se toma el if (). Esto da como resultado la ejecución de la sentencia break que dirige el flujo del programa a la llave de cierre del bucle for (). La ejecución recoge en la línea que sigue a la llave de cierre y todos terminamos con el bucle for () (no, a nunca llega a 7). Este ejemplo es ciertamente un poco complicado de seguir y no necesariamente la mejor práctica de codificación, pero sí ilustra cómo operan las diversas partes.


    This page titled 7.3: Bucle is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.