कस्टम ऑब्जेक्ट्स के वेक्टर को सॉर्ट करना

248

कस्टम (यानी उपयोगकर्ता परिभाषित) ऑब्जेक्ट वाली वेक्टर को सॉर्ट करने के बारे में कैसे जाना जाता है।
शायद, मानक एसटीएल एल्गोरिथ्म तरह कस्टम वस्तु में एक विधेय (एक समारोह या एक समारोह वस्तु) जो (छँटाई के लिए एक प्रमुख के रूप में) क्षेत्रों में से एक पर काम करेंगे के साथ किया जाना चाहिए।
क्या मैं सही रास्ते पर हूं?

c++ stl sorting

— अंकुर
स्रोत

मानक लाइब्रेरी सॉर्ट और उपयोगकर्ता परिभाषित प्रकारों

— MCCCS

365

एक सरल उदाहरण का उपयोग करते हुए 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());

संपादित करें: के रूप में किरिल वी Lyadvinsky ने कहा, एक तरह से विधेय की आपूर्ति के बजाय, आप लागू कर सकते हैं 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>());

— एलन
स्रोत

2

क्या आप बता सकते हैं कि आपने संरचना में तुलनात्मक फ़ंक्शन को कम क्यों बनाया है_थेन_की (पहली में) उदाहरण इनलाइन?

— kluka

2

और एक अन्य प्रश्न / नोट: यदि कोई एक श्रेणी में कई अलग-अलग छांटने के तरीके (अलग-अलग विशेषताओं के लिए) चाहेगा तो <ऑपरेटर को ओवरलोड करने का तरीका शायद एक विकल्प नहीं है, है ना?

— kluka

5

एक अच्छी बात यह भी है कि ऑपरेटर> विधि भी प्रदान की जाए। यह हमें रिवर्स ऑर्डर में क्रमबद्ध करने की अनुमति देगा जैसे:, std::sort(vec.begin(), vec.end(), greater<MyStruct>())जो स्वच्छ और सुरुचिपूर्ण है।

— कप्पा

3

@ बोवाज़ आपको #include <functional>"एसटीडी :: अधिक" का उपयोग करने की आवश्यकता है ।

— निक हार्टुंग

4

@kappa: जहाँ आप बस या operator<तो उपयोग कर सकते हैं std::sort(vec.begin(), vec.end());या std::sort(vec.rbegin(), vec.rend());इस पर निर्भर करते हैं कि आप आरोही या अवरोही क्रम चाहते हैं।

— Pixelchemist

182

कवरेज के हित में। मैंने मेमने के भावों का उपयोग करते हुए कार्यान्वयन को आगे बढ़ाया ।

सी ++ 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;
});

सी ++ 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;
});

— बेन क्राउथस्ट
स्रोत

21

#includes

— Anne

3

स्पष्ट होने के लिए, यह आरोही क्रम में परिणाम करता है; अवरोही क्रम प्राप्त करने के >बजाय उपयोग करें <।

— bhaller

56

आप तीसरे तर्क के रूप में फ़नकार का उपयोग कर सकते हैं 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() );
}

— किरिल वी। लयाडविंस्की
स्रोत

4

हमें constफ़ंक्शन हस्ताक्षर के अंत में जोड़ने की आवश्यकता क्यों है ?

— इसके कांटे

4

फ़ंक्शन ऑब्जेक्ट को परिवर्तित नहीं करता है इसलिए यह है const।

— किरिल वी। ल्याडविंस्की

अगर ऐसा है तो हम "कॉन्स्टेंट एक्सएंडवाई" क्यों पास करते हैं, मेरा मानना है कि एक फंक्शन के लिए कॉस्ट के रूप में वैल्यू पास करने से फंक्शन को लगता है कि उसकी वैल्यू नहीं बदलने वाली है।

— प्रशांत भाणकर

1

@PrashantBhanarkar constहस्ताक्षर के अंत में कीवर्ड निर्दिष्ट करता है कि operator()फ़ंक्शन Xgreaterसंरचना के उदाहरण को नहीं बदलता है (जो सामान्य रूप से सदस्य चर हो सकता है), जबकि constइनपुट मानों के लिए संकेत केवल यह निर्दिष्ट करता है कि उन इनपुट मान अपरिवर्तनीय हैं।

— विद्वान

15

इस तरह के vectorया किसी अन्य लागू (म्यूट इनपुट इनपुट) प्रकार की कस्टम वस्तुओं की श्रेणी को Xविभिन्न तरीकों का उपयोग करके प्राप्त किया जा सकता है, विशेष रूप से मानक पुस्तकालय एल्गोरिदम जैसे उपयोग

चूंकि अधिकांश तकनीकें, Xतत्वों के सापेक्ष आदेश प्राप्त करने के लिए , पहले से ही पोस्ट की जा चुकी हैं, मैं विभिन्न दृष्टिकोणों का उपयोग करने के लिए "क्यों" और "कब" पर कुछ नोटों से शुरू करूंगा।

"सर्वश्रेष्ठ" दृष्टिकोण विभिन्न कारकों पर निर्भर करेगा:

क्या Xवस्तुओं की श्रेणी को एक सामान्य या एक दुर्लभ कार्य है (क्या इस तरह की श्रेणियों को कार्यक्रम में या पुस्तकालय उपयोगकर्ताओं द्वारा अलग-अलग स्थानों पर छांटा जा सकता है)?
क्या आवश्यक छंटाई "प्राकृतिक" (अपेक्षित) है या क्या कई तरीके हैं जिनकी तुलना स्वयं की जा सकती है?
क्या प्रदर्शन एक मुद्दा है या Xवस्तुओं की श्रेणियों को छांटना मूर्खतापूर्ण होना चाहिए?

यदि छँटाई की सीमा Xएक सामान्य कार्य है और प्राप्त छँटाई की उम्मीद की जानी है (यानी Xसिर्फ एक मौलिक मूल्य लपेटता है) तो शायद ओवरलोडिंग के लिए जाता है operator<क्योंकि यह बिना किसी फ़ज़ल के छँटाई करने में सक्षम बनाता है (जैसे सही ढंग से उचित तुलनित्रों को पास करना) और बार-बार पैदावार की उम्मीद करना परिणाम है।

यदि छंटनी एक सामान्य कार्य है या विभिन्न संदर्भों में आवश्यक होने की संभावना है, लेकिन कई मापदंड हैं जिनका उपयोग Xवस्तुओं को क्रमबद्ध करने के लिए किया जा सकता है , मैं फ़ंकर्स ( 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));

— Pixelchemist
स्रोत

में 2. मामले आप ने लिखा bool X_less(X const &l, X const &r) const { return l.i < r.i; }तुलनित्र के लिए लेकिन constकीवर्ड को हटा दिया जाना चाहिए (के रूप में यह एक सदस्य समारोह नहीं है)।

— PolGraphic

@ पॉलीग्राफिक: सही - स्थिति 1 में भी।

— Pixelchemist

@Pixelchemist मैं (4.) लैम्ब्डा एप्रोच का उपयोग कैसे करूँगा जब उपयोग नहीं हो रहा है std::sortया समान है, लेकिन इंस्टेंटेट करते समय उदाहरण की आवश्यकता है Compare, जैसे std::set?

— अजरदेव

1

@azrdev: एक फ़ंक्शन टेम्प्लेट जो इसे सेट करने के लिए टेम्पलेट पैरामीटर के रूप में पास करने के लिए क्लोजर के प्रकार को कैप्चर करता है: template<class T, class C> std::set<T, C> make_set(C const& compare) { return std::set<T, C>{ compare }; }जिसका उपयोग किया जा सकता है auto xset = make_set<X>([](auto && l, auto && r) { return l.i < r.i; });।

— Pixelchemist

14

आप सही रास्ते पर हैं। डिफ़ॉल्ट रूप से तुलना फ़ंक्शन के रूप में 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 );

एक फ़नकार के उपयोग का लाभ यह है कि आप एक फ़ंक्शन का उपयोग कक्षा के निजी सदस्यों तक पहुंच के साथ कर सकते हैं।

— xtofl
स्रोत

याद किया कि एक: एक सदस्य समारोह ऑपरेटर प्रदान करते हैं <।

— xtofl

1

operator<वर्ग (या संरचना) का सदस्य बनाना बेहतर है , क्योंकि वैश्विक व्यक्ति संरक्षित या निजी सदस्यों का उपयोग कर सकता है। या आपको इसे संरचना सी का एक दोस्त बनाना चाहिए

— किरिल वी। लयाडविंस्की

5

मैं उत्सुक था कि क्या प्रदर्शन के विभिन्न तरीकों के बीच कोई औसत दर्जे का प्रभाव हो सकता है, जिसे लोग std :: सॉर्ट कह सकते हैं, इसलिए मैंने एक बहुत ही आसान मूल्यांकन किया है:

$ 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- अस्थायी उत्पादन)।

— qbolec
स्रोत

4

हां, std::sort()तीसरे पैरामीटर (फ़ंक्शन या ऑब्जेक्ट) के साथ आसान होगा। एक उदाहरण: http://www.cplusplus.com/reference/algorithm/sort/

— swatkat
स्रोत

केवल लिंक ही नहीं, बल्कि केवल कम से कम एक एकल पंक्ति उदाहरण उपयोगी होगा।

— मानोस निकोलाइडिस

3

आपकी कक्षा में, आप "<" ऑपरेटर को ओवरलोड कर सकते हैं।

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

— BobbyShaftoe
स्रोत

3

नीचे लैम्बदास का उपयोग करने वाला कोड है

#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;
}

— Sathwick
स्रोत

1

    // 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

आप उपयोगकर्ता परिभाषित तुलनित्र वर्ग का उपयोग कर सकते हैं।

class comparator
{
    int x;
    bool operator()( const comparator &m,  const comparator &n )
    { 
       return m.x<n.x;
    }
 }

0

एक वेक्टर को सॉर्ट करने के लिए आप सॉर्ट () एल्गोरिदम का उपयोग कर सकते हैं।

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

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

यदि तुलना झूठी है, तो यह "स्वैप" करेगा।

— ब्रूस
स्रोत

किसी भी भाषा में यह संकलन नहीं होगा।

— एलएफ

कस्टम ऑब्जेक्ट्स के वेक्टर को सॉर्ट करना

class Xमानक पुस्तकालय छँटाई एल्गोरिदम का उपयोग करने के लिए तुलनात्मकता प्राप्त करने के तरीके

1. अधिभार T::operator<(T)या operator<(T, T)मानक पुस्तकालय टेम्पलेट्स का उपयोग करें जो एक तुलना फ़ंक्शन की अपेक्षा नहीं करते हैं।

2. फंक्शन पॉइंटर का उपयोग कस्टम फंक्शन के साथ फंक्शन पैरामीटर को सॉर्ट करने के लिए करें।

3. bool operator()(T, T)एक कस्टम प्रकार के लिए एक अधिभार बनाएं जो तुलना फ़नकार के रूप में पारित किया जा सकता है।

4. अनाम अनाम क्लोजर (लैम्ब्डा) को सॉर्टिंग फ़ंक्शंस के तुलना पैरामीटर के रूप में पास करें।

`class X`मानक पुस्तकालय छँटाई एल्गोरिदम का उपयोग करने के लिए तुलनात्मकता प्राप्त करने के तरीके

1. अधिभार `T::operator<(T)`या `operator<(T, T)`मानक पुस्तकालय टेम्पलेट्स का उपयोग करें जो एक तुलना फ़ंक्शन की अपेक्षा नहीं करते हैं।

3. `bool operator()(T, T)`एक कस्टम प्रकार के लिए एक अधिभार बनाएं जो तुलना फ़नकार के रूप में पारित किया जा सकता है।