通常以c里的指针函数或者cpp里的函数模板实现

$less<int>, greater<int>$ 等二元操作符类 本质上是模板类其继承了 binary_function<_Tp, _Tp, bool> 类中往往不带成员变量，而只对运算符进行重载，特殊的，当类中重载了operator()运算符，我们称之该类生成的对象对函数对象

通常调用方法如下

less<int> obj;
obj(1, 2);
obj.operator()(1, 2);

template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
{
  typedef _Arg1     first_argument_type; 

  typedef _Arg2     second_argument_type;

  typedef _Result   result_type;
};

template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
  _GLIBCXX14_CONSTEXPR
  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x > __y; }
};

template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
  _GLIBCXX14_CONSTEXPR
  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x < __y; }
};

#include <bits/stdc++.h>
using namespace std;

template<typename _Compare>
bool f(int a, int b, _Compare cmp) {
    return cmp(a, b);
}

bool fun(int a, int b, bool cmp(const int&, const int&)) {
    return cmp(a, b);
}

int main() {

    greater<int> g = greater<int>();
    less<int> l = less<int>();

    cout << l(1, 2) << '\n';
    cout << l.operator()(1, 2) << '\n';
    cout << f(1, 2, l) << '\n';
    cout << g(1, 2) << '\n';
    cout << g.operator()(1, 2) << '\n';
    cout << f(1, 2, g) << '\n';

    /*
    这里不能直接传g.operator(), 因为在C++中，成员函数指针和普通函数指针是不兼容的，
    因为它们有不同的调用约定。成员函数指针需要隐式地包含this指针，
    以指向调用它的对象。而普通函数指针则不需要。
    所以此处用lambda表达式再包装一下
    */
    cout << fun(1, 2, [](const int &a, const int &b) -> bool {
        return greater<int>()(a, b);
    }) << '\n';


    cout << "end\n";

    return 0;
}