C++ in meno di sovraccarico dell'operatore, quale modo di usare?

Question

Ad esempio: in un file di intestazione C++, se ho definito un struct Record e vorrei usarlo per l'eventuale ordinamento in modo che voglio sovraccaricare il . Ecco tre modi che ho notato in vari codici. Ho notato approssimativamente che: se ho intenzione di mettere Record in un std::set, map, priority_queue, ... contenitori, la versione 2 funziona (probabilmente anche la versione 3); se ho intenzione di salvare Record in un vector<Record> v e quindi chiamare make_heap(v.begin(), v.end()) ecc .. allora funziona solo la versione 1.

struct Record 
    { 
     char c; 
     int num; 

     //version 1 
     bool operator <(const Record& rhs) 
     { 
     return this->num>rhs.num; 
     } 

     //version 2 
     friend bool operator <(const Record& lhs, const Record& rhs) //friend claim has to be here 
     { 
     return lhs->num>rhs->num; 
     } 
    }; 

nello stesso file di intestazione, ad esempio:

 //version 3 
     inline bool operator <(const Record& lhs, const Record& rhs) 
     { 
     return lhs->num>rhs->num; 
     } 

In sostanza, vorrei gettare le domande qui per vedere se qualcuno potrebbe venire con qualche sintesi ciò che è le differenze tra questi tre metodi e quali sono i posti giusti per ogni versione?

Answer 1

Sono essenzialmente gli stessi, a parte il primo che non è const e consente di modificarsi.

preferisco la seconda per 2 motivi:

1. Non deve essere un friend.
2. lhs non deve essere un Record

Answer 2

Favorire in classe a meno che non possa essere in classe perché il primo argomento è il tipo sbagliato.

Answer 3

Il modo migliore per definire il meno dell'operatore è:

struct Record{ 
    (...) 
    const bool operator < (const Record &r) const{ 
     return (num < r.num); 
    } 
};