Передача оператора в лямбду

Question

Можно ли передать оператор лямбде?Например, передавая некоторый оператор op в функцию ниже.

auto lambdaCompare = [](value,compare1,compare2,op){return value op compare1 and value op compare2;};

Answer 1

Вы не можете передать оператора, а затем использовать его, как хотите, но вы можете передать std::greater_equal:

#include <iostream>
#include <functional>

int main() {

    auto lambdaCompare = [](int value, int compare1, int compare2, std::function<bool(int, int)> op) {
        return op(value, compare1) && op(value, compare2);
    };

    std::cout << lambdaCompare(2, 1, 6, std::greater_equal<int>());

    return 0;
}

Answer 2

Я бы сделал это:

C ++ 14

auto l = [](auto value, auto c1, auto c2, auto op)
{
    return (op(value, c1) && op(value, c2));
};

l(1, 2, 3, [](int a, int b) { return a < b; });

C ++ 11

auto l = [](int value, int c1, int c2, bool(* op)(int, int))
{
    return (op(value, c1) && op(value, c2));
};

l(1, 2, 3, [](int a, int b) { return a < b; });

Ну, вы также можете сделать это:

Я не согласен, действительно ли я рекомендую это. С одной стороны, это макро-гадость, с другой стороны это выглядит довольно невинно, просто и не требует объяснений

C ++ 14

auto l = [](auto value, auto c1, auto c2, auto op)
{
    return (op(value, c1) && op(value, c2));
};

l(1, 2, 3, OPERATOR(<));
l(1, 2, 3, OPERATOR(<=));
l(1, 2, 3, OPERATOR(>));
l(1, 2, 3, OPERATOR(>=));
l(1, 2, 3, OPERATOR(==));
l(1, 2, 3, OPERATOR(!=));

с

#define OPERATOR(op) [] (const auto& a, const auto& b) { return a op b; }

C ++ 11

auto l = [](int value, int c1, int c2, Op_t<int, int, bool> op)
{
    return (op(value, c1) && op(value, c2));
};

l(1, 2, 3, OPERATOR(int, int, <));
l(1, 2, 3, OPERATOR(int, int, <=));
l(1, 2, 3, OPERATOR(int, int, >));
l(1, 2, 3, OPERATOR(int, int, >=));
l(1, 2, 3, OPERATOR(int, int, ==));
l(1, 2, 3, OPERATOR(int, int, !=));

с

#define OPERATOR(T1, T2, op) [] (const T1& a, const T2& b) { return a op b; }

template <class T1, class T2, class R>
using Op_t = auto (*) (const T1&, const T2&) -> R;

Answer 3

Если ваши операторы являются бесплатными функциями, вы можете вернуться к чему-то вроде этого

struct S
{
public:
    S(int i) : i (i) {}
    int i;
};

bool operator < (const S& s1, const S& s2)
{
    return s1.i < s2.i;
}

int main()
{
    auto lambda_compare = [](S s1, S s2, auto op) {
        return op(s1, s2);
    };
    bool b = lambda_compare(S(1), S(2), operator<);
    return 0;
}