it-swarm.com.ru

Сортировка вектора пользовательских объектов

Как выполнить сортировку вектора, содержащего пользовательские (то есть определенные пользователем) объекты?.
Вероятно, стандартный алгоритм STL sort вместе с предикатом (функцией или объектом функции), который будет работать с одним из полей (в качестве ключа для сортировки) в пользовательском объекте, должен использоваться.
Я на правильном пути?

223
Ankur

Простой пример с использованием std::sort

struct MyStruct
{
    int key;
    std::string stringValue;

    MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}
};

struct less_than_key
{
    inline bool operator() (const MyStruct& struct1, const MyStruct& struct2)
    {
        return (struct1.key < struct2.key);
    }
};

std::vector < MyStruct > vec;

vec.Push_back(MyStruct(4, "test"));
vec.Push_back(MyStruct(3, "a"));
vec.Push_back(MyStruct(2, "is"));
vec.Push_back(MyStruct(1, "this"));

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

Редактировать: Как указал Кирилл В. Лядвинский, вместо предоставления предиката сортировки вы можете реализовать operator< для MyStruct:

struct MyStruct
{
    int key;
    std::string stringValue;

    MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}

    bool operator < (const MyStruct& str) const
    {
        return (key < str.key);
    }
};

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

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

Edit2: Как предполагает Каппа, вы также можете отсортировать вектор в порядке убывания, перегрузив оператор > и немного изменив вызов сортировки:

struct MyStruct
{
    int key;
    std::string stringValue;

    MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}

    bool operator > (const MyStruct& str) const
    {
        return (key > str.key);
    }
};

И вы должны назвать сортировку как:

std::sort(vec.begin(), vec.end(),greater<MyStruct>());
330
Alan

В интересах освещения. Я выдвинул реализацию, используя лямбда-выражения .

C++ 11

#include <vector>
#include <algorithm>

using namespace std;

vector< MyStruct > values;

sort( values.begin( ), values.end( ), [ ]( const MyStruct& lhs, const MyStruct& rhs )
{
   return lhs.key < rhs.key;
});

C++ 14

#include <vector>
#include <algorithm>

using namespace std;

vector< MyStruct > values;

sort( values.begin( ), values.end( ), [ ]( const auto& lhs, const auto& rhs )
{
   return lhs.key < rhs.key;
});
142
Corvusoft

Вы можете использовать functor в качестве третьего аргумента std::sort, или вы можете определить operator< в вашем классе.

struct X {
    int x;
    bool operator<( const X& val ) const { 
        return x < val.x; 
    }
};

struct Xgreater
{
    bool operator()( const X& lx, const X& rx ) const {
        return lx.x < rx.x;
    }
};

int main () {
    std::vector<X> my_vec;

    // use X::operator< by default
    std::sort( my_vec.begin(), my_vec.end() );

    // use functor
    std::sort( my_vec.begin(), my_vec.end(), Xgreater() );
}
52
Kirill V. Lyadvinsky

Ты на правильном пути. std::sort будет использовать operator< в качестве функции сравнения по умолчанию. Поэтому для сортировки ваших объектов вам придется либо перегружать bool operator<( const T&, const T& ), либо предоставить функтор, который выполняет сравнение, примерно так:

 struct C {
    int i;
    static bool before( const C& c1, const C& c2 ) { return c1.i < c2.i; }
 };

 bool operator<( const C& c1, const C& c2 ) { return c1.i > c2.i; }

 std::vector<C> values;

 std::sort( values.begin(), values.end() ); // uses operator<
 std::sort( values.begin(), values.end(), C::before );

Преимущество использования функтора заключается в том, что вы можете использовать функцию с доступом к закрытым членам класса.

13
xtofl

Сортировка такого vector или любого другого применимого (изменяемого входного итератора) диапазона пользовательских объектов типа X может быть достигнута с использованием различных методов, особенно включая использование стандартных библиотечных алгоритмов, таких как

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

"Лучший" подход будет зависеть от разных факторов:

  1. Являются ли диапазоны сортировки объектов X общей или редкой задачей (будут ли эти диапазоны отсортированы в нескольких местах в программе или пользователями библиотеки)?
  2. Является ли требуемая сортировка "естественной" (ожидаемой) или существует несколько способов сравнения типа с самим собой?
  3. Является ли производительность проблемой, или диапазоны сортировки объектов X должны быть надежными?

Если диапазоны сортировки X являются распространенной задачей и ожидаемая сортировка должна ожидаться (т. Е. X просто переносит одно фундаментальное значение), тогда on, вероятно, будет идти на перегрузку operator<, так как она позволяет сортировать без какого-либо размытия (например, правильно передавая надлежащие компараторы) и неоднократно дает ожидаемые результаты.

Если сортировка является обычной задачей или, вероятно, потребуется в различных контекстах, но есть несколько критериев, которые можно использовать для сортировки объектов X, я бы выбрал Functors (перегруженные функции operator() пользовательских классов) или указатели на функции (т.е. один функтор/функция для лексического упорядочения и еще одна для естественного упорядочения).

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

Это особенно верно, если сортировка не является "чистой" или "естественной" в некотором роде. Вы можете легко понять логику упорядочения, глядя на лямбду, которая применяется на месте, тогда как operator< с первого взгляда непрозрачна, и вам придется поискать определение, чтобы знать, какая логика упорядочения будет применяться.

Однако обратите внимание, что одно определение operator< представляет собой одну точку отказа, тогда как несколько лямб - это несколько точек отказа и требуют большей осторожности.

Если определение operator< недоступно там, где выполняется сортировка/шаблон сортировки скомпилирован, компилятор может быть вынужден выполнить вызов функции при сравнении объектов, вместо того, чтобы вставлять логику упорядочения, которая может быть серьезным недостатком (по крайней мере, когда оптимизация времени ссылки/генерация кода не применяется).

Способы достижения сопоставимости class X для использования стандартных алгоритмов сортировки библиотеки

Пусть std::vector<X> vec_X; и std::vector<Y> vec_Y;

1. Перегрузите T::operator<(T) или operator<(T, T) и используйте стандартные библиотечные шаблоны, которые не ожидают функции сравнения.

Либо член перегрузки operator<:

struct X {
  int i{}; 
  bool operator<(X const &r) const { return i < r.i; } 
};
// ...
std::sort(vec_X.begin(), vec_X.end());

или бесплатный operator<:

struct Y {
  int j{}; 
};
bool operator<(Y const &l, Y const &r) { return l.j < r.j; }
// ...
std::sort(vec_Y.begin(), vec_Y.end());

2. Используйте указатель функции с пользовательской функцией сравнения в качестве параметра функции сортировки.

struct X {
  int i{};  
};
bool X_less(X const &l, X const &r) { return l.i < r.i; }
// ...
std::sort(vec_X.begin(), vec_X.end(), &X_less);

3. Создайте перегрузку bool operator()(T, T) для пользовательского типа, которую можно передать в качестве функтора сравнения.

struct X {
  int i{};  
  int j{};
};
struct less_X_i
{
    bool operator()(X const &l, X const &r) const { return l.i < r.i; }
};
struct less_X_j
{
    bool operator()(X const &l, X const &r) const { return l.j < r.j; }
};
// sort by i
std::sort(vec_X.begin(), vec_X.end(), less_X_i{});
// or sort by j
std::sort(vec_X.begin(), vec_X.end(), less_X_j{});

Эти определения функциональных объектов могут быть написаны немного более обобщенно, используя C++ 11 и шаблоны:

struct less_i
{ 
    template<class T, class U>
    bool operator()(T&& l, U&& r) const { return std::forward<T>(l).i < std::forward<U>(r).i; }
};

который можно использовать для сортировки любого типа с членом i, поддерживающим <.

4. Передайте анонимное закрытие (лямбда) в качестве параметра сравнения в функции сортировки.

struct X {
  int i{}, j{};
};
std::sort(vec_X.begin(), vec_X.end(), [](X const &l, X const &r) { return l.i < r.i; });

Где C++ 14 обеспечивает еще более общее лямбда-выражение:

std::sort(a.begin(), a.end(), [](auto && l, auto && r) { return l.i < r.i; });

который можно обернуть в макрос

#define COMPARATOR(code) [](auto && l, auto && r) -> bool { return code ; }

сделать обычное создание компаратора довольно плавным:

// sort by i
std::sort(v.begin(), v.end(), COMPARATOR(l.i < r.i));
// sort by j
std::sort(v.begin(), v.end(), COMPARATOR(l.j < r.j));
11
Pixelchemist

Да, std::sort() с третьим параметром (функция или объект) будет проще. Пример: http://www.cplusplus.com/reference/algorithm/sort/

4
swatkat

В вашем классе вы можете перегрузить оператор "<".

class MyClass
{
  bool operator <(const MyClass& rhs)
  {
    return this->key < rhs.key;
  }
}
3
BobbyShaftoe

Мне было любопытно, есть ли какое-либо измеримое влияние на производительность между различными способами, которые можно вызвать std :: sort, поэтому я создал этот простой тест:

$ cat sort.cpp
#include<algorithm>
#include<iostream>
#include<vector>
#include<chrono>

#define COMPILER_BARRIER() asm volatile("" ::: "memory");

typedef unsigned long int ulint;

using namespace std;

struct S {
  int x;
  int y;
};

#define BODY { return s1.x*s2.y < s2.x*s1.y; }

bool operator<( const S& s1, const S& s2 ) BODY
bool Sgreater_func( const S& s1, const S& s2 ) BODY

struct Sgreater {
  bool operator()( const S& s1, const S& s2 ) const BODY
};

void sort_by_operator(vector<S> & v){
  sort(v.begin(), v.end());
}

void sort_by_lambda(vector<S> & v){
  sort(v.begin(), v.end(), []( const S& s1, const S& s2 ) BODY );
}

void sort_by_functor(vector<S> &v){
  sort(v.begin(), v.end(), Sgreater());
}

void sort_by_function(vector<S> &v){
  sort(v.begin(), v.end(), &Sgreater_func);
}

const int N = 10000000;
vector<S> random_vector;

ulint run(void foo(vector<S> &v)){
  vector<S> tmp(random_vector);
  foo(tmp);
  ulint checksum = 0;
  for(int i=0;i<tmp.size();++i){
     checksum += i *tmp[i].x ^ tmp[i].y;
  }
  return checksum;
}

void measure(void foo(vector<S> & v)){

ulint check_sum = 0;

  // warm up
  const int WARMUP_ROUNDS = 3;
  const int TEST_ROUNDS = 10;

  for(int t=WARMUP_ROUNDS;t--;){
    COMPILER_BARRIER();
    check_sum += run(foo);
    COMPILER_BARRIER();
  }

  for(int t=TEST_ROUNDS;t--;){
    COMPILER_BARRIER();
    auto start = std::chrono::high_resolution_clock::now();
    COMPILER_BARRIER();
    check_sum += run(foo);
    COMPILER_BARRIER();
    auto end = std::chrono::high_resolution_clock::now();
    COMPILER_BARRIER();
    auto duration_ns = std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count();

    cout << "Took " << duration_ns << "s to complete round" << endl;
  }

  cout << "Checksum: " << check_sum << endl;
}

#define M(x) \
  cout << "Measure " #x " on " << N << " items:" << endl;\
  measure(x);

int main(){
  random_vector.reserve(N);

  for(int i=0;i<N;++i){
    random_vector.Push_back(S{Rand(), Rand()});
  }

  M(sort_by_operator);
  M(sort_by_lambda);
  M(sort_by_functor);
  M(sort_by_function);
  return 0;
}

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

Я компилировал с g ++ (GCC) 7.2.1 20170829 (Red Hat 7.2.1-1)

$ g++ -O2 -o sort sort.cpp && ./sort

Вот результаты:

Measure sort_by_operator on 10000000 items:
Took 0.994285s to complete round
Took 0.990162s to complete round
Took 0.992103s to complete round
Took 0.989638s to complete round
Took 0.98105s to complete round
Took 0.991913s to complete round
Took 0.992176s to complete round
Took 0.981706s to complete round
Took 0.99021s to complete round
Took 0.988841s to complete round
Checksum: 18446656212269526361
Measure sort_by_lambda on 10000000 items:
Took 0.974274s to complete round
Took 0.97298s to complete round
Took 0.964506s to complete round
Took 0.96899s to complete round
Took 0.965773s to complete round
Took 0.96457s to complete round
Took 0.974286s to complete round
Took 0.975524s to complete round
Took 0.966238s to complete round
Took 0.964676s to complete round
Checksum: 18446656212269526361
Measure sort_by_functor on 10000000 items:
Took 0.964359s to complete round
Took 0.979619s to complete round
Took 0.974027s to complete round
Took 0.964671s to complete round
Took 0.964764s to complete round
Took 0.966491s to complete round
Took 0.964706s to complete round
Took 0.965115s to complete round
Took 0.964352s to complete round
Took 0.968954s to complete round
Checksum: 18446656212269526361
Measure sort_by_function on 10000000 items:
Took 1.29942s to complete round
Took 1.3029s to complete round
Took 1.29931s to complete round
Took 1.29946s to complete round
Took 1.29837s to complete round
Took 1.30132s to complete round
Took 1.3023s to complete round
Took 1.30997s to complete round
Took 1.30819s to complete round
Took 1.3003s to complete round
Checksum: 18446656212269526361

Похоже, что все параметры, за исключением передачи указателя на функцию, очень похожи, а передача указателя на функцию вызывает штраф + 30%.

Кроме того, похоже, что оператор <версия работает на ~ 1% медленнее (я повторил тест несколько раз, и эффект сохраняется), что немного странно, поскольку предполагает, что сгенерированный код отличается (мне не хватает навыков для анализа --save- вывод временных данных).

2
qbolec

Ниже приведен код с использованием лямбда

#include "stdafx.h"
#include <vector>
#include <algorithm>

using namespace std;

struct MyStruct
{
    int key;
    std::string stringValue;

    MyStruct(int k, const std::string& s) : key(k), stringValue(s) {}
};

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

    vec.Push_back(MyStruct(4, "test"));
    vec.Push_back(MyStruct(3, "a"));
    vec.Push_back(MyStruct(2, "is"));
    vec.Push_back(MyStruct(1, "this"));

    std::sort(vec.begin(), vec.end(), 
        [] (const MyStruct& struct1, const MyStruct& struct2)
        {
            return (struct1.key < struct2.key);
        }
    );
    return 0;
}
2
Sathwick

Вы можете использовать пользовательский класс компаратора.

class comparator
{
    int x;
    bool operator()( const comparator &m,  const comparator &n )
    { 
       return m.x<n.x;
    }
 }
1
user8385974
    // sort algorithm example
    #include <iostream>     // std::cout
    #include <algorithm>    // std::sort
    #include <vector>       // std::vector
    using namespace std;
    int main () {
        char myints[] = {'F','C','E','G','A','H','B','D'};
        vector<char> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33
        // using default comparison (operator <):
        sort (myvector.begin(), myvector.end());           //(12 32 45 71)26 80 53 33
        // print out content:
        cout << "myvector contains:";
        for (int i=0; i!=8; i++)
            cout << ' ' <<myvector[i];
        cout << '\n';
        system("PAUSE");
    return 0;
    }
1
Amin Alomaisi

Для сортировки вектора вы можете использовать алгоритм sort ().

sort(vec.begin(),vec.end(),less<int>());

Третий используемый параметр может быть больше или меньше, или также может использоваться любая функция или объект. Однако оператор по умолчанию - <, если вы оставите третий параметр пустым.

// using function as comp
std::sort (myvector.begin()+4, myvector.end(), myfunction);
bool myfunction (int i,int j) { return (i<j); }

// using object as comp
std::sort (myvector.begin(), myvector.end(), myobject);
0
Prashant Shubham
typedef struct Freqamp{
    double freq;
    double amp;
}FREQAMP;

bool struct_cmp_by_freq(FREQAMP a, FREQAMP b)
{
    return a.freq < b.freq;
}

main()
{
    vector <FREQAMP> temp;
    FREQAMP freqAMP;

    freqAMP.freq = 330;
    freqAMP.amp = 117.56;
    temp.Push_back(freqAMP);

    freqAMP.freq = 450;
    freqAMP.amp = 99.56;
    temp.Push_back(freqAMP);

    freqAMP.freq = 110;
    freqAMP.amp = 106.56;
    temp.Push_back(freqAMP);

    sort(temp.begin(),temp.end(), struct_cmp_by_freq);
}

если сравнение ложно, это сделает "обмен".

0
bruce