Fondo

Hoy conversamos con un chico de C y no estuvimos de acuerdo en lo siguiente:

int intgA[2] = { 1, 2 };
int intgB[2] = { 3, 5 };

int *intAPtr = intgA;
int *intBPtr = intgB;

Entonces cuando hacemos:

*intAPtr++ = *intBPtr++;

Mi analisis

Primero:

intBPtr incrementa en uno, ahora apunta a la dirección de 5. Luego, deferencia, manteniendo el valor 5;

intAPtr también se incrementa en uno, ahora apunta a la dirección de 2. Posteriormente se hace referencia y el valor es 2;

Por último:

2 se sustituye por 5.

Así que respectivamente son: 5 y 5.

Su analisis

El valor de*intBPtr se asigna primero a*intAPtr primero.

Por lo tanto, se convierten en: 3 y 3.

Entonces ambos*intAPtr y*intBPtr Se incrementa en uno.

Así, respectivamente, se convierten en: 4 y 4.

Mi asunción

Pensé que el++ operador tiene prioridad tanto sobre* y=De ahí mi afirmación.

Por ejemplo si tuviéramos:

*intAPtr++; 

El resultado debe ser 2, ¿verdad? Porque primero incrementamos el puntero y luego la desreferencia.

Entonces, ¿por qué en el caso anterior, como él afirma, primero asignamos el valor deintBPtr al valor deintAPtr ¿Y aumentar los valores al último?

Después de haber tomado todas las sugerencias aquí, ejecuté el código en IDE y el resultado confirma el de @sujin:

Aunque confirma que tenía razón al menos en términos de precedencia:

Ese:*intAPtr++ = *intBPtr++;

intAPtr++ Tiene una precedencia más alta, lo que conduce a:intAPtr Incrementa su dirección en 1.

Ahora apuntando a: la dirección de 2.

Y de la misma manera:

intBPtr++ También incrementa en 1 (dirección).

Ahora apuntando a: la dirección de 5.

Entonces es*a su vez:

Así que los dos se desreferenciados (*) a 2 y 5 respectivamente.

Pero El problema sigue existiendo porque la asignación anterior (=) no parece tener lugar.

Si lo hiciera ambos se convertirían en 5.

Esperando ser más iluminado.