I thought you were going to give up on this
bool b = 500;
works because there is an implicit, compiler-supplied conversion from type int (and all its siblings) to type bool. What you are really entering when you type the above line is
bool b = static_cast<bool>(500);
The bool type is fine, its the implicit conversion you disdain.
Which I find interesting, to say the least, because in the you have defended C's implicit conversions and promotions.
Actually, what I am really typing is what I really typed - which is stupid and ought not to be allowed. It looks like C++ has been taking lessons from Clippy.
I don't object to C's conversions because they are (mostly) sensible. When mixed mode operations are encountered, the types are "promoted" to prevent loss of precision. The promotion rules are simple and comprehensible.
C++ takes an extreme approach to type conversion which is the source of many many surprises and bugs (the construction of temporaries and such). In practice, this has made it nearly impossible to write predictable code.
I also find the behavior inconsistent with how enum's work. You can do this:
enum Traffic { RED, YELLOW, GREEN };
Traffic aTraffic = (Traffic) 7;
cout << aTraffic << endl; // this will print 7
There's no value clamping here (and thus no inadvertent loss of information).
Finally, your comparisons with C are falling flat. C is weakly typed. C++ is meant to be strongly typed (which is why we have 5 kinds of cast operator). But its only *sometimes* strongly typed.
Rule number 1 - never surprise the programmer.
Unfortunately, C++'s rule seems to be *always* surprise the programmer.
(Edit - clippy bit)
