utilisation appropriée de l'opérateur pré-incrément en combinaison avec l'opérateur de déréférence de pointeur

Question

je viens d'écrire la ligne de code suivante:

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

Mon intention est d'augmenter la variable count dans la structure de données qui data_ptr des points à avant de faire la comparaison à threshold, et cette ligne de code fonctionne.

Si j'avais lieu voulu augmenter data_ptr avant de faire la comparaison, je l'aurais écrit ceci:

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

Par curiosité, j'ai aussi essayé cette ligne de code:

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

Et trouvé qu'il se comporte exactement comme le premier.

Première question:Pourquoi fait exemple # 3 travail le même que l'exemple # 1? Est-ce une question de précarité de l'opérateur? Quelque chose dans la norme? J'ai dû écrire un programme de test rapide parce que la réponse n'était pas évidente pour moi.

Deuxième question: Dois-je écrire différemment cette instruction if? Je pourrais effectuer l'incrément d'abord, sur sa propre ligne, et puis tester la condition afin d'éviter toute confusion possible. Est-ce nécessaire, ou les deux premiers exemples sont-ils assez évidents?

Answer 1

1) précédence

2) préférence

Answer 2

1. L'opérateur -> se lie plus que ++.
2. Ils sont tous les deux bien définis et je pense qu'ils sont faciles à lire. Les choses ne deviendraient douteuses que si vous aviez des références supplémentaires à data_ptr dans la même expression.

Answer 3

Oui, il s'agit d'une question de priorité d'opérateur. L'opérateur de flèche has higher precedence que l'opérateur d'incrément.

Pour répondre à votre deuxième question, je séparerais généralement ce type de construction dans des deux états distincts:

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

Cela met l'accent sur ce qui se passe et élimine la confusion possible. Cependant, c'est probablement une question de préférence.

Answer 4

1. priorité de l'opérateur dicte le comportement que vous avez observé. Cela ne ferait pas trop de mal si vous avez séparé l'incrément de la comparaison dans cet exemple, mais vous voulez parfois avoir une condition avec incrément au milieu d'une séquence de conditions, puis essayer de séparer l'incrément du test peut nuire à la lisibilité du code en introduisant une imbrication qui serait autrement inutile.

Par exemple:

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