如何使這些std :: function參數明確？傳遞的λ時

Question

下面的函數重載是不明確的。我發現std::function可以constructed from most callable types，即使他們的簽名不匹配。所以編譯器無法知道要使用哪個函數。

template <typename T> void each(std::function<void(T)> iterator); 
template <typename T> void each(std::function<void(T, id)> iterator); 
template <typename T> void each(std::function<void(T&)> iterator); 
template <typename T> void each(std::function<void(T&, id)> iterator); 

這裏有一些類似的問題，但沒有一個能解決我的問題。如何在不改變用途的情況下解決歧義問題？此外，當時我不得不明確提到模板類型。有沒有解決的辦法？

Answer 1

這其中的一半是LWG issue 2132，從重載解析中移除std::function的構造函數，除非參數實際上可以爲指定的參數類型調用。這需要表達SFINAE支持才能實現，哪些VC++沒有。

問題的另一半是重載解析：

#include<functional> 
#include<iostream> 
struct id {}; 
template <typename T> void each(std::function<void(T)>){ std::cout << __PRETTY_FUNCTION__ << std::endl; } 
template <typename T> void each(std::function<void(T, id)>){ std::cout << __PRETTY_FUNCTION__ << std::endl; } 
template <typename T> void each(std::function<void(T&)>){ std::cout << __PRETTY_FUNCTION__ << std::endl; } 
template <typename T> void each(std::function<void(T&, id)>){ std::cout << __PRETTY_FUNCTION__ << std::endl; } 
int main() { 
    each<int>([](int, id){}); 
} 

用實現LWG2132，this code prints，也許令人驚訝的庫：

void each(std::function<void(T&, id)>) [with T = int] 

爲什麼？首先，可以從[](int, id){}構建std::function<void(T&, id)>。畢竟，後者可以被稱爲與int類型的左值就好了。

其次，在

template <typename T> void each(std::function<void(T, id)>); 
template <typename T> void each(std::function<void(T&, id)>); 

第二個比第一個由函數模板部分排序規則更加專業化的，所以它總是通過重載決議選擇。

---

一個可能的解決方案是通過操縱類型提取簽名拉姆達的operator()：

template<class T> 
struct mem_fn_type; 
template<class R, class C, class... T> 
struct mem_fn_type<R(C::*)(T...)> { 
    using type = std::function<R(T...)>; 
}; 
template<class R, class C, class... T> 
struct mem_fn_type<R(C::*)(T...) const> { 
    using type = std::function<R(T...)>; 
}; 

// optional extra cv-qualifier and ref-qualifier combos omitted 
// since they will never be used with lambdas  

// Detects if a class is a specialization of std::function 
template<class T> 
struct is_std_function_specialization : std::false_type {}; 

template<class T> 
struct is_std_function_specialization<std::function<T>> : std::true_type{}; 

// Constrained to not accept cases where T is a specialization of std::function, 
// to prevent infinite recursion when a lambda with the wrong signature is passed 
template<class T> 
typename std::enable_if<!is_std_function_specialization<T>::value>::type each(T func) { 
    typename mem_fn_type<decltype(&T::operator())>::type f = func; 
    each(f); 
} 

這不會對通用Lambda表達式工作（其operator()是一個模板）或任意函數對象（可能會有任意多個過載）。

Answer 2

Morever，當時我已經明確提到的模板類型。有沒有解決的辦法？

規範的解決方案是實現一個通用的依賴注入點（即單重載），並允許客戶端代碼決定它放在那裏。我不確定如何給出一個對你提供的代碼有意義的例子，因爲我無法想象一個稱爲each的函數會使用一個名爲iterator的參數（當該參數是一個返回void的函子時）。

與你相似的函數將被應用於訪問者模式，所以我會使用，給你一個例子：

class collection { 
    std::vector<int> data; // to be visited 
public: 
    void visit(std::function<void(int)> visitor) // single overload 
    { 
     std::for_each(std::begin(data), std::end(data), visitor); 
    } 
}; 

void complex_visitor(int element, double EXTRA, char* PARAMETERS, bool HERE); 

客戶端代碼：

collection c; 
char* data = get_some_data(); 
bool a = false; 
c.visit([&](int x) { complex_visitor(x, .81, data, a); }); 

在這個例子中，它是在最後一行（即在客戶端代碼中），你決定如何插入一個不匹配的訪問者，而不是在collection類的接口。