Come si usa enable_if per i modelli di funzione non membri mutuamente esclusivi?

Question

che sto cercando di scrivere terzi modelli funzione operatore come:

#include <utility> 

template < typename T, unsigned L > 
class MyType; 

template < typename T, typename U, unsigned L > 
auto operator ==(MyType<T,L> const &l, MyType<U,L> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

Ma quando provo a gestire quando l e r hanno lunghezze diverse:

template < typename T, unsigned Lt, typename U, unsigned Lu, class Enable = typename std::enable_if<(Lt < Lu)>::type > 
auto operator ==(MyType<T,Lt> const &l, MyType<U,Lu> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

template < typename T, unsigned Lt, typename U, unsigned Lu, class Enable = typename std::enable_if<(Lt > Lu)>::type > 
auto operator ==(MyType<T,Lt> const &l, MyType<U,Lu> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

ricevo errori ambiguità. Ho provato qualcosa del tipo:

template < typename T, unsigned Lt, typename U, unsigned Lu, bool B = (Lt < Lu), class Enable = typename std::enable_if<B>::type > 
auto operator ==(MyType<T,Lt> const &l, MyType<U,Lu> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

template < typename T, unsigned Lt, typename U, unsigned Lu, bool B = (Lt > Lu), class Enable = typename std::enable_if<B>::type > 
auto operator ==(MyType<T,Lt> const &l, MyType<U,Lu> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

che ho letto (qui su S.O.) per risolvere problemi come questo per i modelli di funzioni membro. (A volte, i rispondenti hanno cambiato una funzione membro in un modello funzione membro per abilitarlo.) Ma gli errori non cambiano per me. Devo passare a inserire enable_if nel tipo restituito?

Oh, l'espressione del tipo restituito dovrebbe escludere questo operatore quando i due tipi di elementi non possono essere confrontati. Funzionerà davvero? È compatibile con l'installazione di enable_if?

Answer 1

È interessante notare che un certain fellow here on SO ha scritto un blogpost poco tempo fa, mostrando una bella tecnica SFINAE in stile C++ 11 che consente facilmente funzioni sovraccariche. La tecnica e la spiegazione sono fornite here.

In breve, il codice fallisce perché entrambi i modelli, quando analizzato per la prima volta e quando le dichiarazioni non dipendenti sono stati risolti, sono esattamente stesso, tipo-saggio. Come per gli argomenti delle funzioni predefinite, gli argomenti dei modelli predefiniti vengono sostituiti solo quando viene effettivamente chiamata la funzione. Questo è ciò che entrambi i modelli assomigliano al compilatore al momento della dichiarazione:

template<class T, unsigned Lt, class U, unsigned Lu, class Enable> 
auto operator==(MyType<T,Lt> const& l, MyType<U,Lu> const& r); 

Il seguente codice dovrebbe ottenere quello che vuoi:

namespace detail{ 
enum class enabler{}; 
} 

template<bool B, class T = detail::enabler> 
using EnableIf = typename std::enable_if<B, T>::type; 

template < typename T, unsigned Lt, typename U, unsigned Lu, EnableIf<(Lt < Lu)>...> 
auto operator ==(MyType<T,Lt> const &l, MyType<U,Lu> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

template < typename T, unsigned Lt, typename U, unsigned Lu, EnableIf<(Lt > Lu)>...> 
auto operator ==(MyType<T,Lt> const &l, MyType<U,Lu> const &r) 
-> decltype(std::declval<T>() == std::declval<U>()) 
{ /*...*/ } 

Una domanda rimane, però ... cosa dovrebbe accadere se Lt == Lu? In tal caso, nessun sovraccarico è praticabile.