Question

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

// 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结果对其进行排序吗？

Answer 1

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

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

它比你的版本长，但在调用sort之前你不需要写任何东西。

如果你需要经常做那种事情，你可以把所有东西都放在一个小算器中（并允许它适用于A，A*和智能指针），它使用{{ 3}}（感谢@TC）：

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));

Answer 2

我建议不要因为考虑到一个特定的用例而重载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));

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

2 个答案: