Hay tres bucles en C: for
, while
ydo-while
. ¿Cual es la diferencia entre ellos?
Por ejemplo, parece que casi todas las while
declaraciones se pueden reemplazar por for
declaraciones, ¿verdad? Entonces, ¿cuál es la ventaja de usar while
?
c
loops
for-loop
while-loop
user355546
fuente
fuente
GOTO
bucle condicional . Si bien la gente no lo considera un bucle, creo que todos los bucles esencialmente se compilan en bucles GOTO condicionales.loop
instrucción más eficiente (resta, comparación y salto en una sola instrucción), que uno que compilewhile
en laloop
instrucción? ¿Los compiladores actuales compilanfor
en unaloop
instrucción?Respuestas:
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
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óndecount
se incremente y si debe incrementarse o no antes o después de la lógica del ciclo. Con unfor
ciclo, 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
break
ycontinue
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,
continue
evalúa lapart3
expresión defor (part1; part2; part3)
; en contraste, en un ciclo while, simplemente salta para reevaluar la condición del ciclo.fuente
for's
y elwhile's
es una cuestión de pragmática: usualmente usamosfor
cuando hay un número conocido de iteraciones , y usamoswhile
construcciones cuando el número de iteraciones no se conoce de antemano . El problema dewhile
vsdo ... while
también es pragmático, el segundo ejecuta las instrucciones una vez al inicio, y luego se comporta como el simplewhile
.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);
fuente
Por el bien de la legibilidad
fuente
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
fuente
do {if(!cond) break; /* do stuff */ } while(cond);
. Feo y repetitivo, pero ese es mi punto sobre por qué existen variaciones :)/* do stuff */
pieza sicond
es falsaSi 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 ; )
fuente
Recuerde, un
for
bucle es esencialmente unwhile
bucle 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
while
bucle 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; }
fuente
for
Los bucles probablemente se introdujeron como métodos convenientes y productivos.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).
fuente
Un malentendido común con
while
/for
loops que he visto es que su eficiencia es diferente.While
los bucles y losfor
bucles 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.For
los bucles son simplemente azucarados sintácticamentewhile
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
while
yfor
se pierden y se vuelven exactamente iguales.fuente
for (i = 0 i < limit ; i++)
.UN
for
sugiera una iteración fija usando un índice o variantes en este esquema.A
while
ydo... 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.
fuente
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.
fuente
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.
fuente
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.
fuente
Una peculiaridad del
do while
es 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
fuente
do-while
existado-while
, solo se usa porque crea un bloque y aún requiere un punto y coma al finalLos 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.
fuente
Entre for y while:
while
no necesita inicialización ni declaración de actualización, por lo que puede verse mejor, más elegante;for
puede 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), entonceswhile
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 bucle debe ejecutarse al menos una vez.fuente
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).
fuente
Son prácticamente iguales excepto por el
do-while
bucle. Elfor
bucle es bueno cuando tienes uncounter
tipo de variable. Lo hace obvio.while
El 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; }
fuente
while
y lasfor
sentencias se pueden usar para hacer bucles en la programación. Dependerá del programador si se utiliza elwhile
bucle o elfor
bucle. Algunos se sienten cómodos usandowhile
bucle y otros confor
bucle.Use cualquier bucle que desee. Sin embargo, el
do...while
bucle puede ser algo difícil en la programación C .fuente
while
,do while
yfor
bucles. Eche un vistazo a la respuesta principal y las encontrará./ * 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
fuente