Discussion :

[adiya]

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

[foetus]

C'est quoi la question ?

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
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 :

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

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

[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

[adiya]

OUPS....

Merci beaucoup
j ai pris conscience que... je ne savais pas...

[Guesset]

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

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

[Guesset]

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

[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

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

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

1
2
3
inline bool operator^(const Foo& lhs, const Foo& rhs) {
    return (lhs and not rhs) or (not lhs and rhs);
}

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

[Bktero]

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


Non, ça renvoie bien un entier :

Code :

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

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.

[Guesset]

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

[foetus]

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

C'est normal 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>.

[Bktero]

@Guesset :

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

[Guesset]

Bonjour foetus,

C'est normal 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

[Guesset]

Bonjour 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

[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' ?

[adiya]

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

[dalfab]

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.

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.

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 :

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

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

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