Problème avec la priorité de l’opérateur

Le O / p est x = 2, y = 1, z = 1, ce qui ne correspond pas à la priorité de l’opérateur. J’exécutais ceci sur le compilateur Turbo c ++:

void main() { int x,y,z,q; x=y=z=1; q=++x || ++y && ++z; printf("x=%dy=%dz=%d",x,y,z); } 

    La priorité des opérateurs ne détermine en aucune manière l’ordre dans lequel les opérateurs sont exécutés. La priorité des opérateurs définit uniquement le regroupement entre les opérateurs et leurs opérandes. Dans votre cas, la priorité des opérateurs indique que l’expression

     q = ++x || ++y && ++z 

    est groupé comme

     q = ((++x) || ((++y) && (++z))) 

    Le rest n’a absolument rien à voir avec la priorité des opérateurs.

    Le rest est déterminé par la sémantique de chaque opérateur spécifique. L’opérateur de niveau supérieur dans ce cas est || . La propriété spécifique de || L’opérateur est qu’il évalue toujours son côté gauche en premier. Et si la taille de la main gauche s’avère être non nulle, elle ne tente même pas d’évaluer le côté droit.

    C’est exactement ce qui se passe dans votre cas. Le côté gauche est ++x et sa valeur est différente de zéro. Cela signifie que toute votre expression avec les valeurs initiales données est équivalente à un simple

     q = (++x != 0) 

    Le côté droit de || l’opérateur n’est même pas touché.

    En réalité, le résultat est en parfait accord avec la norme C. Les courts-circuits logiques ou opérateurs ( || ) après ++x donné que leur nombre est différent de zéro, les autres sont ignorés.

    Donc à partir de x=1 , y=1 , z=1 , après le court-circuit, vous obtenez x=2 , y=1 , z=1 .

     x=y=z=1; 

    Donne toutes les variables = 1

     q=++x || ++y && ++z; 

    Comme ++x rend = 2 et comme il n’est pas nul, il cesse de vérifier les autres conditions car la première est true .

    Ainsi, x=2 , et y and z = 1

    Logique && ( AND ) et || Les opérateurs ( OR ) sont sujets au court-circuit.

    “Les opérateurs logiques garantissent l’évaluation de leurs opérandes de gauche à droite. Cependant, ils évaluent le plus petit nombre d’opérandes nécessaires pour déterminer le résultat de l’expression. C’est ce qu’on appelle l’évaluation” par court-circuit “.”

    Ainsi, pour les opérateurs logiques toujours évalués comme (peu importe || ou && ) de gauche à droite. Et comme mentionné précédemment, la priorité ici détermine uniquement qui prend qui. Puis règle de gauche à droite;

     q = ++x || ++y && ++z; //ok, lets play by rule, lets see who takes who: //first pass ++ is badass here (has highest precedence) //q = (++x) || (++y) && (++z) //second pass &&'s turn //q = (++x) || ((++y) && (++z)) //done, let's do left to right evaluation q = (++x) || rest.. q = (true)|| whatever.. 

    espérons que cela aide plus clair.