Warum schlägt „enable_if_t' in Funktionsdefinitionen fehl?

Konflikt von Vorlagenargumenten: Warum enable_if_t in Definitionen fehlschlägt

Bei der Vorlagenprogrammierung kommt es nicht selten vor, dass wir auf Situationen stoßen, in denen wir eine bedingte Aktivierung benötigen oder deaktivieren Sie Vorlagenfunktionen basierend auf einer bestimmten Bedingung. In solchen Fällen wird häufig die Vorlage std::enable_if verwendet, um dies zu erreichen. Ein kürzlicher Versuch, die neuere Syntax von std::enable_if_t zu verwenden, hat jedoch zu unerwarteten Fehlern geführt.

Im folgenden Codeausschnitt definieren wir zwei Vorlagenfunktionen f() mit std::enable_if:

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

Beim Portieren dieses Codes zur Verwendung der neuen std::enable_if_t-Syntax stoßen wir auf ein Problem:

template<typename T,
         typename = std::enable_if_t<std::is_same<int, T>::value>>
void g() { }

template<typename T,
         typename = std::enable_if_t<std::is_same<double, T>::value>>
void g() { }

GCC beschwert sich über den folgenden Fehler:

error: redefinition of 'template<class T, class> void g()'
       void g() { }

Um zu verstehen, warum dieser Fehler auftritt, müssen wir die Syntax von Vorlagenargumenten untersuchen. Indem wir unnötigen Code entfernen, erhalten wir die folgende vereinfachte Darstellung unserer Funktionen:

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

Es wird deutlich, dass beide Vorlagen unabhängig von ihren unterschiedlichen Standardwerten vom gleichen Typ templatevoid() sind für das zweite Typargument. Dies steht im Widerspruch zur C-Anforderung, dass zwei Vorlagenfunktionen desselben Vorlagentyps unterschiedliche Signaturen haben müssen.

Um dieses Problem zu lösen, können wir das zweite Argument in einen Zeigertyp mit einem abhängigen Typ ändern:

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

In diesem geänderten Code ist die Signatur der Vorlagenfunktionen jetzt eindeutig, wodurch der Konflikt beseitigt und die korrekte Vorlagenübereinstimmung ermöglicht wird.

Das obige ist der detaillierte Inhalt vonWarum schlägt „enable_if_t' in Funktionsdefinitionen fehl?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!