c# - utilizadas - Nunca visto antes de C++ para el bucle
que significa c# (12)
Como lo expresaron otros, el hecho de que C ++ tenga conversión implícita en booleano significa que el condicional es u-- , que será verdadero si el valor es distinto de cero.
Vale la pena agregar, que tiene una suposición falsa al preguntar "dónde está el condicional". Tanto en C ++ como en C # (y otros lenguajes sintaxis similares) puede tener un condicional vacío. En este caso, siempre se evalúa como verdadero, por lo que el ciclo continúa para siempre, o hasta que alguna otra condición lo abandone (a través de return , break o throw ).
for(int i = 0; ; ++i)
doThisForever(i);
De hecho, cualquier parte de la declaración for puede omitirse, en cuyo caso simplemente no se realiza.
En general, for(A; B; C){D} o for(A; B; C)D; se convierte en:
{A}
loopBack:
if(!(B))
goto escapeLoop;
{D}
{C}
goto loopBack;
escapeLoop:
Cualquiera o más de A, B, C o D pueden ser dejados de lado.
Como resultado de esto, algunos for(;;) para bucles infinitos. Lo hago porque aunque while(true) es más popular, lo leo como "hasta que la verdad termine siendo verdad", lo que suena un tanto apocalíptico en comparación con mi lectura for(;;) como "para siempre".
Es una cuestión de gusto, pero como no soy la única persona en el mundo que me gusta for(;;) , vale la pena saber lo que significa.
Estaba convirtiendo un algoritmo de C ++ en C #. Me encontré con esto por bucle:
for (u = b.size(), v = b.back(); u--; v = p[v])
b[u] = v;
No da error en C ++, pero lo hace en C # (no puede convertir int a bool). Realmente no puedo entender esto para el bucle, ¿dónde está la condición?
¿Alguien puede explicar?
PD. Solo para verificar, para adaptar un VECTOR a una LISTA ¿b.back () corresponde a b [b.Count-1]?
El error encontrado en C # en sí despeja la duda. El for-loop busca una
FALSO
condición para terminar. Y como sabemos,
(BOOL) FALSE = (int) 0
pero C # no puede procesar esto por sí solo a diferencia de C ++. Entonces la condición que estás buscando es
u--
pero tienes que dar explícitamente la condición en C # como
u--! = 0
o
u--> 0
Pero aún así trate de evitar este tipo de práctica de codificación. los
while loop
declarado anteriormente en respuesta es una de las versiones más simplificadas de su
en bucle.
En C, todo lo que no sea cero es true en contextos "booleanos", como la condición de fin de ciclo o una instrucción condicional. En C # tienes que hacer que esa verificación sea explícita: u-- != 0 .
Esta será la forma C # de tu ciclo.
// back fetches the last element of vector in c++.
for (u = b.size(), v = b.back(); (u--) != 0; v = p[v])
{
b[u] = v;
}
Simplemente reemplace el equivalente por size () y back ().
Lo que hace es invertir la lista y almacena en una matriz. Pero en C # tenemos directamente una función definida por el sistema para esto. Por lo tanto, no es necesario que escriba este ciclo también.
b = b.Reverse().ToArray();
La condición del bucle for está en el medio, entre los dos puntos ; comas ; .
En C ++, está bien poner casi cualquier expresión como condición: cualquier cosa que se evalúe como cero significa false ; no cero significa true .
En su caso, la condición es u-- : cuando convierte a C #, simplemente agregue != 0 :
for (u = b.size(), v = b.back(); u-- != 0; v = p[v])
b[u] = v; // ^^^^ HERE
La condición es u--; , porque está en la segunda posición de la instrucción.
Si el valor de u--; es diferente de 0, se interpretará como true (es decir, se convierte implícitamente en el valor booleano true ). Si, en cambio, su valor es 0, se convertirá en false .
Este es un código muy malo .
Actualización: Discutí la escritura de los bucles "for" en esta publicación de blog . Sus recomendaciones se pueden resumir en los siguientes párrafos:
Un bucle for es una construcción práctica, legible (una vez que te acostumbras) y concisa, pero necesitas usarla bien. Debido a su sintaxis poco común, usarlo de una manera demasiado imaginativa no es una buena idea.
Todas las partes del bucle for deben ser cortas y legibles. Los nombres de las variables se deben elegir para que sea fácil de entender.
Este ejemplo claramente viola estas recomendaciones.
La condición es el resultado de u-- , que es el valor de u antes de que se decrementara.
En C y C ++, un int es convertible a bool haciendo implícitamente una comparación != 0 (0 es false , todo lo demás es true ).
b.back() es el último elemento en un contenedor, que es b[b.size() - 1] , cuando size() != 0 .
Muchas respuestas precisas, pero creo que vale la pena escribir el equivalente while loop.
for (u = b.size(), v = b.back(); u--; v = p[v])
b[u] = v;
Es equivalente a:
u = b.size();
v = b.back();
while(u--) {
b[u] = v;
v = p[v];
}
Puede considerar la refactorización en el formato while () a medida que traduce a C #. En mi opinión, es más claro, menos una trampa para los nuevos programadores, e igualmente eficiente.
Como otros han señalado, pero para completar mi respuesta, para que funcione en C # necesitaría cambiar while(u--) a while(u-- != 0) .
... o while(u-- >0) solo en caso de que comiences negativo. (OK, b.size() nunca será negativo, pero considere un caso general en el que quizás algo más se haya inicializado u).
O, para hacerlo aún más claro:
u = b.size();
v = b.back();
while(u>0) {
u--;
b[u] = v;
v = p[v];
}
Es mejor ser claro que ser conciso.
Si estás acostumbrado a C / C ++, este código no es tan difícil de leer, aunque es bastante escueto y no tan genial. Así que déjenme explicar las partes que son más Cism que cualquier otra cosa. En primer lugar, la sintaxis general de un ciclo C for se ve así:
for (<initialization> ; <condition>; <increment>)
{
<code...>
}
El código de inicialización se ejecuta una vez. Luego la condición se prueba antes de cada ciclo y finalmente se llama al incremento después de cada ciclo. Entonces en tu ejemplo encontrarás que la condición es u--
¿Por u-- trabajas como condición en C y no en C #? Porque C convierte implícitamente muchas cosas también bools y puede causar problemas. Para un número, cualquier cosa que no sea cero es verdadera y cero es falsa. Entonces contará hacia atrás desde b.size () - 1 a 0. Tener el efecto secundario en la condición es un poco molesto y sería preferible ponerlo en la parte de incremento del ciclo for, aunque una gran cantidad de C el código hace esto. Si lo estuviera escribiendo lo haría más así:
for (u = b.size() - 1, v = b.back(); u>=0; --u)
{
b[u] = v;
v = p[v]
}
La razón de esto es que, al menos para mí, es más claro. Cada parte del bucle for hace su trabajo y nada más. En el código original, la condición estaba modificando la variable. La parte de incremento estaba haciendo algo que debería estar en el bloque de código, etc.
El operador de coma también puede estar lanzándolo por un ciclo. En C algo como x=1,y=2 parece una declaración en lo que respecta al compilador y se ajusta al código de inicialización. Simplemente evalúa cada una de las partes y devuelve el valor de la última. Así por ejemplo:
std::cout << "(1,2)=" << (1,2) << std::endl;
imprimiría 2.
todas las respuestas son correctas:
for loop se puede usar de varias formas de la siguiente manera:
Single Statement inside For Loop
Multiple Statements inside For Loop
No Statement inside For Loop
Semicolon at the end of For Loop
Multiple Initialization Statement inside For
Missing Initialization in For Loop
Missing Increment/Decrement Statement
Infinite For Loop
Condition with no Conditional Operator.
for (u = b.size(), v = b.back(); u--; v = p[v])
b[u] = v;
En el código anterior, u se inicializan con b.size() y b.back() .
Cada vez que se verifica la condición, también ejecuta una declaración de decremento, es decir, u-- .
El bucle for saldrá cuando se convertirá en 0 .
u = b.size(), v = b.back()
es la inicialización.
u--
es la condición.
v = p[v]
es la iteración