operatore sovraccarico <su coppia non utilizzata in ordinamento

Question

Ho sovraccaricato l'operazione inferiore a pair<int,int>, in modo da poter ordinare un vettore in un modo particolare. Voglio che sia in ordine crescente secondo la prima chiave di una coppia, e se le prime chiavi sono uguali, allora lo farei in ordine decrescente in base alla seconda chiave.

Il problema è che la funzione di ordinamento non sembra essere utilizzando il sovraccarico < operatore, ma se < è chiamato a 2 coppie, l'output restituito è quello che mi aspetto. Ho allegato un frammento di codice di sotto del quale sto utilizzando per il test:

#include <iostream> 
#include <vector> 
#include <algorithm> 

using namespace std; 
bool operator<(pair<int, int> &a, pair<int, int> &b) 
{ 
    if (a.first < b.first) return true; 
    else if ((a.first == b.first) && (a.second > b.second)) return true; 
    return false; 
} 

int main() { 
    vector<pair<int, int>> test {make_pair(1,10), make_pair(3,4), make_pair(3,8), make_pair(6, 23), make_pair(1,6)}; 
    sort(test.begin(), test.end()); 
    for (int i = 0; i < test.size(); i++) 
     cout << test[i].first << " - " << test[i].second << " "; 
    cout << endl; 
    auto a = make_pair(3,4); 
    auto b = make_pair(3,8); 
    cout << (a < b) << endl; 
    return 0; 
} 

Il vettore di ingresso è {(1,10), (3,4), (3,8), (6,23), (1,6)}.

Mi aspetto che l'uscita sia {(1,10), (1,6), (3,8), (3,4), (6,23)}.

L'output ottenuto è {(1,6), (1,10), (3,4), (3,8), (6, 23)}.

Come si può vedere, l'output ottenuto è quello che si ottiene utilizzando l'operatore standard < senza sovraccaricare. Quindi ho pensato che questo potrebbe essere un problema e ho controllato (3,4) < (3,8). In questo caso, la risposta è stata restituita come falsa, in base al mio operatore sovraccarico. Quindi dove sto andando male? Perché l'operatore sovraccarico non subisce l'effetto di sort? Ci sono varie domande su SO su problemi simili, ma non è stato possibile trovare alcun aiuto.

Answer 1

C'è già un operator< definito per coppie nello spazio dei nomi std, ed è quello che viene trovato dalla versione di std::sort che si sta utilizzando. Il sovraccarico non viene mai trovato. Utilizzare un predicato denominato invece:

struct MyPairComparator 
{ 
    bool operator()(const std::pair<int, int> & a, 
        const std::pair<int, int> & b) const 
    { 
     // ... 
    } 
}; 

sort(test.begin(), test.end(), MyPairComparator()); // ADL, maybe 
//        ^^^^^^^^^^^^^^^^^^ 

Inoltre, il predicato dovrebbe essere richiamabile con costanti valori, in modo da prendere gli argomenti per valore o per riferimento const.

Nota che sort è nello spazio dei nomi std. Al contrario, quando si utilizza l'espressione < in main, viene rilevato il proprio sovraccarico nello spazio dei nomi globale.

Answer 2

Sembra che si usi un compilatore C++ 11, corretto e facilitato l'uso delle funzioni lambda. Qualcosa come

sort(test.begin(), test.end(), [](const pair<int, int> & a, const pair<int, int> & b) { 
    if (a.first < b.first) return true; 
    else if ((a.first == b.first) && (a.second > b.second)) return true; 
    return false; 
});