Pourquoi utiliser !! lors de la conversion de int bool?

Ce qui peut être une raison pour la conversion d'un nombre entier d'une valeur booléenne de cette façon?

bool booleanValue = !!integerValue;

au lieu de simplement

bool booleanValue = integerValue;

Tout ce que je sais, c'est que dans VC++7 ce dernier va provoquer C4800 avertissement et l'ancien ne sera pas. Est-il une autre différence entre les deux?

  • Après la double négation, la valeur est garantie 0 ou 1; la valeur d'origine pourrait être n'importe quelle valeur int.
  • Mais pourquoi la deuxième instruction de ne pas faire exactement la même chose?
  • Je suppose que la question est pourquoi les anciens ne cause pas un C4800 soit depuis même "le Casting de l'expression de type booléen ne sera pas désactiver l'avertissement, qui est par la conception." (MS)
  • pourquoi ne pas plus de gens de suggérer dans le fait que c'est la bonne réponse. double négatif est très commun dans le code bas-niveau
  • euh, en fait, cela a sa place... les gens sont confus C++ et de C
InformationsquelleAutor sharptooth | 2009-08-21
  1. 111

    Les problèmes avec les "!!" l'idiome qu'il est laconique, difficile à voir, facile à tort d'une faute de frappe, facile à déposer l'un de l' "!'s", et ainsi de suite. Je l'ai mis dans les "regardez comme c'est mignon que nous pouvons être avec C/C++" de la catégorie.

    Il suffit d'écrire bool isNonZero = (integerValue != 0); ... être clair.

    • +1 pour le "bool isNonZero = (integerValue != 0);". J'ai toujours déteste quand le code amalgame ints, des chambres doubles, ptrs, etc avec bool est. Ils sont de différents types et doit être traiter comme tel. L'implicite casting d'un booléen de type numérique est un anchronism.
    • Je ne vois pas le problème avec le traitement de l'ints/pointeurs comme bool - c'est un stock de C/C++ langage, et n'importe quel développeur maîtriser devrait le savoir. Cependant, parfois, vous voulez éviter les avertissements du compilateur et de tel - et dans ces cas, une expicit comparaison (ou fonte) est certainement de beaucoup préférable à la relativement obscur !! truc.
    • Entiers et les booléens sont différents. Pourquoi devrait-0 == false. C'est une gueule de bois de la de jours avant le type bool. Cela signifie aussi que !!un n'est pas nécessairement égal à un qui est contre-intuitif.
    • 0 est égal à faux parce que la norme dit 😉 !! est une jolie commune de l'idiome vous semblez juste pour être pas familier avec. Que doesn_t faire impérativement mauvais, sauf pour l'utiliser au début d'une phrase en langue naturelle.
    • Après plus de 20 ans de C/C++, je suis bien familiarisé avec le langage; je pense juste que c'est contre-intuitif!
    • +1 pour "regardez comme c'est mignon que nous pouvons être avec C/C++". Résume parfaitement tant de mauvaises pratiques de codage que le C/C++, la syntaxe et lâche règles permettent.
    • -1 pour "bool isNonZero = (integerValue != 0);", ce n'est ni plus lisible et plus "intuitive". Si vous n'aimez pas C/C++ standard idiomes aime !!, utiliser un langage différent.
    • dans ces cas, une expicit comparaison (ou fonte) est certainement de beaucoup préférable à la relativement obscur !! truc." apparemment, vous n'avez pas essayé de quoi vous parlez.
    • Je ne suis pas sûr de ce que tu veux dire. Réclamez-vous qu'il existe des cas où !!i est préférable de i != 0, ou quoi? Si oui, pouvez-vous donner un exemple?
    • je dis juste que votre demande est incorrect. il n'est pas le cas, "une comparaison explicite (ou fonte)" est de préférence !! wrt. "éviter les avertissements du compilateur et de tels", puisque le seul compilateur qui a tendance à mettre en garde sur la conversion, à savoir visual c++, n'est pas fermé par un plâtre, mais il est fermé par une !!. vous êtes donc factuellement faux. à l'égard de tous les jugements de valeur, comme "relativement obscur", eh bien, vous devez obtenir les faits techniques de droite avant d'être en mesure de faire des jugements de valeur.
    • Il est "enfermé" par une comparaison explicite, bien, donc pourquoi mon commentaire a dit "comparaison explicite ou cast". Et ma réponse n'était pas destiné à être VC-spécifiques, mais aussi de couvrir autant de terrain que possible - dans un autre compilateur qui se plaignaient de int-à-bool conversion implicite, d'un plâtre peut bien travailler (en effet, le fait qu'il y a un avertissement sur cast explicite dans VC, je considère personnellement comme un bug). En tout cas, tout cela est très non-pertinent pour le jugement de valeur en question, et je continue de tenir.
    • le fait que vous êtes en l'appelant un "truc" est une indication que vous ne pouvons pas le faire. La chose à propos de trucs, c'est qu'ils sont, par définition, difficile à comprendre. Pourquoi confondre votre code? Peut-être que chaque développeur C/C++ doit être si bien informé, mais tout le monde a à apprendre quelque part, pourquoi tromper les débutants? Pour enregistrer quelques traits de caractère?
    • J'ai fait référence plus spécifiquement à l'utilisation de !! comme un "truc" ci-dessus, pas de traitement de zéros et de pointeurs null et faux en C++. Ce dernier est, par conception, et est largement reconnue, comprise et pratiquée dans idiomatiques C++, donc il n'y a pas de problème de lisibilité lors de son utilisation (et il est en outre pris en charge par la bibliothèque standard, qui utilise vérité vérifie par exemple, dans un ruisseau). Le premier est en effet un obscur truc qui est vu très rarement.
    • peut-être zero parce que la norme dit, mais est 1 le meilleur choix à utiliser pour représenter true dans une forme entière, je serais tenté avec -1 sur la base que tous les bits set (n'est-ce pas) plutôt que de simplement le LSB - ou est-il une raison de ne pas le faire?

    InformationsquelleAutor user143506
  2. 49

    Historiquement, la !! idiome a été utilisé pour s'assurer que votre bool contient l'une des deux valeurs attendues dans un bool-comme variable, parce que le C et le C++ n'ont pas de vrai bool type et nous truqué avec ints. C'est moins un problème maintenant, avec de "vrais" bools.

    Mais en utilisant !! est un moyen efficace de documentation (pour le compilateur et à tous les futurs personnes qui travaillent dans votre code) que oui, vous avez vraiment a l'intention de lancer cette int à un bool.

    • Je ne dirais pas "un moyen efficace de la documentation" si l'OP n'a même pas comprendre ce que cela signifiait. Une bien meilleure façon serait static_cast<bool>(integerValue).
    • L'OP n'a probablement pas savoir ce que List<String> signifie au premier, que ce soit, ou ||=. !! est un très, très profondément enracinée dans l'idiome dans le C et le C++ univers. Si quelqu'un ne le sait pas, il/elle doit l'apprendre, et ensuite faire leur propre évaluation motivée sur l'opportunité de l'utiliser.
    • quel est le problème avec bool var = (bool)intVar; ?
    • Crowder: !! peut être efficace, mais c'est inefficace
    • Un "vrai" bool ont plus que deux valeurs? Par exemple, quel est le résultat de (bool)1 ^ (bool)2 Est à 0, ou 3?
    • static_cast<bool>(integerValue) est un avertissement dans VSCPP 2015 (v14). Si des avertissements sont des erreurs pour vous (ou votre code examinateur), vous êtes hors de la chance w/ que...
    • Le fait que c'est un avertissement dans Visual Studio. Se sent maladroit pour moi aussi... de ne pas obtenir beaucoup plus explicite que cela.
    • // bonus: auto foo = !!(10); // foo est bool, pas int!

    InformationsquelleAutor T.J. Crowder
  3. 14

    Il est utilisé parce que le langage C (et quelques pré-standard compilateurs C++ trop) n'a pas eu le bool type, juste int. Ainsi, le ints ont été utilisés pour représenter des valeurs logiques: 0 était censé signifier false, et tout le reste était true. Le ! opérateur était de retour 1 de 0 et 0 de tout le reste. Double ! a été utilisé pour inverser les, et il était là pour s'assurer que la valeur est juste 0 ou 1 en fonction de sa valeur logique.

    En C++, depuis l'adoption d'une bonne bool type, il n'y a pas besoin de faire cela. Mais vous ne pouvez pas simplement mettre à jour toutes les anciennes sources, et vous ne devriez pas avoir à, des raisons de compatibilité descendante de C à C++ (la plupart du temps). Mais beaucoup de gens le font encore, de la même raison: pour rester leur code en arrière-compatible avec les anciens compilateurs qui ne comprends toujours pas bools.

    Et c'est la seule vraie réponse. D'autres réponses sont trompeuses.

    • C'était clair. +1 🙂
    InformationsquelleAutor SasQ
  4. 13

    Parce que !integerValue signifie integerValue == 0 et!integerValue signifie donc integerValue != 0, une expression valide de retourner un booléen. Ce dernier est une fonte avec perte d'information.

    InformationsquelleAutor StampedeXV
  5. 6

    Une autre option est l'opérateur ternaire qui semble générer une ligne de moins de code assembleur (dans Visual Studio 2005, de toute façon):

    bool ternary_test = ( int_val == 0 ) ? false : true;

    qui produit le code assembleur:

    cmp DWORD PTR _int_val$[ebp], 0
setne   al
mov BYTE PTR _ternary_test$[ebp], al

    Contre:

    bool not_equal_test = ( int_val != 0 );

    qui produit:

    xor eax, eax
cmp DWORD PTR _int_val$[ebp], 0
setne   al
mov BYTE PTR _not_equal_test$[ebp], al

    Je sais que ce n'est pas une énorme différence, mais j'étais curieux à ce sujet et juste pensé que je voudrais partager mes découvertes.

    InformationsquelleAutor Brian
  6. 5

    Un booléen ne peut avoir que deux états, 0 et 1. Un entier peut avoir n'importe quel état de -2147483648 à 2147483647 en supposant un entier signé de 32 bits. Unaire ! opérateur de sorties 1 si l'entrée est 0 et sorties 0 si l'entrée est tout sauf 0. Afin de !0 = 1 et !234 = 0. Le deuxième ! passe simplement la sortie de sorte que 0 devient 1 et 1 devient 0.

    De sorte que la première déclaration des garanties que booleanValue sera égal à 0 ou 1 et aucune autre valeur, la deuxième déclaration n'est pas.

    • Ce qui est totalement faux. La deuxième déclaration implique implicitement int->bool exprimés. C'est bien définie, et zéro int seront convertis en true, et 0 seront convertis en false. L'avertissement que VC++ donne il est en fait un "avertissement sur les performances", et n'a rien à voir avec cela.
    • Je pense que vous confondez BOOL avec bool. Avec bool, vous obtenez un vrai bool avec un cast implicite, donc true ou false.
    • Les États d'un bool en C++ ne sont pas des 1 et des 0, mais le vrai et le faux.
    • Merci, je ne savais pas que. Je pensais que 0 == false et 1 == vrai, mais apparemment ce n'est pas de la sorte.
    • vous avez bien fait la première fois, jean-scipion, cela a sa place
    InformationsquelleAutor John Scipione
  7. 4

    !! est un idiomatiques façon de convertir bool, et cela fonctionne pour fermer le compilateur Visual C++ est sillywarning alléguée de l'inefficacité d'une telle conversion.

    Je vois d'ici les autres réponses et les commentaires que beaucoup de gens ne sont pas familiers avec cet idiome de l'utilité dans la programmation Windows. Ce qui signifie qu'ils n'ont pas fait de sérieux de la programmation sous Windows. Et d'assumer aveuglément que ce qu'ils ont rencontrés est représentatif (il ne l'est pas).

    #include <iostream>
using namespace std;

int main( int argc, char* argv[] )
{
    bool const b = static_cast< bool >( argc );
    (void) argv;
    (void) b;
}
    > [d:\dev\test] 
> cl foo.cpp 
foo.cpp 
foo.cpp(6) : avertissement C4800: 'int' : valeur forcée à la valeur booléenne "true" ou "false" (avertissement sur les performances) 

[d:\dev\test] 
> _

    Et au moins une personne pense que si une totale novice ne reconnaît pas son sens, alors c'est ungood. Eh bien, c'est stupide. Il y a beaucoup de choses que de proférer des novices de ne pas reconnaître ou comprendre. L'écriture d'un code de façon à ce qu'il sera entendu par une totale novice n'est pas quelque chose que pour les professionnels. Même pas pour les étudiants. Départ sur le chemin de l'exclusion des opérateurs et de l'opérateur combinaisons de proférer des novices ne reconnaissent pas... eh Bien je n'ai pas les mots pour donner à cette approche une description appropriée, désolé.

    Cheers & hth.,

    InformationsquelleAutor Cheers and hth. - Alf
  8. 1

    La réponse de user143506 est correct mais pour un possible problème de performances, j'ai comparé la possibilies en asm:

    return x;, return x != 0;, return !!x; et même return boolean_cast<bool>(x) résultats dans cette parfaite panoplie de l'asm instructions: 

    test    edi/ecx, edi/ecx
setne   al
ret

    Cela a été testé pour GCC 7.1 et MSVC 19 2017. (Seul le boolean_converter dans MSVC 19 2017 résultats dans une plus grande quantité de asm-code, mais cela est causé par templatization et les structures, et peuvent être négligés par le point de vue des performances, parce que les mêmes lignes comme indiqué ci-dessus peut juste dupliqué pour les différentes fonctions avec le même runtime.)

    Cela signifie: Il n'y a pas de différence de performances.

    PS: Ce boolean_cast a été utilisée:

    #define BOOL int
//primary template
template< class TargetT, class SourceT >
struct boolean_converter;

//full specialization
template< >
struct boolean_converter<bool, BOOL>
{
  static bool convert(BOOL b)
  {
    return b ? true : false;
  }
};

//Type your code here, or load an example.
template< class TargetT, class SourceT >
TargetT boolean_cast(SourceT b)
{
  typedef boolean_converter<TargetT, SourceT> converter_t;
  return converter_t::convert(b);
}

bool is_non_zero(int x) {
   return boolean_cast< bool >(x);
}
    InformationsquelleAutor kallitokaco
  9. -1

    Pas de grande raison si ce n'est être paranoïaque ou crier à l'aide de code que c'est un bool.

    pour le compilateur à la fin il l'habitude de faire la différence .

    • Le code généré peut bien être "plus lent": l'entier aura besoin d'un test pour voir si elle est égale à zéro. Cependant, pour une valeur booléenne qui est représentée comme 0 / 1 binaire, aucun test n'est nécessaire.
    • Mais bon, avec ce rationnelle, nous devrions avoir un avertissement de performance pour chaque appel de fonction virtuelle...
    • Vous voudrez peut-être lire que : stackoverflow.com/a/1847949/62921
    InformationsquelleAutor Learner
  10. -2

    Je n'ai jamais comme cette technique de la conversion en bool type de données - ça sent mauvais!

    Au lieu de cela, nous utilisons un modèle de pratique appelée boolean_cast trouvé ici. C'est une solution flexible qui est plus explicite dans ce qu'il fait et peut être utilisé comme suit:

    bool IsWindow = boolean_cast< bool >(::IsWindow(hWnd));
    • C'est un peu exagéré, n'est-ce pas? Je veux dire à la fin de la journée, la conversion en booléen est une perte de précision et se résume à quelque chose comme retour de b ? true : false; ce Qui est environ le même que !!VRAI pour moi, c'est overengineered STL-comme fétiche.
    • - Je prendre, vous n'êtes pas d'accord avec l'utilisation de boolean_cast ensuite (d'où la baisse de vote) - que suggérez-vous qu'on utilise alors?
    • Je vous suggère d'utiliser la langue comme il était censé être utilisé. De haute performance, et méchant. Il suffit de couper le BS et faire le travail.
    InformationsquelleAutor Alan