編譯器錯誤的選擇，而不是過載超載有效

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

第一呼叫被傳遞滿足的模板參數參數值只有一個過載：

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類型可能）時，可能會影響重載解析。

編譯器會盡可能避免進行不必要的複製。

Answer 3

第三個重載總是比較好，除非你傳遞一個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(...)中的表達式無效。