IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

Operateurs booleens donc logiques : )


Sujet :

C++

  1. #1
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut 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
    Le sens d'un Langage est d'exprimer des Concepts...

  2. #2
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    4 288
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 4 288
    Points : 9 720
    Points
    9 720
    Par défaut
    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

  3. #3
    Responsable Modération

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    1 204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 1 204
    Points : 4 522
    Points
    4 522
    Par défaut
    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

  4. #4
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    OUPS....

    Merci beaucoup
    j ai pris conscience que... je ne savais pas...
    Le sens d'un Langage est d'exprimer des Concepts...

  5. #5
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    852
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 852
    Points : 2 676
    Points
    2 676
    Par défaut 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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  6. #6
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    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...
    Le sens d'un Langage est d'exprimer des Concepts...

  7. #7
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    852
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 852
    Points : 2 676
    Points
    2 676
    Par défaut 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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  8. #8
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    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
    Le sens d'un Langage est d'exprimer des Concepts...

  9. #9
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juin 2009
    Messages
    4 441
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués

    Informations forums :
    Inscription : juin 2009
    Messages : 4 441
    Points : 13 499
    Points
    13 499
    Billets dans le blog
    1
    Par défaut
    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);
    }

  10. #10
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    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.
    Le sens d'un Langage est d'exprimer des Concepts...

  11. #11
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juin 2009
    Messages
    4 441
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués

    Informations forums :
    Inscription : juin 2009
    Messages : 4 441
    Points : 13 499
    Points
    13 499
    Billets dans le blog
    1
    Par défaut
    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.

  12. #12
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    852
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 852
    Points : 2 676
    Points
    2 676
    Par défaut Le retour du chicaneur
    Bonjour Bktero,

    Citation Envoyé par Bktero Voir le message
    ...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.
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  13. #13
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    4 288
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 4 288
    Points : 9 720
    Points
    9 720
    Par défaut
    Citation Envoyé par Guesset Voir le message
    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>.

  14. #14
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juin 2009
    Messages
    4 441
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués

    Informations forums :
    Inscription : juin 2009
    Messages : 4 441
    Points : 13 499
    Points
    13 499
    Billets dans le blog
    1
    Par défaut
    @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

  15. #15
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    852
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 852
    Points : 2 676
    Points
    2 676
    Par défaut Les booléens perdus
    Bonjour foetus,

    Citation Envoyé par foetus Voir le message
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  16. #16
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    852
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 852
    Points : 2 676
    Points
    2 676
    Par défaut
    Bonjour Bktero,

    Citation Envoyé par Bktero Voir le message
    ...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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  17. #17
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    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' ?
    Le sens d'un Langage est d'exprimer des Concepts...

  18. #18
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    au quel cas, pas besoin de 'cast'....
    Le sens d'un Langage est d'exprimer des Concepts...

  19. #19
    Expert éminent
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    1 450
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 1 450
    Points : 7 012
    Points
    7 012
    Par défaut
    Citation Envoyé par adiya Voir le message
    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 Voir le message
    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 Voir le message
    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

  20. #20
    Nouveau membre du Club Avatar de adiya
    Homme Profil pro
    auto didacte
    Inscrit en
    juillet 2016
    Messages
    65
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : auto didacte
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2016
    Messages : 65
    Points : 39
    Points
    39
    Par défaut
    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 ...
    Le sens d'un Langage est d'exprimer des Concepts...

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. operateur booleen de soustraction ?
    Par Zwiter dans le forum Débuter
    Réponses: 11
    Dernier message: 22/04/2009, 13h56
  2. Utilisation d'operateur booleen dans une requete
    Par olivier] dans le forum Langage SQL
    Réponses: 3
    Dernier message: 02/01/2006, 16h16
  3. Operateur booleens
    Par konrad dans le forum OpenGL
    Réponses: 1
    Dernier message: 10/11/2005, 11h27
  4. Opérateur logique
    Par webspeak dans le forum Linux
    Réponses: 3
    Dernier message: 07/11/2005, 18h19
  5. [langage] opérateur booleen
    Par louisis dans le forum Langage
    Réponses: 4
    Dernier message: 30/06/2004, 16h12

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo