c++ - resueltos - sentencia for

¿Cómo pongo dos instrucciones de incremento en un ciclo ''for'' de C++?

Question

Me gustaría incrementar dos variables en una condición for -loop en lugar de una.

Entonces algo así como:

for (int i = 0; i != 5; ++i and ++j) 
    do_something(i, j);

¿Cuál es la sintaxis para esto?

Answer 1

Estoy de acuerdo con Squelart. Incrementar dos variables es propenso a errores, especialmente si solo prueba uno de ellos.

Esta es la forma legible de hacer esto:

for(int i = 0; i < 5; ++i) {
    ++j;
    do_something(i, j);
}

For bucles For son para casos donde su bucle se ejecuta en una variable creciente / decreciente. Para cualquier otra variable, cámbiela en el ciclo.

Si necesita que j esté vinculado a i , ¿por qué no deja la variable original tal como está y la agrega?

for(int i = 0; i < 5; ++i) {
    do_something(i,a+i);
}

Si tu lógica es más compleja (por ejemplo, necesitas monitorear más de una variable), usaría un ciclo while.

Answer 2

Intenta no hacerlo!

De http://www.research.att.com/~bs/JSF-AV-rules.pdf :

Regla AV 199
La expresión de incremento en un bucle for no realizará más acción que cambiar un parámetro de bucle único al siguiente valor para el bucle.

Justificación: Legibilidad.

Answer 3

Prueba esto

for(int i = 0; i != 5; ++i, ++j)
    do_something(i,j);

Answer 4

Una expresión 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);

Pero, ¿es realmente un operador de coma?

Ahora que lo escribió, un comentarista sugirió que en realidad era un azúcar sintáctico especial en el enunciado for, y no un operador de coma en absoluto. Lo comprobé 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 recogiera 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 coloqué entre corchetes la expresión para forzar al analizador a ver realmente a un operador de coma, entiendo 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 comportaba 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 por muchos años!

Answer 5

Usa Matemáticas. Si las dos operaciones dependen matemáticamente de la iteración del bucle, ¿por qué no hacer las matemáticas?

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 PO:

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.

Answer 6

Vine aquí para recordarme a mí mismo cómo codificar un segundo índice en la cláusula de incremento de un ciclo FOR, que sabía que se podía hacer principalmente al observarlo en una muestra que incorporaba en otro proyecto, la escrita en C ++.

Hoy, estoy trabajando en C #, pero estaba seguro de que obedecería las mismas reglas en este sentido, ya que la declaració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 ciclo FOR en uno de mis antiguos programas C, 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 índice .

Para los incautos, el siguiente es un resumen de mis observaciones. Todo lo que vi hoy, al observar cuidadosamente las variables en la ventana Locales, confirmó mi expectativa de que una instrucción C # FOR se comporte exactamente como una instrucción C o C ++ FOR.

1. La primera vez que se ejecuta un ciclo FOR, se salta la cláusula de incremento (el 3 de sus tres). En Visual C y C ++, el incremento se genera como tres instrucciones de máquina en el medio del bloque que implementa el bucle, de modo que la pasada inicial ejecuta el código de inicialización solo una vez, luego salta sobre el bloque de incremento para ejecutar la prueba de terminación. Esto implementa la característica de que un ciclo FOR se ejecuta cero o más veces, dependiendo del estado de su índice y de las variables de límite.
2. Si el cuerpo del bucle se ejecuta, su última instrucción es un salto a la primera de las tres instrucciones de incremento que se omitieron en la primera iteración. Después de ejecutar estos, el control cae naturalmente en el código de prueba límite que implementa la cláusula media. El resultado de esa prueba determina si el cuerpo del bucle FOR se ejecuta, o si el control se transfiere a la siguiente instrucción más allá del salto en la parte inferior de su alcance.
3. Como el control se transfiere desde la parte inferior del bloque de bucles FOR al bloque de incrementos, la variable de índice se incrementa antes de que se ejecute la prueba. Este comportamiento no solo explica por qué debe codificar sus cláusulas límite de la forma en que aprendió, sino que afecta cualquier incremento secundario que agregue, a través del operador de coma, porque se convierte en parte de la tercera cláusula. Por lo tanto, no se cambia en la primera iteración, pero está en la última iteración, que nunca ejecuta el cuerpo.

Si cualquiera de sus variables de índice permanece en alcance cuando termina el ciclo, su valor será uno más alto que el umbral que detiene el ciclo, en el caso de la variable de índice verdadero. Del mismo modo, si, por ejemplo, la segunda variable se inicializa a cero antes de ingresar el bucle, su valor al final será el recuento de iteraciones, suponiendo que es un incremento (++), no un decremento, y que nada en el cuerpo del lazo cambia su valor.

Answer 7

for (int i = 0; i != 5; ++i, ++j) 
    do_something(i, j);

Answer 8

int main(){
    int i=0;
    int a=0;
    for(i;i<5;i++,a++){
        printf("%d %d/n",a,i);
    } 
}