Why is this cast to bool required?

Question

template<typename InputIterator, typename Predicate>
inline InputIterator
find_if(InputIterator first, InputIterator last, Predicate pred, input_iterator_tag)
{
    while (first != last && !bool(pred(*first)))
         ++first;

    return first;
}

I bumped into this snippet in the source code of the implementation of the C++ standard library shipped with GCC 4.7.0. This is the specialization of find_if for an input iterator. I cleaned the leading underscores to make it more readable.

Why did they use a bool cast on the predicate?

score 31 · Accepted Answer · answered Feb 17 '14 at 14:41

31

The reason is that just writing !pred(*first) could result in a call to an overloaded operator! rather than the call to explicit operator bool.

It's interesting that this measure was taken for pred, but an overloaded operator&& can still be selected in the implementation provided. first != last would need to be changed to bool(first != last) to also prevent this overload.

answered Feb 17 '14 at 14:41

Simple

13,992
2
47
47

7

I think that if `operator&&` was overloaded, the behavior would have been undefined because of dereferencing the end iterator in the last iteration (absence of short-circuit). So perhaps the implementation is free to ignore this issue. – Johannes Schaub - litb Feb 17 '14 at 14:54
1

Why doesn't it say `static_cast` though? Why a forced cast? – user541686 Feb 17 '14 at 19:31
@Mehrdad They do the same thing in this context because `reinterpret_cast` is never chosen. (And the GCC source is all just 80 columns wide.) – Potatoswatter Feb 18 '14 at 00:24
@JohannesSchaub-litb: but doesn't that mean && shouldn't be used in the first place? – user541686 Feb 18 '14 at 16:35
@Mehrdad i don't have any idea about the question, I did only throw in some guess without any education – Johannes Schaub - litb Feb 18 '14 at 17:52

score 12 · Answer 2 · answered Feb 17 '14 at 14:36

The standard requires only that the predicate be usable in a context where it can convert to a bool. Presumably, a "predicate" object could have an operator bool function, which did the right thing, and an operator! function which did something totally unrelated. (Of course, that would be horrible design, but the standard requires the library to work as specified, regardless of how bad the user code is.) So g++ converts to bool, and then uses ! on the result of that conversion (where only the build-in operator can apply).

score 2 · Answer 3 · edited Feb 17 '14 at 15:57

In the C++ Standard there is written relative to the predicate that

In other words, if an algorithm takes Predicate pred as its argument and first as its iterator argument, it should work correctly in the construct pred(*first) contextually converted to bool

The words "contextually converted to bool" means that if even a class defines a conversion function that converts an object of the class to bool as an explicit operator it shall be applied. Consider an example of a contextual conversion to bool

#include <iostream>

struct A
{
   explicit operator bool () const { return true; }
};

int main()
{
   if ( A() ) 
   {
      std::cout << "Here is a contextual conversion to bool" << std::endl;
   }
}

So in context of the C++ Standard quote I do not see any sense in writing expression

first != last && !bool( pred(*first ) )

It would be enough to write

first != last && !pred(*first )

Here pred is contextually converted to bool.

It is contextually converted to "bool", which is a user defined conversion. But as someone else says in a comment, if there is an `operator!`, it would be preferred. Which seems to be an excellent remark. — Johannes Schaub - litb, Feb 17 '14 at 14:35
@Johannes Schaub - litb Then there is a problem. If a class does not define a conversion operator to bool but defines operator ! then the original condition will issue an error. So some realization will be compiled with operator ! while others will not. — Vlad from Moscow, Feb 17 '14 at 14:46

Why is this cast to bool required?

3 Answers3