First, it is functionally similar to a tristate boolean (false, maybe,
true) —such as boost::tribool—
except that in a tristate boolean, the maybe state represents
a valid value, unlike the corresponding state of an uninitialized
optional<bool>.
It should be carefully considered if an optional<bool> instead of a tribool
is really needed.

Second, although optional<> provides a contextual conversion
to bool in C++11, this falls
back to an implicit conversion on older compilers. This conversion refers
to the initialization state and not to the contained value. Using optional<bool>
can lead to subtle errors due to the implicit bool
conversion:

voidfoo(boolv);voidbar(){optional<bool>v=try();// The following intended to pass the value of 'v' to foo():foo(v);// But instead, the initialization state is passed// due to a typo: it should have been foo(*v).}

The only implicit conversion is to bool,
and it is safe in the sense that typical integral promotions don't apply
(i.e. if foo()
takes an int instead, it won't
compile).

Third, mixed comparisons with bool
work differently than similar mixed comparisons between pointers and bool, so the results might surprise you: