123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112 |
- [/
- (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_post_decrement has_post_decrement]
- template <class Lhs, class Ret=dont_care>
- struct has_post_decrement : public __tof {};
- __inherit
- If (i) `lhs` of type `Lhs` can be used in expression `lhs--`,
- and (ii) `Ret=dont_care` or the result of expression `lhs--` 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 postfix `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);
- Lhs lhs;
- f(lhs--); // is valid if has_post_decrement<Lhs, Ret>::value==true
- ``
- If `Ret=void`, the return type is checked to be exactly `void`.
- __header `#include <boost/type_traits/has_post_decrement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
- [has_binary_operator_compat]
- __examples
- [:`has_post_decrement<Lhs, Ret>::value_type` is the type `bool`.]
- [:`has_post_decrement<Lhs, Ret>::value` is a `bool` integral constant expression.]
- [:`has_post_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
- [:`has_post_decrement<long>` inherits from `__true_type`.]
- [:`has_post_decrement<int, int>` inherits from `__true_type`.]
- [:`has_post_decrement<int, long>` inherits from `__true_type`.]
- [:`has_post_decrement<double, double>` inherits from `__true_type`.]
- [:`has_post_decrement<double, int>` inherits from `__true_type`.]
- [:`has_post_decrement<bool>` inherits from `__false_type`.]
- [:`has_post_decrement<const int>` inherits from `__false_type`.]
- [:`has_post_decrement<void*>` inherits from `__false_type`.]
- [:`has_post_decrement<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 postfix `operator--` is public or not:
- if `operator--` is defined as a private member of `Lhs` then
- instantiating `has_post_decrement<Lhs>` will produce a compiler error.
- For this reason `has_post_decrement` cannot be used to determine whether a type has a public `operator--` or not.
- ``
- struct A { private: void operator--(int); };
- boost::has_post_decrement<A>::value; // error: A::operator--(int) 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&, int);
- struct B { operator A(); };
- boost::has_post_decrement<A>::value; // this is fine
- boost::has_post_decrement<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_post_decrement.hpp>
- #include <iostream>
- template <class T>
- struct contains { T data; };
- template <class T>
- bool operator--(const contains<T> &lhs, int) {
- return f(lhs.data);
- }
- class bad { };
- class good { };
- bool f(const good&, const good&) { }
- int main() {
- std::cout<<std::boolalpha;
- // works fine for contains<good>
- std::cout<<boost::has_post_decrement< contains< good > >::value<<'\n'; // true
- contains<good> g;
- g--; // ok
- // does not work for contains<bad>
- std::cout<<boost::has_post_decrement< 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_post_decrement..--]
- [endsect]
|