Peut deux booléens être comparé au C++?

Est le morceau de code suivant censé fonctionner?

bool b1 = true;
bool b2 = 1 < 2;
if (b1 == b2)
{
//do something
}

Je soupçonne que tous les "trues" sont égaux.

  • Êtes-vous ce qui implique que vous avez testé ce code et le "// faire quelque chose", la partie n'a pas été exécuté?
  • quelle doit être la différence entre le vrai et le vrai être?
  • Oui, bien sûr 🙂 Mon scénario est un peu plus compliqué, mais en principe, oui. (Peut-être que j'ai fait quelque chose de mal, mais reécriture == résolu mon problème).
  • Je me doutais bien que vrai, c'est juste toute différente de zéro (peut-être une certaine optimisation du compilateur?). Comme en C.
  • Si vous convertissez true à un nombre entier, il est 1. Si vous convertir un nombre entier en un booléen, une valeur autre que zéro est true.
  • La différence a été causé par le "plus compliqué", pas par la version simplifiée que vous avez posté.
  • true == static_cast<bool>(2) mais vrai != 2. C'était peut-être la différence.
  • Dans mon code, il n'y avait pas de débris. Un booléen est a partir de la variable booléenne, l'autre à partir de l'appelant inline fonction booléenne qui contenait de l'or au niveau du bit & comme ceci: bool test() { return (x & 2) != 0; }. Donc soit je fait une erreur vraiment stupide que je n'ai pas vu ou le compilateur fait un peu bizarre d'optimisation. L'ancien est beaucoup plus probable :-).

InformationsquelleAutor danatel | 2010-02-03
  1. 19

    Oui. Tous les trues sont égaux.

    • Eh bien, qu'ils sont égaux autant que == est concerné. À moins que le programmeur a fait quelque chose comme override operator== toujours y revenir false. Puisque rien dans la question est un objet, ce ne sera pas le cas.
    • D. Même si nous avons des objets, en remplaçant l'opérateur==, de sorte qu'elle renvoie toujours false ne semble pas très intuitif technique pour moi.
    • Je vais poser la barre sur cette réponse: tous les falses sont tout aussi fausse.
    • En fait, vous avez abaissé la barre. Parce que falses ont été toujours égale, même en C.
    • Le complet règle serait: "Tous les trues sont égaux. Tous les falses sont égaux. Tous les trues sont tout aussi vrai. Tous les falses sont tout aussi fausse. Enfin, la vraie est différent de false".
    • Je suis en désaccord. Il a haussé la barre en ce qu'il ajoute les informations de ma réponse. C est dans une langue différente.
    • Je ne pense pas que (void *) 0, 0, et 0.0 sont tous égaux, mais ils sont tous faux dans C.
    • Je le sais, mais j'ai vu suffisamment d'abus de la surcharge d'opérateur que je peux comprendre (mais pas d'accord avec) ceux qui préfèrent bannir la surcharge d'opérateur. Personnellement, j'utilise le complex modèle beaucoup, donc je préfère le garder.

    InformationsquelleAutor Daniel Daranas
  2. 11

    Oui, des valeurs booléennes ne peut stocker que de vrai ou de faux, et vous pouvez comparer les valeurs de l'égalité.

    Cependant, certains de mauvais usages de bool variables peut conduire à des "non défini" les comportements et pourrait regarder comme si il n'est ni vrai ni faux. Par exemple la lecture de la valeur d'un non initialisée variable automatique ou direct à la mémoire copier à partir de nombres entiers.

    Prendre un coup d'oeil à la suite de (mauvais) exemple:

      bool b1 = true; 
  bool b2 = true; 
  *((char*)&b1) = 3;

  if( b1 ) cout << "b1 is true" << endl;
  if( b2 ) cout << "b2 is true" << endl;
  if (b1 != b2) cout << "b2 is not equal to b1" << endl;

    Sur Visual Studio 9, il montre:

    b1 est vrai

    b2 est vrai

    b2 n'est pas égal à b1

    Probablement, parce que le compilateur a comparer directement les valeurs stockées.

    • Je ne peux pas imaginer quelqu'un a jamais contorting la langue dans la voie que vous avez dans la ligne 3. C'est une déclaration bizarre. Non pas que votre point de n'en sont pas moins valables...
    • Techniquement, le comportement indéfini vient de la mauvaise utilisation d'une fonte, pas d'un booléen.
    • Oui, je suis d'accord que la ligne 3 n'est pas "réel" du code. C'était un court exemple pour démontrer que la phrase: "tous les" trues "sont égaux" peut être vrai.
    • Mappés en mémoire des structures. Assez commun en programmation C/C++.
    InformationsquelleAutor J. Calleja
  3. 7

    Oui, comme d'autres l'ont dit booléens peuvent être comparés pour l'égalité en C++. Vous pouvez peut-être penser à des choses que vous avez entendu de C. Puisque C n'a pas de type bool, les booléens sont représentés par des entiers. Dans un contexte booléen tout entière non nulle est vraie. Cependant, ils peuvent avoir différents modèles de bits et donc de ne pas être égal. Donc la règle dans C n'était pas comparer "les booléens'.

    Edit: par commentaires, C99 a un type bool. Toutefois, le point de la réponse a été pour indiquer pourquoi l'idée de ne pas comparer bool est flottant autour. Il est basé sur la longue histoire de C, avant C99.

    • Négatif. C99 introduit #include <stdbool.h> en.wikipedia.org/wiki/Stdbool.h et true == (bool)3 C lorsque cela est inclus.
    • Assurez-vous, et vous devez être à l'aide de C99 avec un en-tête spécial pour avoir un vrai type bool. C'est un pas en avant, mais pas complètement.
    InformationsquelleAutor Steve Fallows
  4. 2

    Lorsque vous affectez une partie intégrante de la valeur à un objet boolean (ou d'initialiser un objet boolean avec une partie intégrante de la valeur), il est implicitement converti en true ou false par une norme conversion booléenne (4.12). Donc, à partir de la langue du point de vue, votre 1 et 2 ont disparu sans laisser de trace long avant même de faire la comparaison. Ils sont devenus très à la même true. Il n'y a pas de "tous les trues sont égaux" question ici. Il n'y a qu'un true.

    Bien sûr, certains compilateur peut probablement prendre un "paresseux" approche et de conserver plusieurs différents "trues" autour de, faire en sorte que "tous sont égaux" au moment de la comparaison et, mais je doute que cela soit raisonnable/approche viable.

    En d'autres termes, dans une mise en œuvre raisonnable que vous devriez vous attendre non seulement une comparaison valable, mais beaucoup plus en comparaison à être vrai:

    bool b1 = true; 
bool b2 = 1 < 2;
if (memcmp(&b1, &b2, sizeof(bool)) == 0) {
  /* We should get in here */
}

    Ce n'est pas garanti par la langue, mais dans la vraie vie, il n'décrire le côté physique de la situation tout à fait bien.

    InformationsquelleAutor AnT
  5. 1

    En C avec ints, vous pourriez avoir un point (bien que même là, je pense que cette séquence particulière devrait être OK). En C++, oui, c'est sûr.

    InformationsquelleAutor T.E.D.
  6. 1

    En C++, bool est son propre type, avec les deux valeurs possibles true et false. Toutes les comparaisons se passera comme prévu. Tous les true valeurs booléennes sont la même chose, et de même avec tous les false. Il est vrai que pas toutes les expressions que vous pouvez évaluer à true ou false sont les mêmes.

    En C89, pour aller aussi loin que je veux, tout zéro de la valeur (d'une aiguille ou de type numérique) est faux, et tout le reste est vrai. Cela signifie que les vraies valeurs ne sont pas nécessairement égaux les uns aux autres. 1 et 2 sont les vraies valeurs, mais 1 != 2, et 1 & 2 prend la valeur 0, ce qui est faux.

    Il est également possible pour C89 de fausses valeurs, de ne pas comparer l'égalité, mais il y en aura sur chaque application que j'ai jamais utilisé. Une valeur de pointeur null est une constante intégrale zéro en fonte pour une valeur de pointeur. Il est possible pour un non-valeur de la constante 0 exprimés pour une valeur de pointeur de ne pas être un pointeur null (et il y a eu des systèmes où les pointeurs null n'étaient pas tous les bits à 0). Par conséquent, (void *)0 est une valeur de pointeur null, et donc faux, mais int i;...i = 0;...(void *)i pourrait ne pas être une valeur de pointeur null, et n'est donc pas faux.

    Cependant, en C89, toutes les opérations qui ont l'intention de retourner une valeur booléenne (comme && ou ==, par exemple), renvoie 1 ou 0, de sorte que (1 == 3) == (4 ==3).

    InformationsquelleAutor David Thornley
  7. 0

    Les problèmes ne sont que lorsque vous vous habituez à la non-zéro pour être vrai et oubliez pas que tous les non-zéros sont égaux.

    Imaginez ceci:

    Vous avez une fonction keyPressed() renvoie 0 sur aucune touche, le numéro de la clé lorsqu'une touche est enfoncée.

    Vous avez écrit un simple switch dans une boucle:

    if(keyPressed() && allow)
...

    Maintenant votre entreprise introduit normalement ouvert déclenche dans les appareils et vous avez besoin d'une pref.

    bool key_switches_on = getPref("KeySwitchesOn");

if((keyPressed() && allow) == key_switches_on)
...

    Ensuite, vous remarquez "autoriser" est mal placé...

    if((keyPressed() == key_switches_on) && allow)

    et tout à coup, seule la touche numéro 1 des œuvres.

    InformationsquelleAutor SF.
  8. 0

    Je viens de lire toutes ces réponses sur le pourquoi de vrai est vrai et pourquoi deux variables booléennes peuvent être comparées en utilisant == ou != sauf dans les rares cas où un nombre entier est contraint à être un bool ou quelque chose de ce genre. Cependant, j'ai exactement le même problème que l'affiche originale. J'ai deux variables booléennes, chaque de ce qui est "vrai", mais quand je compare, je trouve qu'ils ne sont pas égaux. Voici la ligne de code,

    if (angDegDiff > 15 || scaleRatioA > 5 || scaleRatioB < -5 || (isParallel2 != isParallel1))
    {
    return false;
    }

    Dans mon exemple, angDegDiff = 0, scaleRatioA = 0, scaleRatioB = 0, isParallel2 = true, et isParallel1 = true. Encore, la déclaration donne true et la seule façon pour que cela se produise est si isParallel2 n'est pas égal à isParallel1.

    Pas de fantaisie méthodes sont utilisées pour définir les valeurs de isParallel1 ou isParallel2. Leurs valeurs sont définies par une instruction telle que _isParallel = true;. Plus tard, cette valeur est copiée dans une autre variable à l'aide d'une instruction telle que isParallel1 = geom1->IsParallel(); qui est mis en œuvre comme return _isParallel;.

    Ma conclusion est que, selon le compilateur, deux variables booléennes ne peut pas être déterminée de façon fiable par rapport à l'égalité. Je suis l'aide de Microsoft Visual C++ 2005, Version 8.0.50727.4039.

    Épilogue: j'ai remplacé le booléen comparaison dans mon code avec l'expression, ((isParallel1 && !isParallel2) || (!isParallel1 && isParallel2)) et maintenant tout fonctionne très bien.

    InformationsquelleAutor Darrell