Double négation en C ++

Je viens juste d'arriver sur un projet avec une base de code assez énorme.

Je travaille principalement avec C ++ et une grande partie du code qu'ils écrivent utilise la double négation pour leur logique booléenne.

 if (!!variable && (!!api.lookup("some-string"))) {
       do_some_stuff();
 }                                   

Je sais que ces types sont des programmeurs intelligents, il est évident qu'ils ne le font pas par accident.

Je ne suis pas un expert C ++ chevronné, ma seule estimation de la raison pour laquelle ils font cela est qu'ils veulent s'assurer que la valeur évaluée est la représentation booléenne réelle. Alors ils le nient, puis le nient à nouveau pour le ramener à sa valeur booléenne réelle.

Est-ce correct ou est-ce que je manque quelque chose?

C'est une astuce pour convertir en booléen.

C'est en fait un idiome très utile dans certains contextes. Prenez ces macros (exemple du noyau Linux). Pour GCC, ils sont implémentés comme suit:

#define likely(cond)   (__builtin_expect(!!(cond), 1))
#define unlikely(cond) (__builtin_expect(!!(cond), 0))

Pourquoi doivent-ils faire cela? GCC __builtin_expecttraite ses paramètres comme longet non bool, il doit donc y avoir une forme de conversion. Comme ils ne savent pas ce que condc'est quand ils écrivent ces macros, il est plus général d'utiliser simplement l' !!idiome.

Ils pourraient probablement faire la même chose en comparant avec 0, mais à mon avis, il est en fait plus simple de faire la double négation, car c'est le plus proche d'un cast-to-bool que C a.

Ce code peut également être utilisé en C ++ ... c'est une chose au plus petit dénominateur commun. Si possible, faites ce qui fonctionne à la fois en C et C ++.

Les codeurs pensent qu'il convertira l'opérande en booléen, mais comme les opérandes de && sont déjà implicitement convertis en booléen, il est totalement redondant.

C'est une technique pour éviter d'écrire (variable! = 0) - c'est-à-dire pour convertir de quelque type que ce soit en booléen.

Un code IMO comme celui-ci n'a pas sa place dans les systèmes qui doivent être maintenus - car ce n'est pas un code immédiatement lisible (d'où la question en premier lieu).

Le code doit être lisible - sinon vous laissez un héritage de dette temporelle pour l'avenir - car il faut du temps pour comprendre quelque chose qui est inutilement alambiqué.

Oui c'est correct et non vous ne manquez pas quelque chose. !!est une conversion en booléen. Voir cette question pour plus de discussion.

Il évite un avertissement du compilateur. Essaye ça:

int _tmain(int argc, _TCHAR* argv[])
{
    int foo = 5;
    bool bar = foo;
    bool baz = !!foo;
    return 0;
}

La ligne 'bar' génère une «valeur de forçage à booléen 'true' ou 'false' (avertissement de performance)» sur MSVC ++, mais la ligne 'baz' se faufile très bien.

Est opérateur! surchargé?
Sinon, ils le font probablement pour convertir la variable en booléen sans produire d'avertissement. Ce n'est certainement pas une manière standard de faire les choses.

Les développeurs C avaient hérité aucun type Boolean, ils souvent #define TRUE 1et #define FALSE 0puis utiliser les types de données numériques arbitraires pour des comparaisons booléennes. Maintenant que nous l'avons fait bool, de nombreux compilateurs émettront des avertissements lorsque certains types d'affectations et de comparaisons sont effectués en utilisant un mélange de types numériques et de types booléens. Ces deux usages finiront par entrer en conflit lorsque vous travaillez avec du code hérité.

Pour contourner ce problème, certains développeurs utilisent l'identité booléenne suivante: !num_valuerenvoie bool trueif num_value == 0; falseautrement. !!num_valuerenvoie bool falsesi num_value == 0; trueautrement. La négation seule est suffisante pour convertir num_valueà bool; cependant, la double négation est nécessaire pour restaurer le sens original de l'expression booléenne.

Ce modèle est connu comme un idiome , c'est-à-dire quelque chose de communément utilisé par des personnes familières avec la langue. Par conséquent, je ne le vois pas comme un anti-modèle, autant que je le voudrais static_cast<bool>(num_value). La distribution pourrait très bien donner les résultats corrects, mais certains compilateurs émettent alors un avertissement de performances, vous devez donc toujours résoudre ce problème.

L'autre façon d'aborder c'est - à - dire (num_value != FALSE). Je suis d'accord avec cela aussi, mais dans l'ensemble, !!num_valuec'est beaucoup moins verbeux, peut-être plus clair et ne prête pas à confusion la deuxième fois que vous le voyez.

!! a été utilisé pour gérer le C ++ original qui n'avait pas de type booléen (comme le C).

Exemple de problème:

À l'intérieur if(condition), les conditionbesoins d'évaluer à un type comme double, int, void*, etc., mais pas boolcar il n'existe pas encore.

Supposons qu'une classe existe int256(un entier de 256 bits) et que toutes les conversions / transtypages d'entiers ont été surchargés.

int256 x = foo();
if (x) ...

Pour tester si xétait "vrai" ou non nul, if (x)convertirait xen un entier et ensuite évaluer si ce intn'était pas zéro. Une surcharge typique de (int) xrenverrait uniquement les LSbits de x. if (x)testait alors uniquement les LSbits de x.

Mais C ++ a l' !opérateur. Un surchargé !xévaluerait généralement tous les bits de x. Donc, pour revenir à la logique non inversée if (!!x)est utilisé.

Ref Les anciennes versions de C ++ utilisaient-elles l'opérateur `int` d'une classe lors de l'évaluation de la condition dans une instruction` if () `?

Comme Marcin l'a mentionné, cela pourrait bien avoir une importance si la surcharge des opérateurs est en jeu. Sinon, en C / C ++, cela n'a pas d'importance sauf si vous faites l'une des choses suivantes:

• comparaison directe avec true(ou en C quelque chose comme une TRUEmacro), ce qui est presque toujours une mauvaise idée. Par exemple:

  if (api.lookup("some-string") == true) {...}

• vous voulez simplement quelque chose converti en une valeur stricte 0/1. En C ++, une affectation à a le boolfera implicitement (pour les choses qui sont implicitement convertibles en bool). En C ou si vous avez affaire à une variable non booléenne, c'est un idiome que j'ai vu, mais je préfère la (some_variable != 0)variété moi-même.

Je pense que dans le contexte d'une expression booléenne plus large, cela encombre simplement les choses.

Si la variable est de type objet, elle peut avoir un! opérateur défini mais pas de conversion en bool (ou pire, une conversion implicite en int avec une sémantique différente. L'appel de l'opérateur! deux fois entraîne une conversion en bool qui fonctionne même dans des cas étranges.

C'est correct mais, en C, inutile ici - 'if' et '&&' traiteraient l'expression de la même manière sans le '!!'.

La raison de faire cela en C ++, je suppose, est que «&&» pourrait être surchargé. Mais alors, '!' Pourrait l'être aussi, donc cela ne garantit pas vraiment que vous obteniez un booléen, sans regarder le code pour les types de variableet api.call. Peut-être que quelqu'un avec plus d'expérience C ++ pourrait expliquer; il s'agit peut-être d'une sorte de mesure de défense en profondeur, et non d'une garantie.

Peut-être que les programmeurs pensaient à quelque chose comme ça ...

!! myAnswer est booléen. Dans le contexte, cela devrait devenir booléen, mais j'adore tout faire pour être sûr, car il était une fois un bug mystérieux qui m'a mordu, et bang bang, je l'ai tué.

Cela peut être un exemple de l' astuce du double bang , voir The Safe Bool Idiom pour plus de détails. Ici, je résume la première page de l'article.

En C ++, il existe plusieurs façons de fournir des tests booléens pour les classes.

Un moyen évident est l' operator boolopérateur de conversion.

// operator bool version
  class Testable {
    bool ok_;
  public:
    explicit Testable(bool b=true):ok_(b) {}

    operator bool() const { // use bool conversion operator
      return ok_;
    }
  };

Nous pouvons tester la classe,

Testable test;
  if (test) 
    std::cout << "Yes, test is working!\n";
  else 
    std::cout << "No, test is not working!\n";

Cependant, opereator boolest considéré comme dangereux car il permet des opérations absurdes telles que test << 1;ou int i=test.

L'utilisation operator!est plus sûre car nous évitons les problèmes de conversion implicite ou de surcharge.

La mise en œuvre est triviale,

bool operator!() const { // use operator!
    return !ok_;
  }

Les deux manières idiomatiques de tester un Testableobjet sont

  Testable test;
  if (!!test) 
    std::cout << "Yes, test is working!\n";
  if (!test2) {
    std::cout << "No, test2 is not working!\n";

La première version if (!!test)est ce que certains appellent le truc du double bang .