Cela vient de l'histoire de l'utilisation de valeurs entières comme booléens.
Si x
est un int
, mais je l'utilise comme un booléen, if(x)...
alors l'incrémentation signifiera que quelle que soit sa valeur de vérité avant l'opération, elle aura une valeur de vérité d' true
après elle (sauf dépassement de capacité).
Cependant, il est impossible de prédire le résultat d' --
une connaissance donnée uniquement de la valeur de vérité de x
, car cela pourrait entraîner false
(si la valeur intégrale est 1) ou true
(si la valeur intégrale est autre chose - notamment cela inclut 0 [ false
] et 2 ou plus [true
]).
Donc, en tant que raccourci ++
, a travaillé, et --
n'a pas fait.
++
est autorisé sur les booléens pour des raisons de compatibilité avec cela, mais son utilisation est déconseillée dans la norme.
Cela suppose que je ne l' utilise qu'enx
tant que booléen, ce qui signifie que le débordement ne peut pas se produire tant que je ne l'ai pas fait ++
assez souvent pour provoquer un débordement par lui-même. Même avec char comme type utilisé et CHAR_BITS
quelque chose de bas comme 5, c'est 32 fois avant que cela ne fonctionne plus (c'est encore un argument suffisant pour que ce soit une mauvaise pratique, je ne défends pas la pratique, j'explique simplement pourquoi cela fonctionne) pour un 32 bits, int
nous devrions bien sûr utiliser ++
2 ^ 32 fois avant que ce soit un problème. Avec --
si elle ne permettra d' false
si j'ai commencé avec une valeur de 1 pour true
, ou commencé avec 0 et utilisé ++
exactement une fois avant.
Ceci est différent si nous commençons avec une valeur qui est juste quelques-uns en dessous de 0. En effet, dans un tel cas, nous pourrions vouloir ++
aboutir à la false
valeur éventuellement comme dans:
int x = -5;
while(++x)
doSomething(x);
Cependant, cet exemple traite x
comme int
partout sauf le conditionnel, il est donc équivalent à:
int x = -5;
while(++x != 0)
doSomething(x);
Ce qui est différent de n'utiliser x
que comme booléen.