Warum enable_if_t in template-Argumente beschwert sich über neudefinitionen?

Lassen Sie uns entfernen Sie einige code.

template<
  class T,
  class U/* = std::enable_if_t<std::is_same<int, T>::value>*/
 >
void g() { }

template<
  class T,
  class U/* = std::enable_if_t<std::is_same<double, T>::value>*/
 >
void g() { }

wären Sie überrascht, wenn der compiler zurückgewiesen, die zwei oben genannten templates?

Beide sind template-Funktionen von "Typ" template<class,class>void(). Die Tatsache, dass die 2. Art argument hat eine andere Standard Wert spielt keine Rolle. Das wäre wie erwartet zwei verschiedene print(string, int) Funktionen mit unterschiedlichen Standard - int Werte zu überlasten. 😉

Im ersten Fall haben wir:

template<
  typename T,
  typename std::enable_if<std::is_same<int, T>::value>::type* = nullptr
>
void f() { }

template<
  typename T,
  typename std::enable_if<std::is_same<double, T>::value>::type* = nullptr
>
void f() { }

hier können wir nicht entfernen Sie die enable_if - Klausel. Update auf enable_if_t:

template<
  class T,
  std::enable_if_t<std::is_same<int, T>::value, int>* = nullptr
>
void f() { }

template<
  class T,
  std::enable_if_t<std::is_same<double, T>::value, int>* = nullptr
>
void f() { }

Ich ersetzte auch ein Einsatz von typename mit class. Ich vermute, deine Verwirrung war, weil typename hat zwei Bedeutungen-einer als marker für eine Art von template argument, und anderen als disambiguator für eine abhängige geben.

Hier das 2. argument ist ein pointer, dessen Typ vom ersten abhängig ist. Der compiler kann nicht feststellen, ob diese beiden in Konflikt, ohne zuerst die Substitution in der Art T -- und Sie werden feststellen, dass Sie eigentlich nie Konflikte.

Für eine Funktion zurück geben, die Sie suchen, sind die folgenden:

template<typename T> std::enable_if_t< conditional, instantiation result > foo();

Beispiel:

#include <iostream>

//when T is "int", replace with 'void foo()'   
template<typename T>
std::enable_if_t<std::is_same<int, T>::value, void> foo() {
    std::cout << "foo int\n";
}

template<typename T>
std::enable_if_t<std::is_same<float, T>::value, void> foo() {
    std::cout << "foo float\n";
}

int main() {
    foo<int>();
    foo<float>();
}

http://ideone.com/TB36gH

siehe auch

http://ideone.com/EfLkQy