将成员指针作为比较器/“键”的 std 算法

Question

我经常发现自己将std::sort、std::max_element 等与简单调用成员函数的 lambda 结合使用

std::vector<MyType> vec;
// populate...
auto m = std::max_element(std::begin(vec), std::end(vec),
    [](const MyType& a, const MyType& b) { return a.val() < b.val()})

这感觉像是在浪费字符和清晰度。我知道我可以编写另一个函数/可调用函数并将函数指针/可调用对象传递给这些算法函数，但我经常需要在程序中只进行一次排序，这对我来说并不好解决问题的方法。理想情况下，我想做的是：

auto m = std::max_element(std::begin(vec), std::end(vec), &MyType::val);

并让对象按它们的val()s 排序。我忽略的标准库的某些部分是否可以帮助我解决这个问题？或另一种简单的方法？我想让排序或搜索的内容尽可能明显。

我知道仅&MyType::val 是不够的，我正在寻找可以包装它的东西，或者提供类似的功能而不会模糊其含义。

Answer 1

为了避免需要使用std::mem_fn，对sehes 答案的改进是为compare_by 函数提供指向成员重载的指针。

示例用法

std::sort(std::begin(vec), std::end(vec), compare_by(&MyType::field));
std::sort(std::begin(vec), std::end(vec), compare_by(&MyType::field, std::greater<>{}));

要实现的代码

#include <functional> // std::less
#include <utility> // std::move
#include <type_traits> // std::is_invocable_r
// Forward declaration
template<typename R, typename T, typename F = std::less<R>>
auto compare_by(R T::*, F = F{});

// Implementation
namespace detail {
template<typename T, typename F>
struct compare_by_t;

template<typename R, typename T, typename F>
struct compare_by_t<R T::*, F> : private F
{
    compare_by_t(F&& f, R T::*m): F{std::move(f)}, _member{m} {}
    R T::* _member;
    bool operator()(T const& x, T const& y) const
    {
        return F::operator()(x .* _member, y .* _member);
    }
};
} // detail

template<typename R, typename T, typename F>
auto compare_by(R T::* member, F f)
{
    static_assert(std::is_invocable_r<bool, F, R, R>::value);
    return detail::compare_by_t<R T::*, F>{ std::move(f), member };
}

Answer 2

您可以做到without 引入任何新功能（模板化或非模板化）。

Just 使用bind 和std::less

auto m = std::max_element(vec.begin(), vec.end(), 
    bind(less<>(), bind(&MyType::val, _1), bind(&MyType::val, _2)));

Answer 3

您可以使用std::mem_fn（或std::tr1::mem_fn）

int main()
{
    std::vector<MyType> vec;

    auto m = std::max_element(std::begin(vec), std::end(vec), compare_by(std::mem_fn(&MyType::field)));
}

当然，这假设您的工具箱中有一个类似compare_by 的实用程序（您应该这样做:)）：

template <typename F>
struct CompareBy {
    explicit CompareBy(F&& f) : f(std::forward<F>(f)) {}
    template <typename U, typename V> 
        bool  operator()(U const& u, V const& v) const {
            return f(u) < f(v);
        }

private:
    F f;
};

template <typename F>
CompareBy<F> compare_by(F&& f) { return CompareBy<F>(std::forward<F>(f)); }

看Live On Coliru

Answer 4

为您的自定义类型重载operator< 怎么样？这可以在类内部（或直接在它旁边）自然地完成，然后在迭代器之外不需要进一步的参数。

传递你的val() 函数是不可能的，因为你必须传递一个二元运算符。

编辑：在阅读了其他有价值的替代方案（也是很好的回应）之后，我想确认我在下面的评论中已经提到的内容：在我看来，没有什么比 lambda 表达式的可读性、局部性和灵活性更好的了（- -关于将某些段落写两次的风险）。

@Ryan Haining：我建议您保留原帖中的内容。

Answer 5

模板化比较器可以帮助您：

template <typename StructureType,
          typename MemberType,
          MemberType StructureType::*member>
bool comparator(const StructureType& the_first, const StructureType& the_second)
{
  return the_first.*member < the_second.*member;
}

http://ideone.com/K8ytav

一点类型特征的魔法当然可以让你避免编写类型。