将 lambda 传递到函数模板中

您的函数binsearch将函数指针作为参数。lambda 和函数指针是不同的类型：lambda 可以被视为实现 operator() 的结构体的实例。

请注意，无状态 lambda(不捕获任何变量的 lambda(可隐式转换为函数指针。在这里，由于模板替换，隐式转换不起作用：

#include <iostream>
template <typename T>
void call_predicate(const T& v, void (*predicate)(T)) {
    std::cout << "template" << std::endl;
    predicate(v);
}
void call_predicate(const int& v, void (*predicate)(int)) {
    std::cout << "overload" << std::endl;
    predicate(v);
}
void foo(double v) {
    std::cout << v << std::endl;
}
int main() {
    // compiles and calls template function
    call_predicate(42.0, foo);
    // compiles and calls overload with implicit conversion
    call_predicate(42, [](int v){std::cout << v << std::endl;});
    // doesn't compile because template substitution fails
    //call_predicate(42.0, [](double v){std::cout << v << std::endl;});
    // compiles and calls template function through explicit instantiation
    call_predicate<double>(42.0, [](double v){std::cout << v << std::endl;});
}

你应该使你的函数binsearch更通用，如下所示：

template <typename T, typename Predicate>
T binsearch(const std::vector<T> &ts, Predicate p) {
    // usage
    for(auto& t : ts)
    {
        if(p(t)) return t;
    }
    // default value if p always returned false
    return T{};
}

从标准算法库中获取灵感。

捕获列表为空的 lambda 表达式可以隐式转换为函数指针。但是函数指针predicate将T作为其参数，需要推导。模板类型推导中不考虑类型转换，T无法推导;正如错误消息所说，候选模板(即 binsearch ( 将被忽略。

你可以使用 operator+ 来实现这一点，它会将 lambda 转换为函数指针，稍后会传递给binsearch，然后成功推导T[^1]。

binsearch(a, +[](int e) -> bool { return e >= 5; });
//           ~

当然，您可以明确使用static_cast：

binsearch(a, static_cast<bool(*)(int)>([](int e) -> bool { return e >= 5; }));

注意如果将predicate的类型更改为独立于T，即 bool (*predicate)(int)，传递带有空捕获列表的 lambda 也可以;lambda 表达式将隐式转换为函数指针。

另一种解决方案是将参数类型从函数指针更改为 std::function ，这对于函子来说更通用：

template <typename T> int binsearch(const std::vector<T> &ts, std::function<bool (typename std::vector<T>::value_type)> predicate) {
    ...
}

然后

binsearch(a, [](int e) -> bool { return e >= 5; });

^{[1] 一个正的λ： '+[]{}' - 这是什么巫术？}

为什么编译器不相信我的 lambda 具有正确的类型？

被告知推导其模板参数的模板函数不会进行转换。 lambda 不是函数指针，因此无法推断该参数中的T。 由于所有函数参数都独立地推导其模板参数(除非阻止演绎(，这会导致错误。

您可以进行许多修复。

您可以修复模板函数。

template <class T>
int binsearch(const std::vector<T> &ts, bool (*predicate)(T))

将函数指针替换为Predicate predicate或Predicate&& predicate，并保持主体不变。

template <class T, class Predicate>
int binsearch(const std::vector<T> &ts, Predicate&& predicate)

使用扣除阻止：

template<class T>struct tag_t{using type=T;};
template<class T>using block_deduction=typename tag_t<T>::type;
template <class T>
int binsearch(const std::vector<T> &ts, block_deduction<bool (*)(T)> predicate)

(可选(将函数指针替换为 std::function<bool(T)> .

您可以在呼叫站点修复它。

您可以手动传递T binsearch<T>(vec, [](int x){return x<0;}) .

您可以将 lambda 衰减为函数指针，并在它前面放一个+ +[](int x)......或static_cast<bool(*)(int)>(... ) .

最好的选择是Predicate一个。 这也是标准库代码的作用。

我们还可以更进一步，使您的代码更加通用：

template <class Range, class Predicate>
auto binsearch(const Range &ts, Predicate&& predicate)
-> typename std::decay< decltype(*std::begin(ts)) >::type

-> typename std::decay...尾随返回类型部分可以在 C++14 中消除。

这样做的好处是，如果主体也使用 std::begin 和 std::end 来查找开始/结束迭代器，binsearch现在支持 deque s、平面 C 样式数组、std::array s、std::string s、std::vector s，甚至一些自定义类型。

如果你对binsearch有任何控制，我建议你重构它：

template <typename T, typename Predicate>
int binsearch(std::vector<T> const& vec, Predicate&& pred) {
    // This is just to illustrate how to call pred
    for (auto const& el : vec) {
        if (pred(el)) {
            // Do something
        }
    }
    return 0; // Or anything meaningful
}

另一种方法是对函子对象/函数指针/任何内容执行类型擦除...通过将它们嵌入到std::function<bool(T const&)>中。为此，只需将上面的函数重写为：

template <typename T>
int binsearch(std::vector<T> const& vec, std::function<bool(T const&)> pred);

但是由于模板参数推导不进行任何转换，因此您需要像下面这样显式馈送函数：

auto my_predicate = [](int x) { return true; }; // Replace with actual predicate
std::vector<int> my_vector = {1, 2, 3, 4};
binsearch(my_vector, std::function<bool (int const&)>(my_predicate));

但是，鉴于您的函数的描述，它似乎与std::find_if .

std::vector<int> my_vector = {1, 12, 15, 13, 16};
auto it = std::find_if(std::begin(my_vector), std::end(my_vector),
                       [](int vec_el) { return !vec_el%5; });
// it holds the first element in my_vector that is a multiple of 5.
if (it != std::end(my_vector)) {
    std::cout << *it << std::endl; // prints 15 in this case
}

请注意，要进行二叉搜索，您需要的不仅仅是一个谓词：您需要一个谓词来定义范围上的顺序和目标值。

函数指针和 lambda 函数不是一回事。

在以下情况下，不能将对象t分配给谓词：

 bool (*predicate)(int)

和

auto t = [](int e) -> bool { return e >= 5; });

不妨使用std::function<bool(int)>.您的签名将如下所示：

template <typename T> 
int binsearch(const std::vector<T> &ts, std::function<bool(T)> predicate){
   // ...
}

现在这不是一个函数指针，如果有必要，你需要绑定你的基础指针，(我假设你只使用 lambda 就可以了(