傳遞lambda時,以下函數(shù)重載是不明確的.我發(fā)現(xiàn)std :: function可以是constructed from most callable types,即使它們的簽名不匹配.所以編譯器無法分辨使用哪個函數(shù).

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

這里有一些類似的問題,但沒有一個能解決我的問題.如何在不改變用法的情況下解決歧義？更重要的是,當時我必須明確提到模板類型.有沒有解決的辦法？

解決方法:

其中一半是LWG issue 2132,從重載決策中刪除std :: function的構(gòu)造函數(shù),除非參數(shù)實際上可以為指定的參數(shù)類型調(diào)用.這需要表達SFINAE支持來實現(xiàn),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){});
}

有一個實現(xiàn)LWG2132,this code prints的庫,也許令人驚訝：

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

為什么？首先,可以構(gòu)造一個std :: function< void(T&,id)>來自[](int,id){}.畢竟,后者可以使用類型為int的左值來調(diào)用.

第二,在

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

第二種方法比功能模板的部分排序規(guī)則更專業(yè),因此總是通過重載分辨率來選擇.

一種可能的解決方案是通過操縱lambda的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()是模板)或任意函數(shù)對象(可能有任意多個operator()重載).