Para vs en la progtwigción C?

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

Por ejemplo, parece casi todo, while declaraciones pueden ser reemplazadas por declaraciones, ¿no? 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 ciclo do / while siempre ejecutará el código en el bloque do{} 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 loops, 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 el for y el es una cuestión de pragmática: usualmente usamos for cuando hay un número conocido de iteraciones, y usamos while construcciones cuando el número de iteraciones no se conoce de antemano. El while vs do ... while problema también es de pragmática, el segundo ejecuta las instrucciones una vez al inicio, y luego se comporta como el simple.


Para los bucles son especialmente agradables porque son concisos. Para que este bucle for

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

para escribirse como un ciclo while, tendrías que hacer lo siguiente.

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

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


En aras de la exhaustividad, es probable que tenga sentido hablar aquí de las sentencias break y continue , que son útiles cuando se procesa el loop.

break interrumpirá 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 } 

continuar 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 ciclo for, 'continue' evalúa la expresión 'part3' de 'for (part1; part2; part3)'; en cambio, en un ciclo while, solo salta para reevaluar la condición de bucle.

Si existe una gran preocupación acerca de la velocidad y el rendimiento, el mejor enfoque es verificar el código producido por el comstackdor en el nivel de ensamblaje.

Por ejemplo, el siguiente código muestra que el “do-while” es un poco más rápido. Esto porque la instrucción “jmp” no es utilizada por el ciclo “do-while”.

Por cierto, en este ejemplo específico, el peor caso viene dado por 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 } 

// "WHILE" LOOP:

  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 } 

// LOOP "DO-WHILE":

 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; puede 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, puede usar un montón de sentencias if”, es cierto, pero si es un patrón común verificar una variable para un conjunto de valores, es conveniente y mucho más fácil de leer si hay una función de idioma. Para hacer eso

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

 while (cond_true) 

que algo como esto:

 for (; cond_true ; ) 

Recuerde, un bucle for es esencialmente un bucle de lujo. Son lo mismo.

 while  { // do some stuff // possibly do something to change the condition } for ( some var, ; increment var ) { } 

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

Un ciclo while 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 usar dicho bucle, que se ajuste 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 se debe usar "do while" cuando algunas operaciones se deben realizar ya antes del momento en que se verificará el estado de su loop.

Perdón por mi mal ingles).

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

Un while y do... while son construcciones que usas cuando hay una condición que debe verificarse cada vez (aparte de una construcción similar a un índice, ver arriba). Difieren en cuando 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.

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

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

Cuando el comstackdor toma su código y lo comstack, lo está traduciendo a un formato que es más fácil de entender y ejecutar en un nivel inferior (ensamblaje). Durante esta traducción, las diferencias sutiles entre el while y las syntax se pierden y se vuelven exactamente iguales.

Hace un tiempo, me di cuenta de que un bucle For normalmente genera muchas más instrucciones de máquina que un bucle while. Sin embargo, si miras 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 cociendo en el código, por ejemplo:

 static int intStartWith = 100; 

El modificador estático hornea el valor inicial en el código, guardando (tambor) una instrucción MOV. De mayor importancia, marcar una variable como estática lo mueve fuera del marco de la stack. 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 entero, booleano o valor de carácter (ANSI o Unicode).

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

Son todos iguales en el trabajo que hacen. Puedes hacer las mismas cosas usando cualquiera de ellos. Pero para legibilidad, facilidad de uso, conveniencia, etc., difieren.

Una diferencia entre while y do-while es que mientras se comprueba el estado del bucle y si esto es cierto, el cuerpo se ejecuta y la condición se comprueba nuevamente. El 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 ciclo while como do-while y vv, pero esto generalmente requiere alguna duplicación de código.

Una peculiaridad del do while es que necesitas un punto y coma después de un tiempo para completarlo. A menudo se usa en las definiciones de macro para ejecutar varias declaraciones 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 scope de la (s) variable (s) incrementada (s).

Los ciclos while son útiles cuando la condición depende de algunas entradas. Son los más raramente usados ​​de los tres tipos de bucle.

Entre for y while: while que no necesita inicialización ni statement de actualización, por lo que puede verse mejor, más elegante; for pueden faltar las sentencias, una o dos, por lo que es la más flexible y obvia si necesita inicialización, condición de bucle y “actualización” antes del bucle. Si solo necesita condición de bucle (probado al comienzo del bucle), entonces es más elegante.

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

Son más o menos lo mismo excepto para el ciclo do-while while. El bucle for es bueno cuando tienes un tipo de variable counter . Lo hace obvio. while loop tiene sentido en los casos donde se verifica una bandera como se muestra a continuación:

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

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 un contador de algún tipo, como

 for (int n=0; n 

Puede lograr lo mismo con un MOMENTO, por supuesto, como han señalado otros, pero ahora la inicialización, la prueba y el incremento se dividen en tres líneas. Posiblemente tres líneas ampliamente separadas si el cuerpo del lazo es grande. Esto hace que sea más difícil para el lector ver lo que está haciendo. Después de todo, mientras que "++ 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.

FOR también puede funcionar muy bien con cosas que no sean un mostrador, por supuesto. 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 el ciclo" 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 statement FOR no es práctica. Sí, a veces puede hacer que funcione con expresiones lo suficientemente complicadas, con el uso del operador ternario? :, pero eso generalmente hace que el código sea menos legible en lugar de más legible.

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

/ * while loop

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 

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

 #include 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) } 

visita 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 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

while y for statements se pueden usar para bucles en la progtwigción. Dependerá del progtwigdor si se usa el ciclo while o for loop. Algunos se sienten cómodos usando while loop y algunos están con for loop.

Usa cualquier loop que te guste Sin embargo, el ciclo do...while while puede ser un tanto complicado en la progtwigción C.