Создание функтора из выражения лямбда

Question

Я хотел бы знать, можно ли создать реальный объект-функтор из выражения лямбда. Я так не думаю, но если нет, то почему?

В качестве иллюстрации приведен ниже код, который сортирует точки, используя различные политики для й и у координат:

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

struct Point 
{ 
    Point(int x, int y) : x(x), y(y) {} 
    int x, y; 
}; 

template <class XOrder, class YOrder> 
struct SortXY : 
    std::binary_function<const Point&, const Point&, bool> 
{ 
    bool operator()(const Point& lhs, const Point& rhs) const 
    { 
     if (XOrder()(lhs.x, rhs.x)) 
      return true; 
     else if (XOrder()(rhs.x, lhs.x)) 
      return false; 
     else 
      return YOrder()(lhs.y, rhs.y); 
    }   
}; 

struct Ascending { bool operator()(int l, int r) const { return l<r; } }; 
struct Descending { bool operator()(int l, int r) const { return l>r; } }; 

int main() 
{ 
    // fill vector with data 
    std::vector<Point> pts; 
    pts.push_back(Point(10, 20)); 
    pts.push_back(Point(20, 5)); 
    pts.push_back(Point(5, 0)); 
    pts.push_back(Point(10, 30)); 

    // sort array 
    std::sort(pts.begin(), pts.end(), SortXY<Descending, Ascending>()); 

    // dump content 
    std::for_each(pts.begin(), pts.end(), 
        [](const Point& p) 
        { 
        std::cout << p.x << "," << p.y << "\n"; 
        }); 
} 

Выражения std::sort(pts.begin(), pts.end(), SortXY<Descending, Ascending>()); сорта согласно убыванию значения х, а затем к значениям у восходящих. Это легко понять, и я не уверен, что я действительно хочу использовать лямбда-выражения здесь.

Но если бы я хотел заменить Восходящий/Нисходящий по лямбда-выражениям, как бы вы это сделали? Следующий не действует:

std::sort(pts.begin(), pts.end(), SortXY< 
    [](int l, int r) { return l>r; }, 
    [](int l, int r) { return l<r; } 
>()); 

Answer 1

Эта проблема возникает потому, что SortXY принимает только типы, в то время как лямбды объекты. Вам нужно переписать его так, чтобы он занимал объекты, а не только типы. Это основное использование функциональных объектов - см. То, как std::for_each не берет тип, он принимает объект.

Answer 2

Я опубликовал аналогичный вопрос w.r.t. лямбда-функторы внутри классов. Проверьте это, возможно, это помогает:

Lambda expression as member functors in a class

Answer 3

У меня была аналогичная проблема: Требовалось обеспечить в некоторых случаях «сырой» указатель -функции и в другой функтор. Так что я придумал «обходной путь», как это:

template<class T> 
class Selector 
{ 
public: 
    Selector(int (*theSelector)(T& l, T& r)) 
     : selector(theSelector) {} 

    virtual int operator()(T& l, T& r) { 
     return selector(l, r); 
    } 

    int (*getRawSelector() const)(T&, T&) { 
     return this->selector; 
    } 

private: 
    int(*selector)(T& l, T& r); 
}; 

Если у вас есть две очень простые функции, принимающие --- как описано --- либо функтор или сырой указатель на функцию, как это:

int 
findMinWithFunctor(int* array, int size, Selector<int> selector) 
{ 
    if (array && size > 0) { 
     int min = array[0]; 
     for (int i = 0; i < size; i++) { 
      if (selector(array[i], min) < 0) { 
       min = array[i]; 
      } 
     } 
     return min; 
    } 
    return -1; 
} 

int 
findMinWithFunctionPointer(int* array, int size, int(*selector)(int&, int&)) 
{ 
    if (array && size > 0) { 
     int min = array[0]; 
     for (int i = 0; i < size; i++) { 
      if (selector(array[i], min) < 0) { 
       min = array[i]; 
      } 
     } 
     return min; 
    } 
    return -1; 
} 

Тогда вы могли бы назвать это такие функции, как это:

int numbers[3] = { 4, 2, 99 }; 

cout << "The min with functor is:" << findMinWithFunctor(numbers, 3, Selector<int>([](int& l, int& r) -> int {return (l > r ? 1 : (r > l ? -1 : 0)); })) << endl; 


// or with the plain version 
cout << "The min with raw fn-pointer is:" << findMinWithFunctionPointer(numbers, 3, Selector<int>([](int& l, int& r) -> int {return (l > r ? 1 : (r > l ? -1 : 0)); }).getRawSelector()) << endl; 

конечно, в этом примере нет никакой реальной пользы прохождения INT в качестве ссылки ... это просто пример :-)

Улучшения:

Вы также можете изменить класс Selector, чтобы быть более кратким, как это:

template<class T> 
class Selector 
{ 
public: 

    typedef int(*selector_fn)(T& l, T& r); 

    Selector(selector_fn theSelector) 
     : selector(theSelector) {} 

    virtual int operator()(T& l, T& r) { 
     return selector(l, r); 
    } 

    selector_fn getRawSelector() { 
     return this->selector; 
    } 

private: 
    selector_fn selector; 
}; 

Здесь мы пользуемся простой ЬурейеЕ для того, чтобы определить указатель на функцию один раз и используйте только его имя, а не повторяя декларацию снова и снова.