¿Para vs. mientras estás en programación C?

Hay tres bucles en C: for, whileydo-while . ¿Cual es la diferencia entre ellos?

Por ejemplo, parece que casi todas las whiledeclaraciones se pueden reemplazar por fordeclaraciones, ¿verdad? Entonces, ¿cuál es la ventaja de usar while?

Un ciclo while siempre evaluará la condición primero.

while (condition) {
  //gets executed after condition is checked
}

Un bucle do / while siempre ejecutará el código en el do{}bloque primero y luego evaluará la condición.

do {
  //gets executed at least once
} while (condition); 

Un bucle for le permite iniciar una variable de contador, una condición de verificación y una forma de incrementar su contador, todo en una línea.

for (int x = 0; x < 100; x++) {
   //executed until x >= 100
}

Al final del día, todos siguen siendo bucles, pero ofrecen cierta flexibilidad en cuanto a cómo se ejecutan.

Aquí hay una gran explicación del razonamiento detrás del uso de cada tipo diferente de bucle que puede ayudar a aclarar las cosas. Gracias clyfe

La principal diferencia entre las for'sy las while' es una cuestión de pragmática: usualmente usamos forcuando hay un número conocido de iteraciones, y usamos whileconstrucciones cuando el número de iteraciones no se conoce de antemano. El problema de whilevs do ... whiletambién es pragmático, el segundo ejecuta las instrucciones una vez al inicio y luego se comporta como el simple while.

Los bucles for son especialmente agradables porque son concisos. Para ello, el bucle for:

for (int x = 0; x < 100; x++) {
   //executed until x >= 100
}

para ser escrito como un bucle while, tendría que hacer lo siguiente:

int count = 0;
while (count < 100) {
  //do stuff
  count++;
}

En este caso, hay más cosas que seguir y count++;podrían perderse en la lógica. Esto podría terminar siendo problemático dependiendo de dónde countse incremente y si debe incrementarse o no antes o después de la lógica del ciclo. Con un forciclo, su variable de contador siempre se incrementa antes de la siguiente iteración del ciclo, lo que agrega cierta uniformidad a su código.

En aras de la integridad, probablemente sea significativo hablar breakycontinue declaraciones aquí, que vienen muy bien cuando se hace el procesamiento de bucle.

break terminará instantáneamente el ciclo actual y no se ejecutarán más iteraciones.

//will only run "do stuff" twice
for (int x = 0; x < 100; x++) {
  if (x == 2) {
    break;
  }
  //do stuff
}

continue terminará la iteración actual y pasará a la siguiente.

//will run "do stuff" until x >= 100 except for when x = 2
for (int x = 0; x < 100; x++) {
  if (x == 2) {
    continue;
  }
  //do stuff
}

Tenga en cuenta que en un bucle for, continueevalúa la part3expresión de for (part1; part2; part3); en contraste, en un ciclo while, simplemente salta para reevaluar la condición del ciclo.

Si existe una gran preocupación por la velocidad y el rendimiento, el mejor enfoque es verificar el código producido por el compilador a nivel de ensamblado.

Por ejemplo, el siguiente código muestra que "do-while" es un poco más rápido. Esto se debe a que el ciclo "do-while" no usa la instrucción "jmp".

Por cierto, en este ejemplo específico, el peor de los casos lo da el bucle "for". :))

int main(int argc, char* argv[])
{
    int i;
    char x[100];

    // "FOR" LOOP:
    for (i=0; i<100; i++ )
    {
        x[i] = 0;
    }

    // "WHILE" LOOP:
    i = 0;
    while (i<100 )
    {
        x[i++] = 0;
    }

    // "DO-WHILE" LOOP:
    i = 0;
    do
    {
        x[i++] = 0;
    }
    while (i<100);

    return 0;
}

// "EN BUCLE:

    010013C8  mov         dword ptr [ebp-0Ch],0
    010013CF  jmp         wmain+3Ah (10013DAh)

  for (i=0; i<100; i++ )
  {
      x[i] = 0;
    010013D1  mov         eax,dword ptr [ebp-0Ch]  <<< UPDATE i
    010013D4  add         eax,1
    010013D7  mov         dword ptr [ebp-0Ch],eax
    010013DA  cmp         dword ptr [ebp-0Ch],64h  <<< TEST
    010013DE  jge         wmain+4Ah (10013EAh)     <<< COND JUMP
    010013E0  mov         eax,dword ptr [ebp-0Ch]  <<< DO THE JOB..
    010013E3  mov         byte ptr [ebp+eax-78h],0
    010013E8  jmp         wmain+31h (10013D1h)     <<< UNCOND JUMP
  }

// BUCLE "MIENTRAS":

  i = 0;
  010013EA  mov         dword ptr [ebp-0Ch],0
  while (i<100 )
  {
      x[i++] = 0;
    010013F1  cmp         dword ptr [ebp-0Ch],64h   <<< TEST
    010013F5  jge         wmain+6Ah (100140Ah)      <<< COND JUMP
    010013F7  mov         eax,dword ptr [ebp-0Ch]   <<< DO THE JOB..
    010013FA  mov         byte ptr [ebp+eax-78h],0
    010013FF  mov         ecx,dword ptr [ebp-0Ch]   <<< UPDATE i
    01001402  add         ecx,1
    01001405  mov         dword ptr [ebp-0Ch],ecx
    01001408  jmp         wmain+51h (10013F1h)      <<< UNCOND JUMP
  }

// BUCLE "HACER MIENTRAS":

i = 0;
.  0100140A  mov         dword ptr [ebp-0Ch],0
  do
  {
      x[i++] = 0;
    01001411  mov         eax,dword ptr [ebp-0Ch]   <<< DO THE JOB..
    01001414  mov         byte ptr [ebp+eax-78h],0
    01001419  mov         ecx,dword ptr [ebp-0Ch]   <<< UPDATE i
    0100141C  add         ecx,1
    0100141F  mov         dword ptr [ebp-0Ch],ecx
    01001422  cmp         dword ptr [ebp-0Ch],64h   <<< TEST
    01001426  jl          wmain+71h (1001411h)      <<< COND JUMP
  }
  while (i<100);

Por el bien de la legibilidad

Todos son intercambiables; podría elegir un tipo y no usar nada más que eso para siempre, pero generalmente uno es más conveniente para una tarea determinada. Es como decir "¿por qué cambiar? Puedes usar un montón de declaraciones if"; es cierto, pero si es un patrón común para verificar una variable para un conjunto de valores, es conveniente y mucho más fácil de leer si hay una característica de idioma. Para hacer eso

Si desea que un bucle se ejecute mientras una condición es verdadera, y no para un cierto número de iteraciones, es mucho más fácil de entender para otra persona:

while (cond_true)

que algo como esto:

for (; cond_true ; )

Recuerde, un forbucle es esencialmente un whilebucle elegante . Son lo mismo.

while <some condition is true> {
   // do some stuff
   // possibly do something to change the condition
}


for ( some var, <some condition is true>; increment var ) {

}

La ventaja de un bucle for es que es más difícil hacer accidentalmente un bucle infinito. O más bien, es más obvio cuando haces uno porque generalmente pones el bucle var en la declaración inicial.

Un whilebucle es más claro cuando no está haciendo un patrón de incremento estándar. Por ejemplo:

int x = 1;
while( x != 10 ) {
  if ( some condition )
     x = 10;
  else 
     x += 5;
}

Debería utilizar un bucle de este tipo que se adapte más a sus necesidades. Por ejemplo:

for(int i = 0; i < 10; i++)
{
    print(i);
}

//or

int i = 0;
while(i < 10)
{
    print(i);
    i++;
}

Obviamente, en tal situación, "para" se ve mejor que "mientras". Y "hacer mientras" debe usarse cuando algunas operaciones deben realizarse antes del momento en que se verificará la condición de su ciclo.

Perdón por mi mal ingles).

Un malentendido común con while/ forloops que he visto es que su eficiencia es diferente. Whilelos bucles y los forbucles son igualmente eficientes . Recuerdo que mi profesor de informática de la escuela secundaria me dijo que los bucles for son más eficientes para la iteración cuando tienes que incrementar un número. Ese no es el caso.

Forlos bucles son simplemente azucarados sintácticamente while y hacen que el código de iteración sea más rápido de escribir.

Cuando el compilador toma su código y lo compila, lo está traduciendo a una forma que es más fácil de entender y ejecutar para la computadora en un nivel inferior (ensamblado). Durante esta traducción, las diferencias sutiles entre las sintaxis whiley forse pierden y se vuelven exactamente iguales.

UN for sugiera una iteración fija usando un índice o variantes en este esquema.

A whileydo... while son construcciones que utiliza cuando existe una condición que debe comprobarse cada vez (aparte de algunas construcciones similares a índices, consulte más arriba). Se diferencian en cuándo se realiza la primera ejecución de la verificación de condición.

Puede usar cualquier construcción, pero tienen sus ventajas y desventajas según su caso de uso.

Hace algún tiempo, noté que un bucle For generalmente genera varias instrucciones de máquina más que un bucle while. Sin embargo, si observa detenidamente los ejemplos, que reflejan mis observaciones, la diferencia son dos o tres instrucciones de máquina, que apenas merecen mucha consideración.

Tenga en cuenta también que el inicializador de un bucle WHILE puede eliminarse introduciéndolo en el código, por ejemplo:

static int intStartWith = 100;

El modificador estático cuece el valor inicial en el código, ahorrando (redoble de batería) una instrucción MOV. Más importante aún, marcar una variable como estática la mueve fuera del marco de la pila. Si la alineación variable lo permite, también puede producir un código ligeramente más pequeño, ya que la instrucción MOV y sus operandos ocupan más espacio que, por ejemplo, un valor entero, booleano o de carácter (ya sea ANSI o Unicode).

Sin embargo, si las variables están alineadas en límites de 8 bytes, una configuración predeterminada común, un int, bool o TCHAR integrado en el código cuesta el mismo número de bytes que una instrucción MOV.

Todos son iguales en el trabajo que realizan. Puedes hacer las mismas cosas usando cualquiera de ellos. Pero difieren en cuanto a legibilidad, usabilidad, conveniencia, etc.

Una diferencia entre while y do-while es que while comprueba la condición del bucle y, si es cierto, se ejecuta el cuerpo y se vuelve a comprobar la condición. Do-while comprueba la condición después de la ejecución del cuerpo, por lo que con do-while el cuerpo se ejecuta al menos una vez.

Por supuesto, puede escribir un bucle while como do-while y vv, pero esto generalmente requiere cierta duplicación de código.

Una peculiaridad del do whilees que necesita un punto y coma después de un tiempo para completar. A menudo se utiliza en las definiciones de macros para ejecutar varias sentencias solo una vez mientras se restringe el impacto de la macro. Si las macros se definieron como bloques, pueden producirse algunos errores de análisis.

Una explicación entre otras

Los bucles for (al menos considerando C99) son superiores a los bucles while porque limitan el alcance de la (s) variable (s) incrementada (s).

Los bucles Do while son útiles cuando la condición depende de algunas entradas. Son los que menos se utilizan de los tres tipos de bucle.

Entre for y while: while no necesita inicialización ni declaración de actualización, por lo que puede verse mejor, más elegante; forpuede tener declaraciones faltantes, una, dos o todas, por lo que es la más flexible y obvia si necesita inicialización, condición de bucle y "actualización" antes de bucle. Si solo necesita la condición del bucle (probado al comienzo del bucle), entonces whilees más elegante.

Entre for / while y do-while : en do-whilela condición se evalúa al final del ciclo. Más cómodo si el bucle debe ejecutarse al menos una vez.

MIENTRAS es más flexible. FOR es más conciso en aquellos casos en los que se aplica.

FOR es ideal para bucles que tienen algún tipo de contador, como

for (int n=0; n<max; ++n)

Puede lograr lo mismo con un WHILE, por supuesto, como otros han señalado, pero ahora la inicialización, la prueba y el incremento se dividen en tres líneas. Posiblemente tres líneas muy separadas si el cuerpo del bucle es grande. Esto dificulta que el lector vea lo que estás haciendo. Después de todo, aunque "++ n" es una tercera pieza muy común de FOR, ciertamente no es la única posibilidad. He escrito muchos bucles donde escribo "n + = incremento" o alguna expresión más compleja.

Por supuesto, FOR también puede funcionar bien con otras cosas que no sean un mostrador. Me gusta

for (int n=getFirstElementFromList(); listHasMoreElements(); n=getNextElementFromList())

Etc.

Pero FOR se rompe cuando la lógica de "la próxima vez que pasa por el bucle" se vuelve más complicada. Considerar:

initializeList();
while (listHasMoreElements())
{
  n=getCurrentElement();
  int status=processElement(n);
  if (status>0)
  {
    skipElements(status);
    advanceElementPointer();
  }
  else
  {
    n=-status;
    findElement(n);
  }
}

Es decir, si el proceso de avance puede ser diferente dependiendo de las condiciones encontradas durante el procesamiento, una instrucción FOR no es práctica. Sí, a veces se puede hacer que funcione con expresiones bastante complicadas, uso del operador ternario?:, Etc., pero eso normalmente hace que el código sea menos legible en lugar de más legible.

En la práctica, la mayoría de mis bucles pasan por una matriz o estructura de algún tipo, en cuyo caso utilizo un bucle FOR; o están leyendo un archivo o un conjunto de resultados de una base de datos, en cuyo caso uso un bucle WHILE ("while (! eof ())" o algo por el estilo).

Son prácticamente iguales excepto por el do-whilebucle. El forbucle es bueno cuando tienes un countertipo de variable. Lo hace obvio. whileEl bucle tiene sentido en los casos en que se comprueba una bandera como se muestra a continuación:

while (!done) {
   if (some condtion) 
      done = true;
}

whiley las forsentencias se pueden usar para hacer bucles en la programación. Dependerá del programador si se utiliza el whilebucle o el forbucle. Algunos se sienten cómodos usando whilebucle y otros con forbucle.

Use cualquier bucle que desee. Sin embargo, el do...whilebucle puede ser algo difícil en la programación C .

/ * bucle while

5 dólares

1 chocolate = 1 dólar

while my money is greater than 1 bucks 
  select chocolate
  pay 1 bucks to the shopkeeper
  money = money - 1
end

Vengo a casa y no puedo ir a comprar porque mi dinero = 0 dólares * /

#include<stdio.h>
int main(){
  int money = 5;

  while( money >= 1){   
    printf("inside the shopk and selecting chocolate\n");
    printf("after selecting chocolate paying 1 bucks\n");
    money = money - 1 ;  
    printf("my remaining moeny = %d\n", money);
    printf("\n\n");
  }

  printf("dont have money cant go inside the shop, money = %d",  money);

  return 0;
} 

Dinero infinito

while( codition ){ // condition will always true ....infinite loop
  statement(s)
}

visite este video para comprender mejor https://www.youtube.com/watch?v=eqDv2wxDMJ8&t=25s

/* en bucle

5 dólares

for my money is greater than equal to 1 bucks   0      money >= 1
  select chocolate
  pay 1 bucks to the shopkeeper
  money = money - 1  1-1 => 0
end

* /

#include<stdio.h>
int main(){

  int money = 5;
  for( ; money >= 1; ){     0>=1  false 
    printf("select chocolate \n");
    printf("paying 1 bucks to the shopkeeper\n");
    money = money - 1;    1-1 = 0
    printf(" remaining money =%d\n", money);
    printf("\n\n");
  }

  return 0;
}

Para una mejor comprensión, visite https://www.youtube.com/watch?v=_vdvyzzp-R4&t=25s