W jaki sposób można użyć enable_if do wzajemnie wykluczających się szablonów funkcji nie będących członkami?

Question

Próbuję napisać szablonów funkcji operatora spoza UE, takich jak:

#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>()) 
{ /*...*/ } 

Ale gdy próbuję obsłużyć gdy l i r mają różne długości:

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>()) 
{ /*...*/ } 

otrzymuję błędy dwuznaczności. Próbowałem coś takiego:

które przeczytałem (tutaj na S.O.), aby rozwiązać problemy takie jak to dla szablonów funkcji członkowskich. (Czasami respondenci zmienili funkcję członka na szablon funkcji członka, aby to umożliwić). Ale błędy nie zmieniają się dla mnie. Czy muszę przełączyć się na wprowadzanie enable_if do typu zwrotu?

Och, wyrażenie typu zwrotu ma na celu wykluczenie tego operatora, gdy nie można porównać dwóch typów elementów. Czy to rzeczywiście zadziała? Czy jest on kompatybilny z umieszczaniem tam również kamery enable_if?

Answer 1

Interesujące jest to, że certain fellow here on SO napisał niedawno wpisany blog, pokazujący ładną technikę SFINAE w stylu C++ 11, która z łatwością pozwala na przeładowanie funkcji. Technika i objaśnienie są dostarczane here.

Podsumowując, Twój kod kończy się niepowodzeniem, ponieważ oba szablony, które są analizowane po raz pierwszy i kiedy są rozwiązywane niezależne deklaracje, są dokładnie takie same, jak w przypadku typów. Podobnie jak w przypadku domyślnych argumentów funkcji, domyślne argumenty szablonu są zastępowane tylko wtedy, gdy funkcja jest faktycznie wywoływana. To jest to, co oba szablony wyglądać do kompilatora w momencie zgłoszenia:

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

Poniższy kod należy osiągnąć to, co chcesz:

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>()) 
{ /*...*/ } 

Jedno pytanie pozostaje jednak ... co powinno się zdarzyć jeśli Lt == Lu? W takim przypadku żadne przeciążenie nie jest możliwe.