¿Cómo coloco dos declaraciones de incremento en un bucle 'for' de C ++?

Me gustaría incrementar dos variables en una forcondició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?

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);

¿Pero es realmente un operador de coma?

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);

¡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.

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

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 ++.

1. La primera vez que se ejecuta un bucle FOR, se omite la cláusula de incremento (la tercera 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 bucle FOR se ejecuta cero o más veces, dependiendo del estado de sus variables de índice y 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 que se ejecuten, el control cae naturalmente en el código de prueba de límite que implementa la cláusula intermedia. 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. Dado que el control se transfiere desde la parte inferior del bloque de bucle FOR al bloque de incremento, 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 de límite de la manera 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, sino en la última iteración, que nunca ejecuta el cuerpo.

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;
}

ForLos 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 jestar 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 whilebucle.

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

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.