Operateurs booleens donc logiques : )

Version imprimable

17/09/2022, 11h31
adiya

Operateurs booleens donc logiques : )

Bien le bonjour

j'ai une question, je ne suis pas du tout sur qu il existe une solution... je tente quand meme...

il existe en C++, les deux operateurs logiques && et || , donc soit le simple "ET", soit le "OU exclusif...
je ne trouve pas mention du simple "OU", qui pourrait s ecrire "&|" ... donc un operateur qui permette une condition telle que :

soit l une des deux conditions est vraie, soit les deux

Car il me semble que "||" n est pas vrai si les deux conditions sont remplies en meme temps...

merci de votre eclairage :?

C'est quoi la question :koi: ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
 
 
int main()
{
    std::cout << "true  || true  is " << ((true  || true)?  "true": "false") << std::endl;
    std::cout << "true  || false is " << ((true  || false)? "true": "false") << std::endl;
    std::cout << "false || true  is " << ((false || true)?  "true": "false") << std::endl;
    std::cout << "false || false is " << ((false || false)? "true": "false") << std::endl << std::endl;
 
    std::cout << "true  ^ true  is " << ((true  ^ true)?  "true": "false") << std::endl;
    std::cout << "true  ^ false is " << ((true  ^ false)? "true": "false") << std::endl;
    std::cout << "false ^ true  is " << ((false ^ true)?  "true": "false") << std::endl;
    std::cout << "false ^ false is " << ((false ^ false)? "true": "false") << std::endl;
 
 
    return 0;
}

Résultat :

Code:

1
2
3
4
5
6
7
8
9
true  || true  is true
true  || false is true
false || true  is true
false || false is false
 
true  ^ true  is false
true  ^ false is true
false ^ true  is true
false ^ false is false

17/09/2022, 13h36
Delias
Bonjour

A moins d'avoir un compilateur très exotique et bugué (ou ne respectant pas la norme, c'est à choix), || c'est bien la fonction OR et Vrai||Vrai donne bien Vrai.
Le ou exclusif, c'est l'opérateur ^.

A noté que les opérateurs doublés && et || sont des opérateurs dit à court-circuit, si la première expression fige déjà le résultat, parce qu'elle vaut faux pour le && ou vrai pour le ||, la deuxième expression n'est pas évaluée.

&, | et ^ peuvent être utilisé comme opérateur dans une évaluation booléen pour un Test, mais aussi comme opérateur booléen bit à bit. 14&5 vaut 4, 5|6 vaut 7 et 7^10 vaut 13
14 & 5 c'est 1110 & 0101 0100 -> 4 5 | 6 c'est 0101 | 0110 0111 -> 7 7 ^10 c'est 0111 ^ 1010 1101 -> 13
Delias
17/09/2022, 13h46
adiya

OUPS....

Merci beaucoup
j ai pris conscience que... je ne savais pas... :roll:
17/09/2022, 23h16
Guesset

Opérateur logique et binaire

Bonsoir,

Delias a raison de citer le ^ qui opère un ou exclusif. Mais c'est un ou exclusif binaire. Il n'opère pas sur des valeurs logiques ou interprétées comme tel mais sur les bits d'entiers.

Le xor logique n'existe pas dans ce langage.

Si le xor logique existait, supposons a = 0xF0F0 et b = 0x00FF, comme a et b sont différents de 0 ils seront interprétés comme a = true et b = true, alors a xor b serait false. mais a ^b = 0xF00F diffère de 0, il sera interprété comme true.

Cette différence de comportement logique vs binaire se retrouve entre || et |, entre && et &, entre ! et ~.

Salutations
21/09/2022, 13h15
adiya

Guesset, merci de ta reponse...

donc, le || est un ou logique... autant pour moi...

mais il me semblait bien : dans mes cours de C++ il n y a pas trace de ou exclusif...

il doit y avoir moyen en combinant une expression comme :

if ( a || b ) && ( ! ( a && b)) ...

je sais pas trop... les logiques booleennes...
21/09/2022, 13h47
Guesset

Pourquoi faire simple ?
Bonjour,

En c++, il n'y a pas de ou exclusif logique mais il y a un ou exclusif binaire.

La solution proposée fonctionne mais il y a une manière de tricher pour utiliser en lieu et place le ( ^ ) ou exclusif binaire :
- Si les expressions a et b sont des booléens, ils correspondent à 0 et 1, alors a ^ b correspondra aussi à 0 ou 1 et sera correctement interprété comme a xor b logique.
- Si a et b sont de valeurs entières, il suffit d'écrire (a != 0) ^ (b != 0) ou plus court mais moins lisible !(a) ^ !(b).
Salutations
21/09/2022, 14h10
adiya

Donc 2 valeurs booleennes peuvent etre comparees comme 2 bits sont comparés...
il faudra donc que je fasse quelques essais... sans chagriner mon compilateur...

Merci
21/09/2022, 15h14
Bktero
A noter toutefois que a && b et a || b donnent un booléen, alors que a^ b donne un entier. Ca peut faire des choses surprenantes si tu utilises auto (et tu utilises presque toujours auto, hein ? :) ) pour stocker le résultat.

Tu peux aussi faire des trucs comme ceci (mais ça peut être tricky) si tu travailles sur des types customs :
Code:

1 2 3 inline bool operator^(const Foo& lhs, const Foo& rhs) { return (lhs and not rhs) or (not lhs and rhs); }
21/09/2022, 15h43
adiya

Aaaah non !!

'auto' , c'est pas dans mes principes...

Sinon, j'ai pu faire fonctionner du code en utilisant des variables booleennes... et ca fonctionne.
le compilateur accepte bool^bool et renvoie un bool.

De la lecture sur auto : https://herbsutter.com/2013/08/12/go...t-always-auto/

Non, ça renvoie bien un entier :
Code:

1 2 3 4 5 6 7 8 #include <type_traits> int main() { bool a, b; static_assert(std::is_same_v<decltype(a ^b), int>); // compile static_assert(std::is_same_v<decltype(a ^b), bool>); // ne compile pas }
Si tu ne comprends pas ce code, qui est plutôt obscur de prime abord, analyse-le par parties :

decltype(expression renvoie le type de l'expression
std::is_same_v<U, V> est vrai si les types U et V sont les mêmes
static_assert(condition) compile que si la condition est vraie

Il s'avère qu'ensuite cet entier est convertible implicitement en booléen.

22/09/2022, 11h20
Guesset

Le retour du chicaneur

Bonjour Bktero,

Citation:

Envoyé par Bktero

...Il s'avère qu'ensuite cet entier est convertible implicitement en booléen.

Je me suis placé implicitement dans le cadre d'expressions dans un test (if(), while() etc.) J'aurais du le préciser :oops:. Sinon il faut caster en bool.

J'attire l'attention sur l'idée fréquente que dans un test, l'expression est implicitement castée en booléen avant usage. Si ça permet de mieux comprendre, c'est cependant faux. Comme le disait Valéry : "ce qui est simple est faux et ce qui est complexe est inutile".

Le point ci après n'a donc d'intérêt que pour qui s'intéresse un peu au code généré. Les processeurs ne testent pas des booléens mais des entiers. Ca ne sert donc à rien de passer par des booléens pour faire un test que le processeur peut faire directement sur l'entier.

En effet, pour caster un entier en bool, on fait un cmp i, 0 (comparaison de l'entier à 0) puis une affectation conditionnelle de 1 ou 0 selon le flag zf (zero flag) levé par la comparaison. En résumé, ce cast implique déjà le test sur l'entier. Et la comparaison suscitée lève tous les flags utiles pour les branchements sans nécessité aucunement la création d'une variables booléenne.

En résumé, le cast suppose le test (cmp) mais le test ne suppose pas le cast (on cherche un branchement et non une affectation conditionnelle).

Salut.
22/09/2022, 11h49
foetus

Citation:

Envoyé par Guesset

Les processeurs ne testent pas des booléens mais des entiers.

C'est normal :mrgreen: le type booléen n'existe pas ... à moins que les nouvelles normes ont changé cela.

true et false sont des typedef respectivement de 1 et 0 et le système du C a été repris : tout ce qui n'est pas 0 est vrai, 0 est faux.
En C++, je pense que ce type sert juste aux contrôles de type lors de la compilation ... mais jamais 1 booléen C++ ne fera 1 seul bit.

Après, en C++, il y a des chausses-trappes comme par exemple, tu ne peux pas faire 1 std:vector<bool>.
22/09/2022, 12h14
Bktero

@Guesset :

Citation:

Ca ne sert donc à rien de passer par des booléens pour faire un test que le processeur peut faire directement sur l'entier.

Il ne faut pas confondre le langage de haut-niveau dans lequel tu t'exprimes, et le langage de bas-niveau dans lequel le processeur fait les actions correspondantes. Quand tu fais du C++, ta réflexion doit se faire en C++ et non en assembleur (l'immense majorité du temps).

@foetus :

true, false et bool sont des mots-clés du langage https://en.cppreference.com/w/cpp/keyword

bool est un type https://en.cppreference.com/w/cpp/la...s#Boolean_type

Tu ne peux pas faire un vecteur de booléens ? Ce type existe pourtant : https://en.cppreference.com/w/cpp/container/vector_bool
22/09/2022, 12h28
Guesset

Les booléens perdus

Bonjour foetus,

Citation:

Envoyé par foetus

C'est normal :mrgreen: le type booléen n'existe pas ... à moins que les nouvelles normes ont changé cela...

Je parle de processeur non d'un langage quelconque, de ses normes et définitions. Et un processeur a effectivement des opérations (mais ni cmp ni test) sur des booléens : les flags sont des booléens.

Salut
22/09/2022, 12h45
Guesset

Bonjour Bktero,

Citation:

Envoyé par Bktero

...Il ne faut pas confondre le langage de haut-niveau dans lequel tu t'exprimes, et le langage de bas-niveau dans lequel le processeur fait les actions correspondantes. Quand tu fais du C++, ta réflexion doit se faire en C++ et non en assembleur (l'immense majorité du temps)...

En langage de haut niveau : il n'y a pas de cast implicite dans les tests.

Quand quelqu'un transforme un comportement "dans un test seul un entier non nul sera considéré comme vrai" en un cast implicite, il présuppose un mécanisme sous-jacent qui n'existe pas. J'ai seulement utilisé l'assembleur pour l'expliquer à ceux que ça intéresse, mais on peut parfaitement vivre sans le savoir.

Salut
24/09/2022, 12h00
adiya

OK

Si je comprend bien, C++, pour ce qui est des tests (qui semblent booleens) compare des valeurs entieres...
...du style, si la valeur est a 0, on renvoie 'false' et sinon, 'true'...

donc, si une comparaison booleenne renvoie un entier, ce ne sera pas un souci... il prendra en compte la valeur de retour comme si c etait une valeur booleenne.

Ceci ne serait il pas suffisant pour permettre une operation logique du type 'bool^bool' ?
24/09/2022, 12h01
adiya

au quel cas, pas besoin de 'cast'....

Citation:

Envoyé par adiya

Si je comprend bien, C++, pour ce qui est des tests (qui semblent booleens) compare des valeurs entieres...
...du style, si la valeur est a 0, on renvoie 'false' et sinon, 'true'...

Non, le C++ peut directement gérer des booléens. Mais à un moment il s'attend un booléen et qu'il y a un nombre, il le convertit par la règle: 0 c'est false, sinon c'est true.

Citation:

Envoyé par adiya

donc, si une comparaison booleenne renvoie un entier, ce ne sera pas un souci... il prendra en compte la valeur de retour comme si c etait une valeur booleenne.

Oui en vertu de la régle ci-dessus.

Citation:

Envoyé par adiya

Ceci ne serait il pas suffisant pour permettre une operation logique du type 'bool^bool' ?

Ça marche car le résultat de 'bool^bool' est un entier qui vaudra 0 ou 1, et donc convertible directement en un booléen. Mais le bon opérateur qui retourne directement un booléen c'est != (attention seulement si les 2 opérantes sont des booléens.)
Code:

1 2 3 4 5 6 auto a{true} auto b{true}; auto c = a != b; // c est un bool équivalent à : a XOR b auto d = a ^ b; // d est un int qui vaut 1 si a XOR b est true, qui vaut 0 sinon if ( a ^ b ) { // ok car fait : a converti en int, b converti en int, appliquer a^b, conversion du résultat en bool if ( a != b ) { // ok car fait : true ssi a différent de b, et comme ce sont des booléens on a bien fait un XOR

24/09/2022, 18h15
adiya

Bien vu...

Si je comprend bien, "mesurer" que a et b sont differents, (en mode booleen), equivaut a un OU exclusif...
car si a et b sont de meme valeur(booleenne) c est a dire a=b=true, ou a=b=false, l operateur (!=) renvoie "false"...

Du coup, je comprend pas pourquoi on s embete a chercher un OU eXclusif, alors qu il suffit de calculer (a!=b)...

quelque chose m echappe ... :roll:
24/09/2022, 20h19
foetus

Citation:

Envoyé par adiya

l operateur (!=) renvoie "false"...

Même avec des entiers, l'opérateur != renvoie 1 booléen : exemple if (a != 15).
Je pense que @dalfab voulait dire qu'avec cet opérateur, si on teste 2 booléens il n'y aura pas de conversion des booléens en entier pour tester

Citation:

Envoyé par adiya

OU eXclusif

:whistle: peut-être parce que c'est 1 opération binaire (avec 0 et 1) et non logique (avec true et false)
27/09/2022, 22h40
Guesset

Bonjour,

Dans un test, toutes les comparaisons restent des comparaisons sans aucune conversion. Un peu comme en mathématiques où "si a > b" n'a nul besoin d'être traduit en "si a > b est vrai". Ou en langage courant "si il pleut" ne nécessite par d'écrire "s'il est vrai qu'il pleut" J'incite à regarder soit l'assembleur généré soit la grammaire du langage pour voir que nul booléen n'est créé à la volée.

Le résultat d'un test donne à la fois une ribambelle d'informations : '0 ? plus grand ? négatif ? etc. Selon la condition choisie le branchement utilisera une partie d'entre elles pour sauter au else ou continuer en séquence (then).

Salutations
28/09/2022, 08h25
Bktero
Citation:

Envoyé par Guesset

J'incite à regarder [...] la grammaire du langage pour voir que nul booléen n'est créé à la volée.

Faisons donc ça : https://en.cppreference.com/w/cpp/language/if

Code:

attr(optional) if constexpr(optional) ( init-statement(optional) condition ) statement-true (1)
Citation:
condition - one of

expression which is contextually convertible to bool
declaration of a single non-array variable with a brace-or-equals initializer.
Citation:

If the condition yields true after conversion to bool, statement-true is executed.
28/09/2022, 10h45
Guesset
Bonjour Bktero,

Je crois que je vais abandonner :roll:.

Play it again Sam !
- statement-true est le statement qui est effectué si la proposition est vérifiée, cela ne suppose nullement pas qu'il y ait un booléen, on pourrait tout aussi bien l'appeler statement_then.
- "expression which is contextually convertible to bool" signifie juste qu'il doit pouvoir être converti en bool non qu'il l'est effectivement.
Je vais reprendre l'exemple (mal écrit mais lisible) de bool a = bool(int i) qui est en fait une forme de a = (i != 0) ? true : false; ou, en forme longue, if(i != 0) a = true; else a = false; .

Il y a toujours une comparaison implicite (== 0 ou !=0) ou explicite car la transformation d'un int en bool ne peut se faire autrement. Pour un être humain c'est pareil, si nous devons répondre par oui ou par non, nous allons comparer le critère à notre disposition à une valeur de référence. Dans un test, cette comparaison implicite existe même pour un booléen pour savoir quelle décision (branchement le plus souvent) prendre if(a) sera interprétée comme if(a == true) ou, un niveau en dessous, comme if(a != 0).

Si cette comparaison n'est pas possible, le test et une conversion vers un booléen ne sont pas possibles ou non pertinents. C'est ce qu'exprime l'explication "expression which is contextually convertible to bool", les critères de test et de conversion sont les mêmes (le test est nécessaire à la conversion, non l'inverse). D'où la confusion d'assimilation de l'un à l'autre.

Supposons un test if(i) statement_true; else statement_false; au lieu du cast i vers bool a. S'il y avait création d'un booléen caché a cela reviendrait à :
Code:

1 2 if(i != 0) a = true; else a = false; if(a != 0) statement_true; else statement_false;
On voit bien que c'est inutile puisque l'expression directe fonctionne :

Code:

if(i != 0) statement_true; else statement_false;

Il y a un cas où on peut provoquer la création de booléens cachés. Dans des tests complexes en désactivant le calcul abrégé des tests (parce qu'il transforme un test complexe en chaîne de tests simples). Il y a alors besoin de stockages intermédiaires de certains résultats partiels.

Je ne reviendrais pas sur ce sujet. Si penser qu'il y a des booléens cachés facilite l'écriture de code, alors qu'importe le flacon...:ave:

Salut