Change 19.4.2.1 [sys.errcode.overview]
namespace std {
class error_code {
public:
...
// observers:
value_type value() const;
const error_category& category() const;
posix_errno posix() const;
string message() const;
wstring wmessage() const;
explicit operator unspecified-bool-type() const;
...
};
} // namespace std
...
explicit operator unspecified-bool-type () const;
-11- Returns: If value() != value_type(), returns a value that will evaluate true in a boolean context; otherwise,
returs a value that will evaluate false. The return type shall not be convertible to int.
-12- Throws: Nothing.
-13- [ Note: This conversion can be used in contexts where a bool is expected (e.g., an if condition); however, implicit
conversions (e.g., to int) that can occur with bool are not allowed, eliminating some sources of user error. One
possible implementation choice for this type is pointer to member. - end note ]
Change 20.5.14.2 [func.wrap.func]:
namespace std {
template<class> class function; // undefined
template<class R, class... ArgTypes>
class function<R(ArgTypes...)>
: public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and ArgTypes contains T1
: public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and ArgTypes contains T1 and T2
{
public:
...
// 20.5.14.2.3, function capacity:
explicit operator unspecified-bool-type () const;
...
private:
// 20.5.14.2.6, undefined operators:
template<class R2, class... ArgTypes2> bool operator==(const function<R2(ArgTypes2...)>&);
template<class R2, class... ArgTypes2> bool operator!=(const function<R2(ArgTypes2...)>&);
};
} // namespace std
and 20.5.14.2.3 [func.wrap.func.cap]:
explicit operatorunspecified-bool-type() const
-1- Returns: if *this has a target, returns a value that will evaluate true in a boolean context; otherwise, returns a value that will evaluate false in a boolean context. The value type returned shall not be convertible to int.
-2- Throws: nothing.
-3- [ Note: This conversion can be used in contexts where a bool is expected (e.g., an if condition); however, implicit conversions (e.g., to int) that can occur with bool are not allowed, eliminating some sources of user error. One possible implementation choice for this type is pointer-to-member. - end note ]
and remove 20.5.14.2.6 [func.wrap.func.undef]:
template<class R2, class... ArgTypes2> bool operator==(const function<R2(ArgTypes2...)>&); template<class R2, class... ArgTypes2> bool operator!=(const function<R2(ArgTypes2...)>&);
-1- These member functions shall be left undefined.
-2- [ Note: the boolean-like conversion opens a loophole whereby two function instances can be compared via or !=. These undefined void operators close the loophole and ensure a compile-time error. - end note ]
Change 20.6.5.2 [unique.ptr.single]:
template <class T, class D = default_delete<T>> class unique_ptr {
...
// observers
T& operator*() const;
T* operator->() const;
T* get() const;
deleter_type& get_deleter();
const deleter_type& get_deleter() const;
explicit operator unspecified-bool-type () const;
...
};
and 20.6.5.2.4 [unique.ptr.single.observers]
explicit operatorunspecified-bool-type() const;
-11- Returns: An unspecified value that, when used in boolean contexts, is equivalent to get() != 0.
-12- Throws: nothing.
-13- [ Note: The unspecified-bool-type is often implemented as a pointer to a private data member, avoiding many of the implicit conversion pitfalls. - end note ]
and 20.6.5.3 [unique.ptr.runtime]:
template <class T, class D> class unique_ptr<T[], D> {
...
// observers
T& operator[]() const;
T* get() const;
deleter_type& get_deleter();
const deleter_type& get_deleter() const;
explicit operator unspecified-bool-type () const;
...
};
and 20.6.5.4 [unique.ptr.compiletime]:
template <class T, class D, size_t N> class unique_ptr<T[N], D> {
...
// observers
T& operator[]() const;
T* get() const;
deleter_type& get_deleter();
const deleter_type& get_deleter() const;
explicit operator unspecified-bool-type () const;
...
};
Change 20.6.6.2 [util.smartptr.shared]:
namespace std {
template class shared_ptr {
...
// 20.6.6.2.5, observers:
T* get() const;
T& operator*() const;
T* operator->() const;
long use_count() const;
bool unique() const;
explicit operator unspecified-bool-type () const; };
} // namespace std
and 20.6.6.2.5 [util.smartptr.shared.obs]
explicit operatorunspecified-bool-type() const;
-16- Returns: an unspecified value that, when used in boolean contexts, is equivalent to get() != 0.
-17- Throws: nothing.
-18- [ Note: This conversion operator allows shared_ptr objects to be used in boolean contexts. [ Example: if (p
&& p->valid()) - end example ] One possible choice for the return type is a pointer to member function, which avoids many of the implicit conversion pitfalls of a bool or void* return type. - end note ]
Change 27.4.4 [ios]
namespace std {
template <class charT, class traits = char_traits<charT> >
class basic_ios : public ios_base {
public:
...
explicit operator unspecified-bool-type () const;
};
}
and 27.4.4.3 [iostate.flags]:
explicit operatorunspecified-bool-type() const;
-1- Returns: If !fail() then a value that will evaluate false in a boolean context; otherwise a value that will evaluate true in a boolean context. The value type returned shall not be convertible to int.
[ Note: This conversion can be used in contexts where a bool is expected (e.g., an if condition); however, implicit conversions (e.g., to int) that can occur with bool are not allowed, eliminating some sources of user error. One
possible implementation choice for this type is pointer-to-member. - end note ]
Change 27.6.1.1.3 [istream::sentry]
namespace std {
template <class charT,class traits = char_traits<charT> >
class basic_istream<charT,traits>::sentry {
typedef traits traits_type;
// bool ok_; exposition only
public:
explicit sentry(basic_istream<charT,traits>& is , bool noskipws = false);
~sentry();
explicit operator bool() const { return ok_; }
private:
sentry(const sentry&); // not defined
sentry& operator=(const sentry&); // not defined
};
}
Change 27.6.2.4 [ostream::sentry]
namespace std {
template <class charT,class traits = char_traits<charT> >
class basic_ostream<charT,traits>::sentry {
// bool ok_; exposition only
public:
explicit sentry(basic_ostream<charT,traits>& os);
~sentry();
explicit operator bool() const { return ok_; }
private:
sentry(const sentry&); // not defined
sentry& operator=(const sentry&); // not defined
};
}