基于getter成员函数对STL容器进行排序，无需编写额外代码

sort a STL container based on a getter member function, with no extra code written

本文关键字：代码 排序 函数 成员 getter STL 基于      更新时间：2023-10-16

让我们考虑以下代码示例：

// Example program
#include <iostream>
#include <string>
#include <algorithm>
class A
{
public:
    A( const std::string& name ) : name( name ) {}
    inline const std::string& getName() const { return name; }
private:
    std::string name;
};
int main()
{
    std::vector<A> v;
    v.push_back( A("b") );
    v.push_back( A("a") );
    // want to sort the container, based on it's name!
}

我知道如何做到这一点（要么定义一个内部或外部operator<，要么声明一个提供operator()的函子结构/类，并将其传递给std::sort函数），例如：

bool operator<( const A& a ) const
{
    return getName() < a.getName();
}

然而，每当我想根据包含的类属性对容器进行排序时，尤其是当类为其提供getter函数时，我就懒得这样做了

是否可以请求基于类成员函数结果值进行排序（显然，如果这个函数有可用的比较器）？

类似于：

std::sort( v.begin(), v.end(), &(A::getName) );

不必声明新的运算符或函子？

可选问题：若矢量包含指针（std::vector<A*> v）。。。一行语句可以根据A::getName结果对其进行排序吗？

您可以使用lambda函数对向量进行排序：

std::sort(v.begin(), v.end(), [] (A const& a, A const& b) {
        return a.getName() < b.getName();
    });

它比您的版本长，但在调用sort之前您不需要编写任何内容。

如果你需要经常做这种事情，你可以把所有的东西都放在一个小函数中（并允许它同时适用于A、A*和智能指针），它使用mem_fn（多亏了@T.C.）：

template <typename T, typename R>
struct cmp_attr {
    using fun_t = R (T::*) () const;
    cmp_attr (fun_t g) : _g(g) { }
    template <typename U>
    bool operator() (U const& a, U const& b) const {
        auto fn = std::mem_fn(_g);
        return fn(a) < fn(b);
    }
private:
    fun_t _g;
};
// Utility function to have template parameters deduced, a like std::make_pair
template<typename T, typename R>
auto make_cmp_attr (R (T::*g) () const) {
    return cmp_attr<T, R>(g);
}

然后：

struct A { const std::string& getName(); }
struct B: public A { }
std::vector<A> v1; // vector of A
std::sort(v1.begin(), v1.end(), make_cmp_attr(&A::getName));
std::vector<A*> v2; // vector of A*
std::sort(v2.begin(), v2.end(), make_cmp_attr(&A::getName));
std::vector<B> v3; // vector of child class
std::sort(v3.begin(), v3.end(), make_cmp_attr(&A::getName));
std::vector<B*> v4; // vector of pointer of child class
std::sort(v4.begin(), v4.end(), make_cmp_attr(&A::getName));

我建议不要因为有一个特定的用例就重载operator<。将排序逻辑放在需要的地方；它不是类型的一部分。

如果你想定期按投影排序，那么写一个小助手可能是值得的：

template <typename C, typename R>
struct SortByPred
{
    using P = R (C::*)() const;
    P const p_;
    SortByPred(P p) : p_(p) {}
    template <typename T>
    bool operator()(T const & lhs, T const & rhs) const
    {
        return (lhs.*p_)() < (rhs.*p_)();
    }
};
template <typename C, typename R>
SortByPred<C, R> SortBy(R (C::*p)() const)
{
    return SortByPred<C, R>(p);
}

用法：

std::sort(v.begin(), v.end(), SortBy(&A::getName));
相关文章：