Discussion :

[bogoss91]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

if  (1 || 0)

Ce que donnera :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (1)

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (1 | 0)

Ça donnera :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (1)

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

[neuro6]

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

[Davidbrcz]

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

[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 .

[fenkys]

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;

[kinji1]

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.

[fenkys]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Jean-Marc.Bourguet]

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)

[bogoss91]

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