C++ 将std:：find_if（）与接受多个输入参数的比较函数一起使用

我正在尝试将

std:：find_if（）

算法与接受多个输入参数的比较函数一起使用，但我不确定如何在代码中实现它。我在不同的站点上搜索了

std:：find_if（）

的用法，但它们都使用了带有单个输入参数的比较函数

using namespace std;

// comparison function
bool range_search(double x, double X1, double X2)
{
    return (x >= X1 && x <= X2) ? true : false;
}

// main   
vector<double> x;

for(int i = 0; i < size; i++){
    x.push_back(...);
};

vector<double>::iterator it = find_if(x.begin(), x.end(), range_search);
int pos_1 = distance(x.begin(), it);

使用名称空间std；
//比较函数
布尔范围搜索（双x、双X1、双X2）
{
返回（x>=X1&&x使用lambda：

vector<double>:: iterator it = find_if(x.begin(),x.end(),[param1, param2, param3](const double& a, const double& b) { /* use param1-3 here*/ });

double X1 = 2, X2 = 4;
auto it = find_if(x.begin(), x.end(),
                  [&](double v) { return (v >= X1 && v <= X2); });

vector:：iterator it=find_if（x.begin（），x.end（），[param1，param2，param3]（constdouble&a，constdouble&b）{/*此处使用param1-3*/}）；
find_if
的测试函数只需要一个参数，因为它必须依次测试集合中的每个元素。如果要在调用时绑定额外变量，请使用lambda：

vector<double>:: iterator it = find_if(x.begin(),x.end(),[param1, param2, param3](const double& a, const double& b) { /* use param1-3 here*/ });

double X1 = 2, X2 = 4;
auto it = find_if(x.begin(), x.end(),
                  [&](double v) { return (v >= X1 && v <= X2); });

双X1=2，X2=4；
auto it=find_if（x.begin（），x.end（），
[&]（双v）{return（v>=X1&&v没有任何版本的
std:：find_if（）
接受具有多个输入参数的谓词。
std:：find_if（）
遍历指定的迭代器范围，将每个元素一次传递给谓词。因此，谓词只能接受一个输入参数，不能多，也不能少。这就是为什么您看到的所有示例都使用一个参数

您显示的
range\u search（）
函数本身不兼容，无法用作谓词

在C++11及更高版本中，您可以使用lambda捕获要传递到
range\u search（）
的额外值，例如：

double X1 = ...;
doubke X2 = ...;
auto it = find_if(x.begin(), x.end(),
    [X1, X2](double x){ return range_search(x, X1, X2); }
);

在C++11之前，可以改用函子对象：

struct range_search_s
{
    double X1, X2;
    range_search_s(double x1, double x2) : X1(x1), X2(x2) {}
    bool operator()(double x) { return range_search(x, X1, X2); }
};

double X1 = ...;
doubke X2 = ...;
vector<double>::iterator it = find_if(x.begin(), x.end(), range_search_s(X1, X2));

struct range\u search\s
{
双X1，X2；
范围搜索（双x1，双x2）：x1（x1），x2（x2）{
布尔运算符（）（双x）{返回范围_搜索（x，X1，X2）；}
};
双X1=。。。；
doubke X2=。。。；
向量：：迭代器it=find_if（x.begin（），x.end（），range_search_s（X1，X2））；
您可以使用将带有
n
参数的函数转换为带有
n-x
参数的函数，方法是将一些参数作为常量提供：

auto fn = std::bind(&range_search, _1, 0.1, 0.9);

\u 1
是第一个参数的占位符，我们希望将其保持为变量。参数
0.1
和
0.9
分别传递给参数
X1
和
X2

由于生成的函数现在只有一个参数，我们可以将其与
std:：find_if（）
：

您还可以将这两个功能组合为一个调用：

auto it = std::find_if(x.begin(), x.end(), std::bind(&range_search, _1, 0.1, 0.9));

假设
std:：find\u如果
只接受一元谓词，则可以使用高阶函数构造一个谓词，该函数具有多个输入参数，返回一元lambda：

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <cassert>

namespace pred {

template <class T>
constexpr auto is_in_range(const T min_value, const T max_value)
{
    return [min_value, max_value] (T x) { return x >= min_value && x <= max_value; };
}

}

int main()
{
    std::vector<double> x {0.1, -3.0, 1.67, 4.0, 3.14, 1.5, 0.0, 2.0};

    auto it = find_if(x.begin(), x.end(), pred::is_in_range(1.0, 3.0));
    assert(distance(x.begin(), it) == 2  &&  *it == 1.67);  

    auto ranged = pred::is_in_range(0.0, 3.5);

    auto it2 = find_if(x.begin(), x.end(), ranged);   
    assert(distance(x.begin(), it2) == 0  &&  *it2 == 0.1);  

    std::vector<double> y;
    std::copy_if(x.begin(), x.end(), std::back_inserter(y), ranged);
    assert(y.size() == 6);

    std::cout << "So far, so good...\n";
}

#包括
#包括
#包括
#包括
#包括
名称空间pred{
模板
constexpr auto在范围内（const T最小值、const T最大值）
{
return[min_value，max_value]（tx）{return x>=min_value&&x是X1和X2常量？使用lambdas或functor对象？@P.W是的，X1和X2是常量。但是我想调用这个函数几次。例如x[2][2]={{1,2}，{3,4}；对于第一种情况：X1=x[0][0]，X2 x=x[0][1]&对于第二种情况X1 x=x[1][0]，X2 1][1]。如果您查看，您可以看到谓词函数的概念是
UnaryPredicate
。因此，标准库函数将只接受接受一个参数并返回true/false的函数。您的函数接受3个参数。因此，您需要将其包装为只接受一个参数的函数。是否允许至少使用C++11 standard？不能在lambda的
（）
之间使用2个参数值，
find_if（）
将只接受1个参数。