Inherits: If (i) rhs
of type Rhs can be used in
expression +rhs,
and (ii) Ret=dont_care or the result of expression
+rhs
is convertible to Ret then
inherits from true_type,
otherwise inherits from false_type.

The default behaviour (Ret=dont_care)
is to not check for the return value of prefix operator+. If Ret
is different from the default dont_care
type, the return value is checked to be convertible to Ret.
Convertible to Ret means
that the return value of the operator can be used as argument to a function
expecting Ret:

voidf(Ret);Rhsrhs;f(+rhs);// is valid if has_unary_plus<Rhs, Ret>::value==true

If Ret=void, the return type is checked to be exactly
void.

Header:#include<boost/type_traits/has_unary_plus.hpp>
or #include<boost/type_traits/has_operator.hpp>
or #include<boost/type_traits.hpp>

This trait cannot detect whether prefix operator+ is public or not: if operator+ is defined as a private member of Rhs then instantiating has_unary_plus<Rhs>
will produce a compiler error. For this reason has_unary_plus
cannot be used to determine whether a type has a public operator+
or not.

There is an issue when applying this trait to template classes. If operator+
is defined but does not bind for a given template type, it is still detected
by the trait which returns true
instead of false. Example:

#include<boost/type_traits/has_unary_plus.hpp>#include<iostream>template<classT>structcontains{Tdata;};template<classT>booloperator+(constcontains<T>&rhs){returnf(rhs.data);}classbad{};classgood{};boolf(constgood&){}intmain(){std::cout<<std::boolalpha;// works fine for contains<good>std::cout<<boost::has_unary_plus<contains<good>>::value<<'\n';// truecontains<good>g;+g;// ok// does not work for contains<bad>std::cout<<boost::has_unary_plus<contains<bad>>::value<<'\n';// true, should be falsecontains<bad>b;+b;// compile time errorreturn0;}

volatile qualifier is not
properly handled and would lead to undefined behavior