C'est l'opération “false < true” bien définis?

Le C++ spécification de définir:

l'existence de la "moins que" l'opérateur pour les paramètres booléens, et, dans l'affirmative,
le résultat de l'4 paramètre de permutations?

En d'autres mots, ce sont les résultats de ces opérations définies par le cahier des charges?

false < false
false < true
true < false
true < true

Sur ma configuration (Centos 7, gcc 4.8.2) , le code ci-dessous crache ce que j'avais prévu (donnée C de l'histoire de l'représente false 0 et vrai 1):

false < false = false
false < true = true
true < false = false
true < true = false

Alors que je suis sûr que la plupart (tous?) les compilateurs donnera le même résultat, est-ce la loi, par le C++ cahier des charges? Ou est abrutissant, mais la spécification conforme compilateur autorisé à décider que le vrai est moins faux?

#include <iostream>

const char * s(bool a)
{
  return (a ? "true" : "false");
}

void test(bool a, bool b)
{
  std::cout << s(a) << " < " << s(b) << " = " << s(a < b) << std::endl;
}

int main(int argc, char* argv[])
{
  test(false, false);
  test(false, true);
  test(true, false);
  test(true, true);
  return 0;
}

g++-4.9.0 et clang++-3.5.0 sur Linux pense que c'est banal: coliru.stacked-crooked.com/a/2174ebc466d0c445
Il y a des utilisations valides. Comme l'utilisation de std::min sur std::vector<bool> comme &&.
si vous pouvez trouver une bonne question qui n'a pas encore été demandé après toutes ces années de StackOverflow, vous méritez un peu de points. Ce n'est pas à la traîne.
La motivation pour la poser est authentique: je suis assez novice en C++ (en provenance de la C) et que vous souhaitez stocker des objets dans un std::set<>. Ma mise en œuvre de mon objet < opérateur est principalement basée sur une propriété booléenne de l'objet, suivi par d'autres secondaires d'identifier les propriétés. Lors d'une itération sur l'ensemble, je veux être sûr que le "faux" objets viennent en premier. Alors qu'il travaille pour moi, ici et maintenant, je suis à la recherche de réconfort, il est garanti de fonctionner sur les plates-formes (y compris ceux intégrés), sans avoir à recourir inutilement à l'utilisation des (un ? 1 : 0), ou similaire, dans mon objet < opérateur.
Une fâcheuse conséquence est que p <= q signifie p implies q quand p et q sont de type bool!
Je ne suis pas clair sur ce que vous trouver inquiétant à ce sujet. Pourriez-vous en dire un peu plus?
Sans doute ce qui est troublant, c'est que <= peut-être par inadvertance, se lire comme un leftarrow, et que le "seulement si" (c'est à dire, "[matériellement] implique") rightarrow est parfois composées à la main ou de manière informelle, écrit de la même façon à => (c'est à dire, avec un doublé de l'arbre ressemblant à =). Un leftarrow est même parfois lire que "si," si je crois que c'est bien moins courante que l'utilisation d'un rightarrow pour "seulement si".
Exactement comme Elie dit. p <= q ressemble q implique p, mais, en fait, signifie p implique q.
Être très prudent avec ce que si vous interagissez avec les COM et/ou Sql Server, parfois ils définissent vrai que -1.
Apparemment, il est bien définie. C'est un peu triste. Comme une langue en s'efforçant trop dur d'être populaire. Il est peut-être une commodité pour "commander" le vrai et le faux, il est logiquement absurde. Donc, si vous commandez le vrai et le faux est un facteur de conception dans un modèle, l'OMI, l'auteur devrait être forcé de choisir la commande explicitement. Heck, la prochaine étape pourrait être faux ou vrai est moins vrai ou vrai - parce que deux vrais battements un vrai.
"est-ce que la loi, par le C++..." j'espère bien que les programmes ne pas commencer à écrire les lois...
de nombreux compilateurs ont des extensions qui ne font pas partie de la norme. Il y a aussi des zones où la norme déclare que le comportement est définie par l'implémentation(différent de comportement indéfini) qui signifie qu'elle peut varier d'un compilateur de compilateur et encore autorisé par la norme. Si cette distinction est importante, et ce type de question permet souvent une langue de l'avocat question.

InformationsquelleAutor duncan | 2014-10-01

boolean c++comparison-operators language-lawyer

206

TL;DR:

Les opérations sont bien définis, selon le projet de norme C++.

Détails

Nous pouvons voir qu'en allant à la projet de norme C++ section 5.9 opérateurs Relationnels qui dit (accent mine d'aller de l'avant):

La opérandes ont arithmétique, énumération, ou un pointeur type, ou de type std::nullptr_t. Les opérateurs
< (moins de), > (supérieur à), <= (inférieur ou égal), et >= (supérieur ou égal à) tous rendement
faux ou vrai. Le type du résultat est bool

et bool sont arithematic types de 3.9.1 types Fondamentaux

Types bool, char, char16_t, char32_t, wchar_t, et les entiers signés et non signés types d'entiers sont collectivement
appelé les types intégraux.

et

Intégral et les types flottants sont collectivement appelés arithmétique
les types.

et true et false sont littéraux booléens de 2.14.6 littéraux Booléens:
```
boolean-literal:
    false
    true
```
Aller retour à la section 5.9 de voir la mécanique des opérateurs relationnels plus loin, il dit:

L'habitude de l'arithmétique conversions sont effectuées sur des opérandes de l'arithmétique ou de type énumération.

la d'habitude arithmétique des conversions sont couverts dans la section 5 qui dit:

Sinon, l'intégrale des promotions (4.5) doit être effectuée sur les deux opérandes

et de l'article 4.5 dit:

Un prvalue de type booléen peut être converti en prvalue de type int, avec de faux en devenant zéro et vrai
devenir un.

et de sorte que les expressions:
```
false < false
false < true
true < false
true < true
```
à l'aide de ces règles deviennent:
```
0 < 0
0 < 1
1 < 0
1 < 1
```
- Nice, c'est aussi explicite que toute réponse qui pourrait éventuellement être, tout en restant facile à lire. Un nit: je pense que vous en caractères gras le mauvais "type": "opérandes ont arithmétique, énumération, ou un pointeur type, ou de type std::nullptr_t." L'ajout de parenthèses pour plus de clarté donne ((l'arithmétique, de l'énumération, ou un pointeur) type) ou (de type std::nullptr_t).
- bonne prise, fixe!
- Non pas qu'il change votre réponse, mais N3485 [plus.construit]/12: Pour chaque paire de promu arithmétique types L et R, il existe candidat de l'opérateur fonctions de la forme ... bool opérateur<(L , R ); - ne Sont pas les arguments promu avant les règles que vous citez, même s'appliquer?
- Je ne suis pas super familier avec cet article que j'aurais à y réfléchir, mais je ne pense pas que la réponse change de ce que je peux voir.
- Ouais, la promotion est la première chose à se produire de toute façon.
InformationsquelleAutor Shafik Yaghmour
63

Valeurs booléennes sont soumis à la entier promotions, avec false défini comme 0 et true défini comme 1. Qui rend toutes les comparaisons bien définis.
- ...et les opérateurs relationnels sont spécifiés pour effectuer l'habitude de l'arithmétique des conversions (qui comprend entier promotions) sur des opérandes de l'arithmétique ou de type énumération.
- J'aime que cette réponse est plus court que Shafik, mais je pense que le point clé que false est défini comme 0 et true est défini comme 1 standard (plutôt que par la pratique courante) a besoin de preuves à l'appui.
- quoi, vous n'allez pas prendre mon mot pour lui? 🙂 Avant il y avait un bool type, avant même que le C++, le résultat d'une opération booléenne a été définie comme 0 pour faux et 1 pour de vrai. Je ne serais pas surpris si vous pouvez le trouver en K+R.
- hein, pour une raison que je pensais que C était bool depuis le début (même si je me rends compte 0 et 1 ont été utilisés avant bool existait précédemment dans des langues). Mais ensuite, j'ai seulement tellement que vu K+R code une fois dans ma vie, donc mes connaissances dans cette histoire, c'est suspect.
- Je ne peux pas revenir en arrière aussi loin que les K+R, mais j'ai creusé ma copie de l'1990 C ANSI Standard. Section 6.3.8 dit "Chacun des opérateurs < (moins de), > (plus grand que), <= (inférieur ou égal), et >= (supérieur ou égal à) donnera 1 si la relation est vraie et 0 si elle est fausse. Le résultat est de type int."
- Le plus gros problème de l'IIRC est que dans le K&R, enum bool { false = 0, true = 1} était légal, mais n'en est pas de définir un operator<.
InformationsquelleAutor Mark Ransom
22

Selon la Norme C++ (5.9 opérateurs Relationnels)

2 de L'habitude de l'arithmétique conversions sont effectuées sur des opérandes de
l'arithmétique ou de type énumération.

et

1...Le type du résultat est bool.

et (3.9.1 types Fondamentaux)

6 Valeurs de type booléen sont vraies ou fausses.49 [ Note: Il n'y a pas
signé, non signé, à court ou à long bool types ou des valeurs. —la note de fin ]
Valeurs de type booléen participer à partie intégrante des promotions (4.5).

et (4.5 Intégrale promotions)

6 Un prvalue de type booléen peut être converti en prvalue de type int,
avec faux devenant zéro et devenir un vrai.

Donc, dans tous les exemples vrai est converti en int 1 et false est converti en int 0

Ces expressions
```
false < false
false < true
true < false
true < true
```
sont entièrement équivalentes à
```
0 < 0
0 < 1
1 < 0
1 < 1
```
InformationsquelleAutor Vlad from Moscow
8

Boolean false est équivalent à int 0, et boolean true est équivalent à int 1.
C'est ce qui explique pourquoi l'expression false < true => 0 < 1 est la seule qui renvoie true.

InformationsquelleAutor Blindstealer

Vous devez vous connecter pour publier un commentaire.