C++ menos sobrecarga del operador, ¿qué manera de usar?

Question

Por ejemplo: en un archivo de cabecera C++, si he definido un struct Record y me gustaría utilizarlo para una posible clasificación de modo que yo quiero sobrecargar el less operator. Aquí hay tres formas que noté en varios códigos. Me di cuenta de que más o menos: si voy a poner en un Recordstd::set, map, priority_queue, ... Contenedores, la versión 2 obras (probablemente la versión 3 también); si voy a guardar Record en un vector<Record> v y luego llamar al make_heap(v.begin(), v.end()) etc., entonces solo funciona la versión 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; 
     } 
    }; 

en el mismo archivo de cabecera por ejemplo:

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

Básicamente, me gustaría lanzar las preguntas para ver si alguien podría llegar a algún resumen de lo que es la diferencia entre estos tres métodos y ¿Cuáles son los lugares correctos para cada versión?

Answer 1

Ellos son esencialmente los mismos, que no sea el primero de los cuales no constante y que le permite modificar en sí.

prefiero la segunda por 2 razones:

1. No tiene que ser un friend.
2. lhs no tiene que ser un Record

Answer 2

Favor en clase a menos que no pueda ser en la clase porque el primer argumento es del tipo incorrecto.

Answer 3

La mejor manera de definir el operador es menos:

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