Сортировка вектора объектов по свойству объекта

Ответ 1

Существует несколько разных объектов и несколько разных свойств, которые можно было бы отсортировать.

В то время как решение Erik опубликовано правильно, это утверждение заставляет меня думать, что это непрактично в лучшем случае, если вы на самом деле планируете сортировать несколькими публичными элементами данных нескольких классов несколькими способами в одной и той же программе, так как каждый метод сортировки потребуется собственный тип функтора.

Я рекомендую следующую абстракцию:

#include <functional>

template<typename T, typename M, template<typename> class C = std::less>
struct member_comparer : std::binary_function<T, T, bool>
{
    explicit member_comparer(M T::*p) : p_(p) { }

    bool operator ()(T const& lhs, T const& rhs) const
    {
        return C<M>()(lhs.*p_, rhs.*p_);
    }

private:
    M T::*p_;
};

template<typename T, typename M>
member_comparer<T, M> make_member_comparer(M T::*p)
{
    return member_comparer<T, M>(p);
}

template<template<typename> class C, typename T, typename M>
member_comparer<T, M, C> make_member_comparer2(M T::*p)
{
    return member_comparer<T, M, C>(p);
}

Использование будет выглядеть так:

#include <algorithm>
#include <vector>
#include <string>

struct MyClass
{
    int i;
    std::string s;

    MyClass(int i_, std::string const& s_) : i(i_), s(s_) { }
};

int main()
{
    std::vector<MyClass> vec;
    vec.push_back(MyClass(2, "two"));
    vec.push_back(MyClass(8, "eight"));

    // sort by i, ascending
    std::sort(vec.begin(), vec.end(), make_member_comparer(&MyClass::i));
    // sort by s, ascending
    std::sort(vec.begin(), vec.end(), make_member_comparer(&MyClass::s));
    // sort by s, descending
    std::sort(vec.begin(), vec.end(), make_member_comparer2<std::greater>(&MyClass::s));
}

Это будет работать для любого типа с общедоступными элементами данных и сэкономит много информации, если вам нужно отсортировать свои классы более чем несколькими способами.

Вот вариант, который работает с публичными функциями-членами вместо публичных элементов данных:

#include <functional>

template<typename T, typename M, template<typename> class C = std::less>
struct method_comparer : std::binary_function<T, T, bool>
{
    explicit method_comparer(M (T::*p)() const) : p_(p) { }

    bool operator ()(T const& lhs, T const& rhs) const
    {
        return C<M>()((lhs.*p_)(), (rhs.*p_)());
    }

private:
    M (T::*p_)() const;
};

template<typename T, typename M>
method_comparer<T, M> make_method_comparer(M (T::*p)() const)
{
    return method_comparer<T, M>(p);
}

template<template<typename> class C, typename T, typename M>
method_comparer<T, M, C> make_method_comparer2(M (T::*p)() const)
{
    return method_comparer<T, M, C>(p);
}

С использованием, например:

#include <algorithm>
#include <vector>
#include <string>

class MyClass
{
    int i_;
    std::string s_;

public:
    MyClass(int i, std::string const& s) : i_(i), s_(s) { }

    int i() const { return i_; }
    std::string const& s() const { return s_; }
};

int main()
{
    std::vector<MyClass> vec;
    vec.push_back(MyClass(2, "two"));
    vec.push_back(MyClass(8, "eight"));

    // sort by i(), ascending
    std::sort(vec.begin(), vec.end(), make_method_comparer(&MyClass::i));
    // sort by s(), ascending
    std::sort(vec.begin(), vec.end(), make_method_comparer(&MyClass::s));
    // sort by s(), descending
    std::sort(vec.begin(), vec.end(), make_method_comparer2<std::greater>(&MyClass::s));
}

Ответ 2

Используйте std::sort и функтор. например:

struct SortByX
{
   bool operator() const (MyClass const & L, MyClass const & R) { return L.x < R.x; }
};

std::sort(vec.begin(), vec.end(), SortByX());

Оператор функтора() должен возвращать значение true, если L меньше, чем R для порядка сортировки, который вы желаете.

Ответ 3

Вот моя версия ответа, просто используйте функцию лямбда! Он работает, он использует меньше кода, и, на мой взгляд, он изящный!

#include <algorithm>
#include <vector>
#include <string>

struct MyClass
{
    int i;
    std::string s;

    MyClass(int i_, std::string const& s_) : i(i_), s(s_) { }
};

int main()
{
    std::vector<MyClass> vec;
    vec.push_back(MyClass(2, "two"));
    vec.push_back(MyClass(8, "eight"));

    // sort by i, ascending
    std::sort(vec.begin(), vec.end(), [](MyClass a, MyClass b){ return a.i < b.i; });
    // sort by s, ascending
    std::sort(vec.begin(), vec.end(), [](MyClass a, MyClass b){ return a.s < b.s; });
    // sort by s, descending
    std::sort(vec.begin(), vec.end(), [](MyClass a, MyClass b){ return a.s > b.s; });
}

Ответ 4

EDIT: замена lambda_compare, потому что я мазохист:

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

template <class F> class lambda_compare
{
public:
    lambda_compare(F f_): f(f_) { }
    template <class T> bool operator()(const T &lhs, const T &rhs) const
    { return f(lhs)<f(rhs); }

private:
    F f;
};

template <class F> lambda_compare<F> make_lambda_compare(F f)
{ return f; }

...
std::sort(vec.begin(), vec.end(), make_lambda_compare([](const foo &value) { return value.member; }));