programar - Para vs en la programación C?
programacion en c pdf (19)
/ * 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<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)
}
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<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
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 ?
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.
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).
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 pila. 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.
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 ciclos while son útiles cuando la condición depende de algunas entradas. Son los más raramente usados de los tres tipos de bucle.
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<max; ++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 declaración 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).
Por el bien de la legibilidad
Recuerde, un bucle for es esencialmente un bucle de lujo. 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 un bucle infinito accidentalmente. O más bien, es más obvio cuando haces uno porque generalmente colocas el lazo var en la declaración 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;
}
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 ; )
Si existe una gran preocupación acerca de la velocidad y el rendimiento, el mejor enfoque es verificar el código producido por el compilador 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);
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;
}
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.
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
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
fory el es una cuestión de pragmática: usualmente usamosforcuando hay un número conocido de iteraciones, y usamoswhileconstrucciones cuando el número de iteraciones no se conoce de antemano. Elwhilevsdo ... whileproblema 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.
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 compilador toma su código y lo compila, 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 sintaxis se pierden y se vuelven exactamente iguales.
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.
while y for statements se pueden usar para bucles en la programación. Dependerá del programador 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 programación C.
Entre for y while: while que no necesita inicialización ni declaración 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.