boucle while et post incrémentation

Salut, soit le code suivant :

Code:

---

1 2	while ( (Res) && (Index<DUMP_MODULE_MAX) && (Res=Res && buildWheel(this->m_pModules[Index++])) );

---

Question :
la fonction buildWheel() est-elle appelée avant ou après l'incrémentation de la variable Index ?
je serai tenté de dire avant, mais l'expérience montre qu'elle est appelée après.
Vous en pensez quoi ? au niveau normes, etc...
:?:

remarque : ce code est censé appeler la fonction buildWheel() pour tous les m_pModules[], jusqu'à ce qu'il y en ait une qui renvoit faux. La variable Res set à renvoyer le résultat.

Tu utilises la post-incrémentation, Index sera donc incrémenté avant l'appel à la fonction (je n'ai pas la norme mais je pense qu'il est clair que les paramètres sont toujours évalués avant), par contre c'est sa valeur initiale qui sera renvoyée et donc passée à la fonction.

Et au passage, peut-être qu'une boucle for serait plus "claire" ?

Code:

---

1 2 3 4 5

for (int Index = 0; Index < DUMP_MODULE_MAX; ++Index) { if (!buildWheel(this->m_pModules[Index])) break; }

---

Ou encore

Code:

---

for (Truc* Ptr = this->m_pModules; (Ptr != m_pModules + DUMP_MODULE_MAX) && buildWheel(*Ptr); ++Ptr);

---

tel que je vois les choses, normalement avec ce code :

Code:

---

while ( (Res) && (Index<DUMP_MODULE_MAX) && (Res=Res && buildWheel(this->m_pModules[Index++])) );

---

on devrait, dans l'ordre :
- évaluer Res;
- évaluer Index<DUMP_MODULE_MAX;
- appeler buildWheel() avec la valeur de this->m_pModules[Index];
- faire l'opération Res = Res && (valeur de retour);
- évaluer Res;
- incrémenter Index;

et grâce au debugger, je vois que ce n'est pas éxactement ce qui se passe.
Je vais récrire ce truc pour faire plus lisible, sans que cela ne prète à confusion, et lever toute ambiguïté. De toute façon, je ne suis pas convaincu du bien fondé de ce type d'écriture.
Un détail, buildWheel() est une macro renvoyant à une fonction, mais je ne pense pas que cela change quoi que ce soit...
Merci en tout cas.

Sans étudier le truc dans le détail, il est en tout cas clair que le compilo construit un "arbre syntaxique" de ton expression logique.
A la racine, l'opérateur "&&" avec à gauche 'Res' et de l'autre, un autre opérateur "&&", qui à sa gauche à un opérateur "<" et ses opérandes, à droite encore un &&, etc...

ensuite, selon l'implémentation il reste possible que les noeud terminaux (comme, typiquement, l'appel de fonction) soient évalué AVANT l'arbre logique. D'où l'incrémentation de 'Index' avant le test.

Comme diraient Eric ou Ramzy... "Je ne vois pas d'autre explication..."

De plus, moi qui aime bien les macros, j'ai bani les "++" dans "l'appel de macro" (passez moi l'expression) car il est toujours possible que la macro utilise deux fois l'argument, et donc l'incrémente deux fois.
Ta syntaxe 'while' ne me choque pas, j'aurais tout simplement incrémenté Index à la place du point-virgule, (même s'il y a effectivement plus lisible) i.e. :

Code:

---

1 2	while(.... buldWhell(...Index...)...) {Index++;}

---

moi aussi cette écriture me plaît bien (c'est moi qui l'ait fait) mais elle plaît moyen aux autres... trop "sioux" à leur goût. En plus, telle quelle ça ne fonctionne pas.
Je voulais juste savoir si c'était moi qui ne comprenait pas ou un problème de compilo.
Effectivement, le fait de mettre Index++ à la place du ";" arrange tout...
Tant pis ! :roll:

Juste pour être sûr, à quoi correspond la macro buildWheel ?

Citation:

---

ensuite, selon l'implémentation il reste possible que les noeud terminaux (comme, typiquement, l'appel de fonction) soient évalué AVANT l'arbre logique. D'où l'incrémentation de 'Index' avant le test.

---

Perso je dirais que tout est bien défini ici : les opérandes de && de gauche à droite, et les arguments de fonction avant l'appel. Le seul truc que je verrais indéfini ce serait l'ordre d'évaluation des paramètres, pour une fonction qui en prend plusieurs. Mais ici ce n'est pas le cas.

Sinon toujours au niveau du style, tant qu'à garder le while, ceci doit être équivalent

Code:

---

1 2	while ((Index<DUMP_MODULE_MAX) && buildWheel(this->m_pModules[Index])) Index++;

---

SKZ81 a le nez creux : c'est une macro qui utilise deux fois son argument, d'où les soucis d'incrémentation...