int ha un operatore ==

Question

Sto provando a verificare se una classe ha un metodo operator==. Ho trovato una soluzione con SFINAE here e funziona perfettamente con la classe che faccio.

Ecco come si presenta:

template <typename T> 
class comparable 
{ 
    typedef char one; 
    typedef long two; 

    template <typename C> static one test(typeof(&C::operator==)) ; 
    template <typename C> static two test(...); 


public: 
    enum { value = sizeof(test<T>(0)) == sizeof(char) }; 
}; 

Ma, quando provo:

std::cout << comparable<int>::value << std::endl; 

Poi restituisce false, mentre io mi aspettavo di restituire true. Perchè è questo ?

Answer 1

int non è un tipo di classe e non ha alcun membro operator==, che è ciò che si verifica con il &C::operator==. Pertanto, il test produce un "no" "". Come altri correttamente hanno sottolineato, il test sarebbe anche negativo per le classi con solo un non membro operator==.

Come controllare correttamente se un operator== esiste è stato chiesto qui: How to check whether operator== exists?

Answer 2

Il test non verifica se l'espressione C==C è valida. Verifica se la tua classe C ha un C::operator==. Dal int non esiste una classe che non abbia membri della classe.

Provare ad es. typeof(C()==C())

Answer 3

L'approccio immediato è imperfetto (o incompleto) per almeno due motivi fondamentali.

In primo luogo, i vostri controlli metodo se classeC ha un membro nome operator ==. I tipi non di classe non supereranno questo test, poiché non hanno membri di sorta. E int è un tipo non di classe.

In secondo luogo, questo approccio di per sé non rileva classi per le quali operator == è implementato come funzione autonoma. Ad esempio, il tuo test dirà che std::string non ha l'operatore ==. È vero che lo std::string non ha un membro del genere, ma puoi confrontare lo std::string per l'uguaglianza utilizzando lo standalone operator ==. Quindi, anche se int fosse in qualche modo un tipo di classe, non significa ancora che implementerebbe operator == come funzione membro.

Answer 4

Se si utilizza C++ 11 è possibile utilizzare decltype che renderà l'applicazione molto più facile:

#include <iostream> 
#include <type_traits> 

using namespace std; 

template <class T, class Sfinae = void> 
class comparable { 
public: 
    static constexpr bool value = false; 
}; 

template <class T> 
class comparable <T, typename enable_if<is_same<decltype(declval<T>() == declval<T>()), bool>::value>::type> { 
public: 
    static constexpr bool value = true; 
}; 

class A { 
public: 
    bool operator==(const A &) { 
     return true; 
    } 
}; 

class B { 
}; 

int main() { 
    cout << comparable<int>::value << endl; // output: 1 
    cout << comparable<A>::value << endl; // output: 1 
    cout << comparable<B>::value << endl; // output: 0 
}