基于成员字段或函数创建比较器的快捷方式

Question

我经常发现自己想为 struct 或 class 创建一个比较器对象，它只是提取类的一个成员，并对其进行通常的 < 比较。

例如：

struct student {
   int id;
   std::string name;
};

// sort by ID
std::sort(students.begin(), students.end(), [](const student& l, const student& r){ return l.id < r.id; });

那里有很多样板，特别是因为我们必须重复 l 和 r 的声明。标准库中是否有一种方法可以创建基于“提取器”函数的比较器，该函数返回要比较的对象？

类似：

std::sort(students.begin(), students.end(), compare_on([](const student& s){ return s.id; });

我正在使用 C++11，但我也对后续标准中不适用于 C++11 的解决方案感兴趣（因此我可以在我的“升级原因”列表中添加一些内容）。

我在这里询问有关使用单个成员作为 comprand 的问题，以及默认比较“小于”，但对于易于组合的技术的奖励积分，例如允许您按字典顺序使用两个字段，或更改比较运算符。

Answer 1

您实际上正在寻找的是允许将 投影 传递到算法中。 N4128 为标准库提出了这个建议，C++20 将在许多算法中提供这些。

但在那之前，我们可以自己做这件事。写一个sort的新重载：

struct identity {
    template <typename T>
    T&& operator()(T&& t) const noexcept { return std::forward<T>(t); }
};

// because no std::less<> in C++11 yet
struct less {
    template <typename T, typename U>
    constexpr bool operator()(T const& lhs, U const& rhs) const {
        return lhs < rhs;
    }
};

template <typename Range, typename Comp=less, typename Proj=identity>
void sort_proj(Range& range, Comp comp={}, Proj proj={}) {
    using std::begin;
    using std::end;
    auto first = begin(range), last = end(range);
    using reference = typename std::iterator_traits<decltype(first)>::reference;

    std::sort(first, last,
        [&](reference lhs, reference rhs) {
            return comp(std::ref(proj)(lhs), std::ref(proj)(rhs));
        });
}

std::ref(f)(x) 是在 C++11 中获得 INVOKE 功能的技巧。它基本上允许您将指向成员的指针作为投影传递。这个实现可以让你写：

sort_proj(students, less{}, &student::id);

请注意，投影与排序无关。所以我可以很容易地做各种事情：

sort_proj(students);                            // sort on students, if they're ordered
sort_proj(students, greater{}, &student::name); // decreasing, by name
sort_proj(students, less{},                     // by name, then id
    [](student const& s) {
        return std::tie(s.name, s.id);
    });

---

这种方法超级对于从一般算法中消除大量样板文件非常有用。我有一个标题，其中充满了许多常用标准算法的基于投影的重载。

Answer 2

您可以定义一个实用程序类

template <class Fct> class compare_on {
  public:
    compare_on(Fct&& get) : get(std::forward<Fct>(get)) {}

    template <class T> bool operator()(const T& lhs, const T& rhs)
    {
       return get(lhs) < get(rhs);
    }

  private:
    Fct get;
};

然后将它传递给std::sort，就像你描述的那样（使用 C++17 类模板参数推导）

std::sort(students.begin(), students.end(),
    compare_on([](const student& s){ return s.id; }));

从 C++17 开始，@Justin 在 cmets 中指出实际比较可以改进（使用#include <functional>），这样

return std::invoke(get, lhs) < std::invoke(get, rhs);

允许使用数据成员引用进行实例化：

std::sort(students.begin(), students.end(), compare_on(&student::id));

当绑定到 C++11 时，忘记 std::invoke 并使用 compare_on 的显式实例化。后者不适用于 lambda，因此通常使用参数推导 make_* 助手：

template <class Fct> auto make_compare_on(Fct&& get)
    -> decltype(compare_on<Fct>(std::forward<Fct>(get)))
{
    return compare_on<Fct>(std::forward<Fct>(get));
}

请注意，您可以在 C++14 中删除尾随返回类型。

最后一点，这里的命名应该改进：compare_on 具有误导性，因为它隐藏了函数对象的真正作用——通过operator < 进行比较。也许compare_less_then 或类似的东西会更好，或者添加另一个可以指定为标准谓词之一的模板参数（std::less 等）。

Answer 3

根据您的建议，我提出这样的compare_on：

template<class T>
auto compare_on(T &&t){
    return [t](const auto &l, const auto &r){
        return l.*t < r.*t; 
    };
}
... 
std::sort(students.begin(), students.end(), compare_on(&student::id));

它需要 C++14。它使用指向成员的指针来准确获取您要求的行为。

在 C++11 中，使用类似的想法，它看起来像这样：

template<class U>
class comparison{
public:
    comparison(const U &ptr) : memberPtr(ptr){}

    template<class T>
    int operator()(const T &l, const T &r){
        return l.*memberPtr < r.*memberPtr;
    }

private:
    U memberPtr;
};

template<class T>
comparison<T> compare_on(T &&t){
    return comparison<T>(std::forward<T>(t));
}

正如@Barry 建议的那样，您应该将所有l.*t 替换为std::invoke(t, l) 以使其在C++ 17 中更通用。

Answer 4

range-v3 实现投影：

// sort by ID
ranges::sort(students, std::less<>{}, &student::id);