Confused by use of double logical not (!!) operator

Question

I have some C++ code that makes extensive use of !!. I'm kinda baffled because as far as I know !! is not a operator on it's own but two ! after each other. So that would mean that !!foo is the same as just foo.

Is there any place and or reason when !! actually makes sense? I was thinking about if it could perhaps have a bit wise meaning? So you first perform some bit wise operation on foo and then ! on the result? But I don't seem to remember ! being used as a bit wise operator and don't seem to find any reference telling me it is either. As far as I can tell ! in only used as a logical operator and in that case

!!foo == foo

Solution 1

It is not as simple as double negation. For example, if you have x == 5, and then apply two ! operators (!!x), it will become 1 - so, it is used for normalizing boolean values in {0, 1} range.

Note that you can use zero as boolean false, and non-zero for boolean true, but you might need to normalize your result into a 0 or 1, and that is when !! is useful.

It is the same as x != 0 ? 1 : 0.

Also, note that this will not be true if foo is not in {0, 1} set:

!!foo == foo

#include <iostream>

using namespace std;

int main()
{
        int foo = 5;

        if(foo == !!foo)
        {
                cout << "foo == !!foo" << endl;
        }
        else
        {
                cout << "foo != !!foo" << endl;
        }



        return 0;
}

Prints foo != !!foo.

Solution 2

It can be used as shorthand to turn foo into a boolean expression. You might want to turn a non-boolean expression into true or false exclusively for some reason.

foo = !!foo is going to turn foo into 1 if it's non-zero, and leave it at 0 if it already is.

Solution 3

if foo != 0, then !!foo == 1. It is basically a trick to convert to bool.

Solution 4

If foo is not of type bool, then !!foo will be. So !!foo can be 1 or 0.

Solution 5

This technique is used for an safe evaluation of an variable in an boolean context. If you have an normal conversation to bool (operator bool()) unrelated variables (with differnt types) can participate in boolean expressions in an unwanted way. A defintion of operator! which returns a negated boolean value is implemented. And its result has to be negated again. Simply have a look at the Safe bool idiom.

View more solutions