Compiler chooses erroneous overload instead of valid overload - c++

Question

Take a look at this code:
#include <vector>
#include <functional>
template<typename RandIt, typename T, typename Pred>
auto search_with(RandIt begin, RandIt end, const T& value, Pred&& pred) noexcept {
//...
return begin;
}
template<typename RandIt, typename T>
auto search_with(RandIt begin, RandIt end, const T& value) noexcept {
return search_with(begin, end, value, std::less<T>{});
}
template<typename Array, typename T, typename Pred>
auto search_with(const Array& array, const T& value, Pred&& pred) noexcept {
return search_with(std::begin(array), std::end(array), value, std::forward<Pred>(pred));
}
int main() {
std::vector<int> v = { 1, 2, 3 };
search_with(v, 10, std::less<int>{}); // ok
search_with(v.begin(), v.end(), 10); // fail!
}
I do not understand why in the second search_with call, the compiler selects the third overload. If I comment out the third overload, then the code compiles fine. This indicates that the second overload is not discarded as it does compile, and it should be a valid overload.
However, the third overload is chosen, which fails, as there is no specialization of std::begin (and std::end) for iterators:
main.cpp: In instantiation of 'auto search_with(const Array&, const T&, Pred&&) [with Array = __gnu_cxx::__normal_iterator<int*, std::vector<int> >; T = __gnu_cxx::__normal_iterator<int*, std::vector<int> >; Pred = int]':
main.cpp:23:39: required from here
main.cpp:17:34: error: no matching function for call to 'begin(const __gnu_cxx::__normal_iterator<int*, std::vector<int> >&)'
return search_with(std::begin(array), std::end(array), value, std::forward<Pred>(pred));
~~~~~~~~~~^~~~~~~
I would have thought that the opposite happens: the third overload is discarded because it fails to compile, and the second one is chosen.
But that is obviously not the case, so what is happening here? Why is the wrong overload being chosen? Why is the third overload a better match then the second one?

Answer 1

It mostly has to do the third argument, which is an rvalue. Try the following to see why it matches the universal reference better.
#include <iostream>
template <typename T>
inline void f(T &)
{
std::cout << "f2" << std::endl;
}
template <typename T>
inline void f(const T &)
{
std::cout << "f3" << std::endl;
}
template <typename T>
inline void f(T &&)
{
std::cout << "f4" << std::endl;
}
int main()
{
int a = 0;
const int b = 0;
int &c = a;
const int &d = b;
f(1); // f4 : rvalue matched by universal reference
f(a); // f2 : lvalue matched by reference, T& preferred to const T&
f(b); // f3 : lvalue matched by reference, can only do const T&
f(c); // f2 : lvalue reference matched by reference, T& preferred to const T&
f(d); // f3 : lvalue const reference matched by reference, can only do const T&
f(std::move(a)); // f4 : rvalue reference, matched by universal reference
}
If you throw one more overload,
template <typename T>
inline void f(T);
into the mix, you will get ambiguous errors, because it will also give you perfect match.
As to the first two rvalue arguments, consider the following example,
template <typename T>
inline void f(T)
{
}
template <typename T>
inline void f(const T &)
{
}
int main() { f(1); }
You will get an ambiguous error. That is, the two overloads match an rvalue equally well. So they do not determine which overload is selected in your example

Answer 2

The third overload is always better, except if you pass a const lvalue as third parameter to your function template. You pass a prvalue. The forwarding reference Pred&& can match this case better and therefore gets chosen.
You can achieve your desired behavior by using the SFINAE (Substitution Failure Is Not An Error) technique.
template<typename Array, typename T, typename Pred>
auto search_with(const Array& array, const T& value, Pred&& pred) noexcept
-> decltype(search_with(
std::begin(array), std::end(array), value, std::forward<Pred>(pred)))
{
return search_with(std::begin(array), std::end(array), value, std::forward<Pred>(pred));
}
This will exclude the overload, if the expression in the decltype(...) is not valid.

Answer 3

The first call is passing parameter values that satisfy the template arguments of only one overload:
template<typename Array, typename T, typename Pred>
auto search_with(const Array& array, const T& value, Pred&& pred) noexcept
The second call is passing parameter values that satisfy the template arguments of two overloads:
template<typename RandIt, typename T>
auto search_with(RandIt begin, RandIt end, const T& value) noexcept
// where RandIt is std::vector<int>::iterator, and T is int...
template<typename Array, typename T, typename Pred>
auto search_with(const Array& array, const T& value, Pred&& pred) noexcept
// where Array and T are both std::vector<int>::iterator, and Pred is int...
However, the third overload is a better match, because its parameters are all being passed by reference, so no unnecessary copies have to be created by the compiler.
With the second overload, the first two parameters are being passed by value, so extra copies have to be made. When dealing with class objects (which an STL container's iterator type may be), that can affect overload resolution.
The compiler tries to avoid making unnecessary copies when possible.