libs/type_traits/doc/has_unary_minus.qbk
[/ (C) Copyright 2009-2011 Frederic Bron. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). ] [section:has_unary_minus has_unary_minus] template <class Rhs, class Ret=dont_care> struct has_unary_minus : public __tof {}; __inherit 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`: `` void f(Ret); Rhs rhs; f(-rhs); // is valid if has_unary_minus<Rhs, Ret>::value==true `` If `Ret=void`, the return type is checked to be exactly `void`. __header `#include <boost/type_traits/has_unary_minus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>` [has_binary_operator_compat] __examples [:`has_unary_minus<Rhs, Ret>::value_type` is the type `bool`.] [:`has_unary_minus<Rhs, Ret>::value` is a `bool` integral constant expression.] [:`has_unary_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.] [:`has_unary_minus<long>` inherits from `__true_type`.] [:`has_unary_minus<int, int>` inherits from `__true_type`.] [:`has_unary_minus<int, long>` inherits from `__true_type`.] [:`has_unary_minus<double, double>` inherits from `__true_type`.] [:`has_unary_minus<double, int>` inherits from `__true_type`.] [:`has_unary_minus<const int>` inherits from `__true_type`.] [:`has_unary_minus<int, std::string>` inherits from `__false_type`.] [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits] [*Known issues:] * 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_minus<Rhs>` will produce a compiler error. For this reason `has_unary_minus` cannot be used to determine whether a type has a public `operator-` or not. `` struct A { private: void operator-(); }; boost::has_unary_minus<A>::value; // error: A::operator-() is private `` * There is an issue if the operator exists only for type `A` and `B` is convertible to `A`. In this case, the compiler will report an ambiguous overload. `` struct A { }; void operator-(const A&); struct B { operator A(); }; boost::has_unary_minus<A>::value; // this is fine boost::has_unary_minus<B>::value; // error: ambiguous overload `` * 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_minus.hpp> #include <iostream> template <class T> struct contains { T data; }; template <class T> bool operator-(const contains<T> &rhs) { return f(rhs.data); } class bad { }; class good { }; bool f(const good&) { } int main() { std::cout<<std::boolalpha; // works fine for contains<good> std::cout<<boost::has_unary_minus< contains< good > >::value<<'\n'; // true contains<good> g; -g; // ok // does not work for contains<bad> std::cout<<boost::has_unary_minus< contains< bad > >::value<<'\n'; // true, should be false contains<bad> b; -b; // compile time error return 0; } `` * `volatile` qualifier is not properly handled and would lead to undefined behavior [prefix_operator_known_issues has_unary_minus..-] [endsect]