Syntaxe pour conditions C++

Bonjour les amis,
J'essaie de traduire, en Xojo et Delphi, un programme (Algorithm 493: Zeros of a Real Polynomial) écrit au départ en Fortran et que j'ai trouvé en C++ aussi.

Je voulais vous demander si cette condition pouvait avoir un sens en C++?
Code:

1 2 3 4 5 6 7 fflag = 1; do { if ((fflag && ((fflag = 0) == 0)) && ((spass) && (!vpass || (tss < tvv)))) ...
fflag est déclaré comme entier et n'intervient ni avant ni après ce bout de code.
Si cette condition est logique, pourriez-vous me dire comment l'interpréter?

Salut,

Si tu veux comprendre ce test, il faut appliquer les priorités imposées par les différentes paires de parenthèses,

Le plus facile est sans doute donc de commencer par séparer les différentes expressions, et de les "indenter" en fonction du "niveau" auquel se trouve la parenthèse ouvrante qui s'y rapporte.
on a donc ((fflag && ((fflag = 0) == 0)) && ((spass) && (!vpass || (tss < tvv)))) qui est composé de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ( // 1 ( // 2 fflag && ( // 3 ( // 4 fflag = 0 ) // 4 == 0 ) // 3 ) // 2 && ( // 5 ( // 6 spass ) // 6 && ( // 7 !vpass || ( // 8 tss < tvv ) // 8 ) //7 ) // 5 ) // 1
Les chiffres que j'ai placés en commentaires permettent de retrouver la parenthèse correspondante qui permet d'avoir une paire composée d'une parenthèse ouvrante et une parenthèse fermante ;).
Les éléments qui se trouvent au même niveau d'indentation et qui sont inclus dans la même paire de parenthèse devront au final être évalués ensembles.

Cependant, chaque terme devra être évalué, du moins, le résultat de cette évaluation risque encore de changer le résultat final, car && et || sont des opérateurs logiques dits "optimisés" : l'expression se trouvant à droite de ces opérateurs n'étant évaluée que si elle peut encore changer le résultat.
C'est à dire que l'expression se trouvant à droite de l'opérateur && ne sera évaluée que si le résultat de l'expression se trouvant à gauche est équivalent à true et que l'expression se trouvant à droite de l'opérateur ||ne sera évaluée que si le résultat de l'expression se trouvant à gauche est équivalent à false.

Commencons donc par comprendre les différents termes de cette expression :

fflag est en fait équivalent à fflag != 0, car, pour convertir n'importe quelle valeur en booléen, on part du principe que 0 vaut false, et que n'importe quelle autre valeur vaut 1
fflag = 0 assigne la valeur 0 à flag
==0 vérifie que le résultat de l'assignation est égal à 0
spass est équivalent à spass != 0
!vpass est équivalent à [c]!(pass[ !=0)/c], autrement dit, inverse l'évaluation booléenne de vpass : si vpass vaut 0, son évaluation d'origne est équivalente à false et devient true, si vpass est différent de 0, son évaluation d'origine est équivalente à true et devient false
tss <tvv évalue le fait que tss soit plus petit que tvv

La suite va être plus joyeuse, car il va s'agir de regrouper les différents termes en fonction des pairs de parenthèses.

La plus imple à expliquer est la paire numéro 8 : cette paire de parenthèses ne sert normalement à rien. Elle n'est là que pour indiquer que l'on prend bel et bien le résultat de l'évaluation de tss < tvv (autrement dit: vrai ou faux selon que tss est plus petit que tvv ou non)

Et comme j'ai commencé avec la paire numéro 8, autant continuer avec la paire numéro 7, qui fait une expression basée sur la 8 ( !vpass || (tss < tvv):
Si !vpass est évalué à false, alors on utilise le résultat de tss < tvv comme résultat de cette expression.

Et, tant qu'on y est, on peut terminer avec les paires de parenthèses 5 et 6 (spass && (!vpass || (tss <tvv) ) ):
Si spass est différent de zéro,alors il faut soit que !vpass (autrement dit que vpass soit égal à 0 ) soit vrai, soit que tss soit plus petit que tvv.

Ne restent plus que les paires de parenthèses 2, 3 et 4 ...

La paire de parenthèses numéro 4 va avoir un effet de bord : si fflag est différent de zéro, sa valeur sera changée pour qu'il soit égal à 0

La paire de parenthèse numéro 3 va utiliser la valeur true si on a du changer la valeur de fflag et ... ne sera pas utilisée si fflag était égal à 0 à l'origine

Au final, on a donc un test booléen dont le résultat est vrai si fflag n'est pas égal à 0 et faux si fflag est égal à 0

Si fflag n'est pas égal à 0 à l'origine, il faut aussi vérifier la valeur de spass, qui doit elle aussi être différente de 0
Et si spass est différent de 0, alors il faut aussi s'assurer que soit vpass est égal à zéro soit que tss est plus petit que tvv

Les opérateurs utilisés permettent d'éviter les vérifications "inutiles", à savoir que:
on ne testera si tss est plus petit que tvv que si on a testé vpass et qu'il n'est pas égal à 0
on ne testera vpass que si fflag n'est pas égal à 0 ET que si n'est pas non plus égal à 0

Mais attention: quoi qu'il arrive, fflag faudra 0 après ce test.

On pourrait donc réécrire cette boucle sous une forme "plus lisible" qui serait proche de
Code:

1 2 3 4 5 6 7 8 9 10 do{ if(fflag != 0){ if(spass != 0){ if (vpass == 0 || (tss < tvv)){ fflag=0; // effet de bord de la parenthèse 4 // tout ce qui doit être fait dans la boucle } } } } // il y a surement une condition while ici (

Est-ce que ce ne serait pas plutôt

Code:

1
2
3
4
5
6
7
8
9
10
do{
    if(fflag != 0){
        fflag=0; // effet de bord de la parenthèse 4
        if(spass != 0){
            if (vpass == 0 || (tss < tvv)){
                // tout ce qui doit être fait dans la boucle
            }
        }
    }
} // il y a surement une condition while ici (

Les opérations étant effectuées dans l'ordre de gauche à droite, fflag sera assigné dès qu'il sera non nul en entrée

Citation:
Envoyé par Bousk
Est-ce que ce ne serait pas plutôt
Code:

1 2 3 4 5 6 7 8 9 10 do{ if(fflag != 0){ fflag=0; // effet de bord de la parenthèse 4 if(spass != 0){ if (vpass == 0 || (tss < tvv)){ // tout ce qui doit être fait dans la boucle } } } } // il y a surement une condition while ici (
Tu as tout à fait raison, je me suis trompé sur ce point...

Et c'est d'autant plus embêtant que, dans la version correspondante que je donne, fflag pourrait ne pas être remis à zéro lorsque fflag est différent de zéro, mais que l'une ou l'autre des deux condition suivante n'est pas respectée.

Ta version corrigée s'assure que fflag sera systématiquement remis à zéro si il a une valeur différente, alors que, dans le code que je présentais, il y a au moins deux cas dans lesquels ce ne serait pas fait, alors que l'on s'attend à ce que ce le soit.

Merci pour l'attention portée à ma répose :D

Holà! Merci Koala pour ce cours de C++.
Donc on peut attribuer une valeur à une variable dans une condition.
Je n'invente pas grand chose, je traduis la plupart du temps des programmes écrits dans différents langages mais le C++ a une syntaxe difficile je trouve, toutes sortes de signes cabalistiques,..., ce qui ne m'a jamais donné envie de m'y mettre.
Je sais que c'est une question d'habitude mais quand même.
Et merci aussi Bousk pour ta contribution sinon je serais toujours en train de traduire cette ligne de code en français.
Tchüss