Me gustaría incrementar dos variables en una for
condición de bucle en lugar de una.
Entonces algo como:
for (int i = 0; i != 5; ++i and ++j)
do_something(i, j);
¿Cuál es la sintaxis de esto?
Me gustaría incrementar dos variables en una for
condición de bucle en lugar de una.
Entonces algo como:
for (int i = 0; i != 5; ++i and ++j)
do_something(i, j);
¿Cuál es la sintaxis de esto?
Respuestas:
Un modismo común es usar el operador de coma que evalúa ambos operandos y devuelve el segundo operando. Así:
for(int i = 0; i != 5; ++i,++j)
do_something(i,j);
Ahora, habiendo escrito eso, un comentarista sugirió que en realidad era un azúcar sintáctico especial en la declaración for, y no un operador de coma en absoluto. Lo verifiqué en GCC de la siguiente manera:
int i=0;
int a=5;
int x=0;
for(i; i<5; x=i++,a++){
printf("i=%d a=%d x=%d\n",i,a,x);
}
Esperaba que x tomara el valor original de a, por lo que debería haber mostrado 5,6,7 .. para x. Lo que obtuve fue esto
i=0 a=5 x=0
i=1 a=6 x=0
i=2 a=7 x=1
i=3 a=8 x=2
i=4 a=9 x=3
Sin embargo, si coloco entre corchetes la expresión para obligar al analizador a ver realmente un operador de coma, obtengo esto
int main(){
int i=0;
int a=5;
int x=0;
for(i=0; i<5; x=(i++,a++)){
printf("i=%d a=%d x=%d\n",i,a,x);
}
}
i=0 a=5 x=0
i=1 a=6 x=5
i=2 a=7 x=6
i=3 a=8 x=7
i=4 a=9 x=8
Inicialmente pensé que esto mostraba que no se estaba comportando como un operador de coma en absoluto, pero resulta que esto es simplemente un problema de precedencia: el operador de coma tiene la precedencia más baja posible , por lo que la expresión x = i ++, a ++ es efectivamente analizado como (x = i ++), a ++
Gracias por todos los comentarios, fue una experiencia de aprendizaje interesante y he estado usando C durante muchos años.
Prueba esto
for(int i = 0; i != 5; ++i, ++j)
do_something(i,j);
for( ; ; ((++i), (++j)) )
for(int i = 0; i != 5; (++i)) {
el paréntesis adicional engaña al compilador para que piense que ya no es una operación de "incremento".
¡Intenta no hacerlo!
De http://www.research.att.com/~bs/JSF-AV-rules.pdf :
AV Regla 199
La expresión de incremento en un bucle for no realizará ninguna acción más que cambiar un parámetro de un solo bucle al siguiente valor del bucle.Justificación: legibilidad.
Vine aquí para recordarme a mí mismo cómo codificar un segundo índice en la cláusula de incremento de un bucle FOR, que sabía que se podía hacer principalmente al observarlo en una muestra que incorporé a otro proyecto, que estaba escrito en C ++.
Hoy estoy trabajando en C #, pero estaba seguro de que obedecería las mismas reglas a este respecto, ya que la instrucción FOR es una de las estructuras de control más antiguas de toda la programación. Afortunadamente, recientemente había pasado varios días documentando con precisión el comportamiento de un bucle FOR en uno de mis programas C más antiguos, y rápidamente me di cuenta de que esos estudios contenían lecciones que se aplicaban al problema actual de C #, en particular al comportamiento de la segunda variable de índice .
Para los incautos, a continuación se presenta un resumen de mis observaciones. Todo lo que vi sucediendo hoy, al observar cuidadosamente las variables en la ventana Locales, confirmó mi expectativa de que una instrucción FOR de C # se comporta exactamente como una instrucción FOR de C o C ++.
Si alguna de sus variables de índice permanece dentro del alcance cuando finaliza el ciclo, su valor será uno más alto que el umbral que detiene el ciclo, en el caso de la variable de índice verdadera. Asimismo, si, por ejemplo, la segunda variable se inicializa a cero antes de que se ingrese el ciclo, su valor al final será el recuento de iteraciones, asumiendo que es un incremento (++), no una disminución, y que nada en el cuerpo del bucle cambia su valor.
Estoy de acuerdo con Squelart. Incrementar dos variables es propenso a errores, especialmente si solo prueba una de ellas.
Esta es la forma legible de hacer esto:
int j = 0;
for(int i = 0; i < 5; ++i) {
do_something(i, j);
++j;
}
For
Los bucles están pensados para los casos en que su bucle se ejecuta en una variable creciente / decreciente. Para cualquier otra variable, cámbiela en el ciclo.
Si necesita j
estar vinculado i
, ¿por qué no dejar la variable original como está y agregar i
?
for(int i = 0; i < 5; ++i) {
do_something(i,a+i);
}
Si su lógica es más compleja (por ejemplo, necesita monitorear más de una variable), usaría un while
bucle.
int main(){
int i=0;
int a=0;
for(i;i<5;i++,a++){
printf("%d %d\n",a,i);
}
}
i
y a
local para el bucle?
Utilice matemáticas. Si las dos operaciones dependen matemáticamente de la iteración del ciclo, ¿por qué no hacer los cálculos?
int i, j;//That have some meaningful values in them?
for( int counter = 0; counter < count_max; ++counter )
do_something (counter+i, counter+j);
O, más específicamente, refiriéndose al ejemplo del OP:
for(int i = 0; i != 5; ++i)
do_something(i, j+i);
Especialmente si está pasando a una función por valor, entonces debería obtener algo que haga exactamente lo que desea.