uso adecuado del operador de incremento previo en combinación con el operador de referencia de puntero

Question

que acabo de escribir la siguiente línea de código:

if (++(data_ptr->count) > threshold) { /*...*/ } // example 1 

Mi intención es incrementar la variable count dentro de la estructura de datos que data_ptr puntos a antes de hacer la comparación a threshold, y esta línea de código funciona.

Si en cambio hubiera querido incrementar data_ptr antes de hacer la comparación, habría escrito esta:

if ((++data_ptr)->count > threshold) { /*...*/ } // example 2 

Por curiosidad, también probé esta línea de código:

if (++data_ptr->count > threshold) { /*...*/ } // example 3 

Y encontró que se comporta exactamente igual que el primero.

Primera pregunta: ¿Por qué hace el ejemplo # 3 trabajo lo mismo que el ejemplo # 1? ¿Es una cuestión de precendencia del operador? Algo en el estándar? Tuve que escribir un programa de prueba rápido porque la respuesta no era obvia para mí.

Segunda pregunta: ¿Debo escribir esta declaración if de manera diferente? Podría realizar el incremento primero, en su propia línea, y luego probar la condición para evitar cualquier posible confusión. ¿Es esto necesario, o los primeros dos ejemplos son suficientemente evidentes por sí solos?

Answer 1

1) Precedencia

2) Preferencia

Answer 2

1. El -> operador se une más apretado que ++.
2. Ambos están bien definidos y creo que son fáciles de leer. Las cosas solo serían dudosas si tuviera referencias adicionales a data_ptr en la misma expresión.

Answer 3

Sí, esta es una cuestión de precedencia del operador. El operador de flecha has higher precedence que el operador de incremento.

para responder a su segunda pregunta, en general, me gustaría separar este tipo de construcción a cabo en dos estados separados:

++(data_ptr->count); 
if(data_ptr->count > threshold) { /*...*/ } 

Esto pone de relieve lo que está pasando y elimina posibles confusiones. Sin embargo, esta es probablemente una cuestión de preferencia.

Answer 4

1. La precedencia de operadores dicta el comportamiento que ha observado.
2. No haría mucho daño si separara el incremento de la comparación en este ejemplo, pero a veces desea tener una condición con incremento en el medio de una secuencia de condiciones, y luego tratar de separar el incremento de la prueba puede dañar la legibilidad del código al introducir el anidamiento que de otro modo sería innecesario.

Por ejemplo:

if (...1...) 
    ...2... 
else if (++data_ptr->count > threshold) 
    ...3... 
else 
    ...4... 

Versus:

if (...1...) 
    ...2... 
else 
{ 
    ++data_ptr->count; 
    if (data_ptr->count > threshold) 
     ...3... 
    else 
     ...4... 
}