C++ 使用运行时常量实例化的函数模板

我需要一些方法来结合lambda捕获运行时值的能力和函数模板指定我们想要的任何类型的能力。最好的方法是什么

Lambda允许我们在运行时捕获局部变量的值，例如

unsigned char c=0;
auto compareEquality=[c](unsigned char c1) ->bool {return c1==c;};
..
scanner(compareEquality);

因此，

scanner

被传递一个嵌入了运行时确定的值0的函数，在

scanner

内部，我们调用

compareEquality

传递一个

unsigned char

来与0或运行时获得的任何其他值进行比较。但是我也希望参数是我想要的任何类型，而不仅仅是

无符号字符

。如果有这样的话，那就太好了：

template<typename T>
bool compareEquality(T data) {
  return ( data== c);//error, what is 'c'?
}

上面的代码不允许我指定在函数内部与哪个值进行比较

---

组合函数模板和lambda捕获的最佳方法是什么，这样

compareEquality

可以与一些嵌入的运行时值一起传递，而我们不必定义接受不同参数类型的单独版本。

我可能误解了您的问题，但您可以编写一个高阶函数，返回lambda：

#include <iostream>
#include <vector>
#include <algorithm>

template <typename T>
constexpr auto is_equal_to(T value)
{
    return [value](T const& x) { return x == value; };   
}

int main(void)
{
    std::vector src {17, 4, 42, 23, 9, 17, 8, 61};   
    int x;
    std::cin >> x;
    std::cout << "count (" << x << "): "
        << std::count_if(src.cbegin(), src.cend(), is_equal_to(x)) << '\n';

    std::cout << "count (42): "
        << std::count_if(src.cbegin(), src.cend(), is_equal_to(42)) << '\n';   
}

#包括
#包括
#包括
模板
constexpr auto等于（T值）
{
return[value]（T const&x）{return x==value；}；
}
内部主（空）
{
std：：载体src{17,4,42,23,9,17,8,61}；
int x；
标准：cin>>x；
std:：cout您可以做的是使用一个函数为您构建这些lambda，如下所示：

template<typename T>
auto ret_f(const T& p){
    return  [p](const T& p1)-> bool 
               {return p1==p;};
}
struct foo{
    int a;
    double b;
    bool c;

    bool operator==(const foo& f){
        return false;
    }
};

int main() { 
    unsigned char c= 0;
    int i = 0;
    foo bar {22,15.2,false};

    auto fchar = ret_f(c);
    auto fint = ret_f(i);    
    auto f_foo = ret_f(bar);

    cout<<fchar('a');

    cout<<fint(2.6);

    cout<<f_foo(bar);

return 0;

模板
自动修复（施工测试与生产）{
返回[p]（常数T&p1）->bool
{返回p1==p；}；
}
结构foo{
INTA；
双b；
布尔c；
布尔运算符==（常量foo&f）{
返回false；
}
};
int main（）{
无符号字符c=0；
int i=0；
foo-bar{22,15.2，false}；
自动fchar=ret_f（c）；
自动fint=ret_f（i）；
自动f_foo=返回f（bar）；
您是否尝试过对lambda参数使用
auto
类型推断？如
[c]（auto c1）{return c1==c；}
但使用
[c]（auto c1）{return c1==c；}
，这是否意味着我们在定义lambda时需要知道
c
的类型是
unsigned char
。
template<typename T>
auto ret_f(const T& p){
    return  [p](const T& p1)-> bool 
               {return p1==p;};
}
struct foo{
    int a;
    double b;
    bool c;

    bool operator==(const foo& f){
        return false;
    }
};

int main() { 
    unsigned char c= 0;
    int i = 0;
    foo bar {22,15.2,false};

    auto fchar = ret_f(c);
    auto fint = ret_f(i);    
    auto f_foo = ret_f(bar);

    cout<<fchar('a');

    cout<<fint(2.6);

    cout<<f_foo(bar);

return 0;