Pourquoi les opérateurs logiques et non les opérateurs binaires?

Salut!

Je me pose une question depuis quelques temps : pourquoi utilise-t-on des opérateurs logiques dans les if, else, etc. alors que les opérateurs binaires font la même chose?

Par exmple, si j'ai :

Code:

---

1 2 3 4 5 6

int truc = 5; int bidule = 6;   if (truc == 5 || bidule == 5) { //suite du code...

---

A l'évaluation de truc et bidule, on aura :

Code:

---

if (1 || 0)

---

Ce que donnera :

Code:

---

if (1)

---

Mais l'opérateur binaire '|' ne donne-t-il pas la même chose?
Ainsi, si je remplace ||par | :

Code:

---

if (1 | 0)

---

Ça donnera :

Code:

---

if (1)

---

Donc je comprends pas pourquoi il y a des opérateurs logiques. :?

il me semble que "||" est partiel, si la 1ere condition est vraie, la 2e n'est pas évaluée. "|" teste toutes les conditions.

C'est surtout que | est un ou au niveau binaire, cad bit-à-bit.
Exemple :
9 | 12
En binaire ca done :
(1001 | 1100)
Ce qui donne à la fin :
1|1 -> 1
0|1 -> 1
0|0 -> 0
1|0 -> 1
soit 1101 en binaire donc 13 en décimal

Citation:

---

Envoyé par bogoss91

pourquoi utilise-t-on des opérateurs logiques dans les if, else, etc. alors que les opérateurs binaires font la même chose?

---

C'est pour ça que j'ai précisé que je me pose la question quand c'est pour les conditions . ;)

Ce n'est pas la même chose du tout. || et && attendent des valeurs booleenne. & et | attendent des valeurs entières. Bien qu'il y ait équivalence pour les types scalaires( 0 équivaut à false et le reste à true), ce n'est pas le cas pour les objets non scalaires (les classes entre autres).

Et pour finir un contre exemple avec les types scalaires :
1 && 2 -> true;
1 & 2 donne 0 -> false

PS : rien ne garanti que true == 1. La norme garanti :
bool(0) == false;
false++ == true;
true++ == true;

Citation:

---

Envoyé par fenkys

PS : rien ne garanti que true == 1. La norme garanti :
bool(0) == false;
false++ == true;
true++ == true;

---

Je crois bien que la norme garantie que la conversion entière de true est 1.

Et comme le dit neuro6, la différence entre les opérateurs logiques et les opérateurs binaires lorsqu'ils sont appliqués à des bool, c'est que les premiers permettent les court-circuits lors de l'évaluation de l'expression.

Voici une classe (je ne met pas les controles de validité, ni les constructeurs et on considère que les allocations fonctionnent toujours (pour simplifier la démo).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class intPtr { int * _ptr; public; [...] setPtr(int i) { if (_ptr == NULL) _ptr = new int; _ptr = i; } operator int () {if (_ptr != NULL) return *ptr; else return 0;} operator bool () {return _ptr != NULL;} };

---

Maintenant le code :

intPtr objet;
objet.setPtr(0);

Dans ce cas :
bool a (true);
(int (objet) == 0) est donc vraie
(bool (objet) == true) est donc vraie

& converti en int. Donc le résultat de l'opération (objet & a) sera 0, donc false.
&& convertit en bool. Donc le résultat de l'opération (objet && a) sera true;

Il y a donc bien une autre différence entre les deux opérateurs que la simple évaluation partielle des expressions


oops : j'ai oublié un morceau de phrase important "S'ils sont appliqué à des bool". A cette restriction près tu as raison. Mais ce n'est qu'un cas spécifique, pas le cas général.

Citation:

---

Envoyé par fenkys

PS : rien ne garanti que true == 1. La norme

---

demande que true est converti en 1 dans les contextes demandant un entier et que false est converti en 0 (4.5/4)

Ok merci à vous, je pense avoir compris le truc. ;)