Rozdzielczość przeciążeniowa z odwołaniami uniwersalnymi

Question

Mam funkcję, która może akceptować dowolny typ według uniwersalnego odwołania i chciałbym ją przeciążać dla określonych typów (niektóre z nich sami są szablonami, chociaż nie sądzę, że jest to ważne). Niestety, wydaje mi się, że nie udało mi się usunąć przeciążeń w odpowiedniej kolejności.

Przypuszczam, że druga deklaracja foo byłaby preferowana, ponieważ jest bardziej szczegółowa (mniej szablonowa), chociaż wygląda na to, że brakuje mi nieco zrozumienia dla rozwiązania dotyczącego przeciążenia. Co ciekawe, zmiana drugiej deklaracji na wartość X według wartości powoduje, że jest drukowana "dobra, dobra", co powoduje, że jest ona "niezła, dobra". Oczywiście usunięcie pierwszej deklaracji całkowicie powoduje, że zwraca ona "dobry, dobry", ponieważ nie ma innego wyboru.

Dlaczego tak się dzieje? A co najważniejsze, jeśli poniższy kod nie działa, jak można przeciążać funkcję tym podpisem?

#include <iostream> 
#include <string> 

class X {}; 

template<typename T> 
inline std::string foo(T && rhs) { 
    return "bad"; 
} 

inline std::string foo(const X & rhs) { 
    return "good"; 
} 

int main() { 
    std::cout << foo(X()) << std::endl; 
    X x; 
    std::cout << foo(x) << std::endl; 
    return 0; 
} 

Edit:

Może bardziej rondo Rozwiązaniem tego problemu jest zrobić to w sposób pośredni. Pozbądź się pierwszej formy foo i użyj SFINAE, aby sprawdzić, czy istnieje przeciążenie, ale nie zadzwoń pod foo_fallback.

Answer 1

Aby odpowiedzieć na question.comment aby odpowiedzieć Kerre jest, można spróbować użyć SFINAE:

#include <type_traits> 
#include <string> 

template <class T> 
struct HasFooImpl_ { 
    template <typename C> 
    static std::true_type test(decltype(fooImpl(std::declval<C>()))*); 
    template <typename C> 
    static std::false_type test(...); 
    typedef decltype(test<T>(0)) type; 
}; 

template <typename T> 
using HasFooImpl = typename HasFooImpl_<T>::type; 

template <typename T> 
typename std::enable_if<HasFooImpl<T>::value, std::string>::type 
foo(T&& t) 
{ 
    return fooImpl(std::forward<T>(t)); 
} 

template <typename T> 
typename std::enable_if<!HasFooImpl<T>::value, std::string>::type 
foo(T&& t) 
{ 
    return "generic!"; 
} 

Trzeba by realizować funkcję fooImpl dla każdego typu, które nie chcą być traktowane genericly .

Wdrożenie było nieco trudne, najpierw próbowałem po prostu enable_if<is_same<string, decltype(fooImpl(declval<C>()))>::value, ale w odpowiedzi na awarię !is_same<>::value dało mi błędy kompilatora, ponieważ próbowało również utworzyć egzemplarz decltype.

Ta implementacja ma jedno zastrzeżenie, że może, ale nie chcą używać: jeśli T jest cabrio do innego typu, który ma fooImpl zdefiniowany, że konwersja będzie kopać w

Można zobaczyć całość. rzeczą w akcji tutaj: http://ideone.com/3Tjtvj

Aktualizacja: jeśli nie chcesz, aby typ konwersji, to faktycznie staje się łatwiejsze:

#include <type_traits> 
#include <string> 

template <typename T> void fooImpl(T); 

template <typename T> 
using HasFooImpl = typename std::is_same<std::string, decltype(fooImpl(std::declval<T>()))>; 

template <typename T> 
typename std::enable_if<HasFooImpl<T>::value, std::string>::type 
foo(T&& t) 
{ 
    return fooImpl(std::forward<T>(t)); 
} 

template <typename T> 
typename std::enable_if<!HasFooImpl<T>::value, std::string>::type 
foo(T&& t) 
{ 
    return "generic!"; 
} 

Zobacz http://ideone.com/miaoop

Answer 2

Konwersja z X do const X jest uważany za gorszy niż bezpośrednim meczu przeciążenia matrycy z T = X lub T = X &.