C++ częściowe uporządkowanie dla funkcji z domyślnym argumentem

Question

Rozważmy następujący kod:

template <class...> 
using void_t = void; 

template <class T> 
void bar(T){} 

template <class T> 
void bar(T, void_t<decltype(std::declval<T>().foo())>* = 0) {} 

struct A { void foo(); } a; 
bar(a); // gives a compiler error on ambiguous call 

Więc pytanie jest, dlaczego są te przeciążenia niejednoznaczne? Dlaczego drugie przeciążenie nie jest uważane za bardziej restrykcyjne, bardziej wyspecjalizowane niż drugie przez kompilator?

Answer 1

Jednym ze zwyczajowych sposobów, aby to zrobić, jest stworzenie alternatywy dla wyspecjalizowanych szablonów.

#include <utility> 
#include <iostream> 

template<class T> 
struct has_foo_impl 
{ 
    template<class U> static auto test(U* p) -> decltype(p->foo(), void(), std::true_type()); 
    static auto test(...) -> decltype(std::false_type()); 

    using type = decltype(test((T*)nullptr)); 
}; 

template<class T> using has_foo = typename has_foo_impl<T>::type; 

template <class...> 
using void_t = void; 

template <class T, std::enable_if_t<not has_foo<T>::value>* = nullptr> 
void bar(T){ 
    std::cout << "not me\n"; 
} 

template <class T, std::enable_if_t<has_foo<T>::value>* = nullptr> 
void bar(T) { 
    std::cout << "me\n"; 
} 

struct A { void foo(); } a; 

int main() 
{ 
    bar(a); // "me" 
} 

Answer 2

Ponieważ używasz wartości domyślnej dla przeciążonej funkcji, więc kompilator nie wie, której funkcji chcesz użyć.

void bar(T, void_t<decltype(std::declval<T>().foo())>* = 0) 

bez

= 0 

to działa dobrze.

/EDIT

template <class...> 
using void_t = void; 

template <class T> 
void bar(T) 
{} 

template <class T> 
void bar(T, void_t<decltype(std::declval<T>().foo())>*) 
{} 

struct A 
{ 
    void foo(); 
} a; 

int main() 
{ 
    bar(a); 
    return 0; 
} 

To działa.

The program '[7464] Project3.exe' has exited with code 0 (0x0). 

Answer 3

Próbujesz użyć SFINAE wymusić wybór konkretnego kandydata w konkretnym przypadku (tu obecność na żądanie podmiotu foo sobą nie argumentu wewnątrz T lwartości). Co tak naprawdę się tutaj dzieje?

Szablon z void_t jest dobrze zdefiniowany dla twojego struct A, więc w momencie połączenia masz dwóch ważnych kandydatów do uzyskania rozdzielczości przeciążenia. Jeśli chcesz korzystać z SFINAE, musisz upewnić się, że dla danego połączenia dostępna jest tylko jedna przeciążenie. Aby to zrobić, powinieneś najpierw osadzić swój test w typie. W tym celu można wziąć przykład na Yakk's can_apply facility które bezczelnie kopiować tutaj, ponieważ bardzo dobrze pasuje do Państwa potrzeb:

namespace details { 
    // if Z<Ts...> is invalid, false_type: 
    template <template<class...> class Z, class always_void, class... Ts> 
    struct can_apply : std::false_type {}; 

    // if Z<Ts...> is valid, true_type: 
    template <template<class...> class Z, class... Ts> 
    struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...> : std::true_type {}; 
} 
// alias to inject the void type where we need it for SFINAE: 
template <template<class...> class Z, class... Ts> 
using can_apply = details::can_apply<Z, void, Ts...>; 

template <typename T> 
using has_foo_t = decltype(std::declval<T>().foo()); 

template <typename T> 
using has_foo = can_apply<has_foo_t, T>; 

teraz mamy tylko do korzystania cechę określoną powyżej w naszych definicji szablonu:

// The enable_if with the negation is needed to invalidate 
// this implementation when T indeed has foo(). 
// This is what you were missing in your original idea. 
template <typename T> 
std::enable_if_t<!has_foo<T>::value> bar(T) { 
    std::cout << "T has no foo(void)" << std::endl; 
} 

template <typename T> 
std::enable_if_t<has_foo<T>::value> bar(T) { 
    std::cout << "T has a foo(void)" << std::endl; 
} 

Możesz zobaczyć działający przykład na Coliru.

Answer 4

Żadna z funkcji nie jest bardziej wyspecjalizowana niż inna.

W każdym razie, można siła wybór za pomocą dwóch przeciążone funkcje, jak następuje:

#include<utility> 

template <class T> 
void bar(char, T){} 

template <class T> 
auto bar(int, T) -> decltype(std::declval<T>().foo(), void()) {} 

struct A { void foo(); } a; 

int main() { 
    bar(0, a); 
} 

Dla 0 jest int, bar(int, T) jest sądzony za pierwszym. Z powodu sfinae, może on zostać odrzucony, jeśli T nie ma funkcji składowej . W każdym razie, 0 może być rzutowany na char, w ten sposób wybiera się bar(char, T).
Jeśli zdarza się, że obie funkcje są wykonalne, wywoływana jest bar(int, T), ponieważ nie wymaga żadnego niejawnego rzutowania, a wywołanie nie jest już niejednoznaczne.

Answer 5

jest inne rozwiązanie, które zestawia z g ++:

//g++ 4.9.3 

#include <iostream> 

template <class T> 
    void bar(T) 
{std::cout << "not foo boo...\n";} 

template <class T > 
    void bar(decltype(std::declval<T>().foo(),T())) 
{std::cout << "foo\n";} 

template <class T > 
    void bar(decltype(std::declval<T>().boo(),T())) 
{std::cout << "boo\n";} 

struct Foo { void foo(); } f; 

struct Boo {void boo(); } b; 

struct NotFooBoo { } n; 
template <class T> 
    auto func(T&& t) 
{ 
    return bar<typename std::decay<T>::type>(std::forward<T>(t)); 
} 
int main() 
{ 
    func(f); 
    func(b); 
    func(n); 
}