编译器选择错误重载而不是有效重载

Question

看看这段代码：

#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!
}

我不明白为什么在第二个search_with 调用中，编译器选择了第三个重载。如果我注释掉第三个重载，那么代码编译得很好。这表明第二个重载在编译时没有被丢弃，它应该是一个有效的重载。

但是，选择了第三个重载，但失败了，因为迭代器没有专门化 std::begin（和 std::end）：

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));
                        ~~~~~~~~~~^~~~~~~

我原以为会发生相反的情况：第三个重载因为编译失败而被丢弃，而选择了第二个。

但显然情况并非如此，那么这里发生了什么？为什么选择了错误的重载？为什么第三个重载比第二个更好？

Answer 1

它主要是做第三个参数，它是一个右值。请尝试以下操作，看看为什么它更符合通用参考。

#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

}

如果你再抛出一个超载，

 template <typename T>
 inline void f(T);

混进去，你会得到模棱两可的错误，因为它也会给你完美的匹配。

至于前两个右值参数，请考虑以下示例，

template <typename T>
inline void f(T)
{
}

template <typename T>
inline void f(const T &)
{
}

int main() { f(1); }

你会得到一个模棱两可的错误。也就是说，这两个重载同样匹配一个右值。因此，他们无法确定您的示例中选择了哪个重载

Answer 2

第三个重载总是更好，除非你将一个 const 左值作为第三个参数传递给你的函数模板。你传递了一个prvalue。转发参考Pred&& 可以更好地匹配这种情况，因此被选中。

您可以使用SFINAE (Substitution Failure Is Not An Error) 技术实现您想要的行为。

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));
}

如果decltype(...) 中的表达式无效，这将排除重载。

Answer 3

第一个调用是传递满足模板参数的参数值只有一个重载：

template<typename Array, typename T, typename Pred>
auto search_with(const Array& array, const T& value, Pred&& pred) noexcept

第二个调用是传递满足两个重载的模板参数的参数值：

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...

但是，第三个重载是更好的匹配，因为它的参数都是通过引用传递的，所以编译器不必创建不必要的副本。

在第二次重载中，前两个参数是按值传递的，因此必须制作额外的副本。在处理类对象时（可能是 STL 容器的 iterator 类型），这可能会影响重载决议。

编译器会尽可能避免制作不必要的副本。