On 31 July 2015 at 20:49, François Dumont wrote: > On 30/07/2015 12:30, Jonathan Wakely wrote: >> On 29/07/15 22:08 +0200, François Dumont wrote: >>> Standard algos signatures are such that there is no guaranty that >>> the operator < or predicate to compare the iterator value type will >>> exist. So I had to check if the call is valid using C++11 features >>> declval and decltype. >> >> Surely if someone calls an algorithm that requires a >> StrictWeakOrdering then we know that it's valid to compare the value >> types using the comparison implied by that particular call (either >> operator< or the supplied predicate), and we should only be adding >> this assertion to algorithms that require a StrictWeakOrdering. >> >> Am I missing something? > If you consider for instance lower_bound signature: > > template<typename _ForwardIterator, typename _Tp> > inline _ForwardIterator > lower_bound(_ForwardIterator __first, _ForwardIterator __last, > const _Tp& __val) > > This algo require expressions *__first < __val or __val < *__first > to be well defined. But what the check is doing is *__first < *__first > that might not exist as the algo won't need it. The range [__first, > __last[ might have been sorted using another functor that we don't know > at the time of the call to lower_bound. > > There might be situations where the check will be useless but I > prefer to keep this debug check simple and so always go through the check.
OK, but that is only true for some algos, it's not a problem for many of them, e.g. std::sort we know that we only ever do homogeneous comparisons, so we don't need the SFINAE tricks to detect if the comparison is valid, and so could check for irreflexivity in C++03 mode. So I think ideally we would be able to check for irreflexivity for most algos in C++03, and for some (such as lower_bound) we would only be able to check for C++11 and later.
