C++ tidbit #3: Contextual Conversion

Warmup: explicit constructors

When you mark a cast operator as explicit:

struct C {

   explicit operator bool() { return true; }

};        

(yes, that is a silly implementation) you're saying that implicit casts will fail to compile:

bool b1 = c;                     // error

bool b2 = c==true;               // error

bool b3 = static_cast<bool>(c);  // explicit cast - success        

This is generally considered a good practice, as implicit casts are a gaping hole in C++ strong-type system. If, for example, you passed a wrong argument to a function - you want the compiler to err and help you catch it, and not implicit-cast to hide away the source of the error and sneak up on you in surprising ways later.

Some Surprises

So, what happened in the 2nd line here?

if (c == true) {}    // compilation error, as expected

if (c)  {}           // success ?!        

And here??

while(c) {}                // success !?

for (int i=0; c ; ++i) {}  // success !?!        

And, oh my, here?

bool b4 = c || false         // success !!?

bool b5 = c ? true : false;  // success !??!        

No explicit casts are anywhere to be seen. Shouldn't all these implicit casts be forbidden??

You can fiddle with this live code in various compilers here .

Enter Contextual Conversion

`bool` is special.

There are specific locations within the C++ syntax that require a bool type. In all the surprise-success cases above, `c` appears in such a place (go check!).

In these places a slightly different set of rules kicks in, and the term employed is contextual conversion (not casting!) to bool. In a nutshell: existing cast-operators to bool are considered, with `explicit` ignored. Details and some delicate diffs between C++ versions here .

Final Musing

This is a fine example of a good intention on the road to hell. Sometime during C++'s evolution, its designers wished to provide this convenience to developers - and not have them type out casts to bool where it would seem clear from the context that such a cast must be present.

I would happily trade the extra head-scratches this had caused me for some extra typing and reading. The same goes for many, many other C++ dark corners too. Some modern languages (notably Rust) learnt that lesson well, and allow no implicit casting of any kind.