Wie implementiert man eine Vorlagenfunktion, die ihre Implementierung basierend auf der Verfügbarkeit von std::to_string auswählt?

Metaprogrammierung: Funktionsdefinition basierend auf der Typverfügbarkeit ableiten

Im Kontext der Template-Metaprogrammierung wird es notwendig, Vorlagen basierend auf bestimmten Kriterien zu definieren . In diesem speziellen Szenario besteht das Ziel darin, eine Vorlage zu definieren, die ihre Implementierung basierend darauf auswählt, ob die überladene to_string-Funktion für einen bestimmten Typ definiert ist.

Der erste Versuch bestand darin, is_arithmetic als Auswahlkriterium zu verwenden:

template<typename T> enable_if_t<is_arithmetic<T>::value, string> stringify(T t){
    return to_string(t);
}

To_string ist jedoch möglicherweise nicht für nicht-arithmetische Typen verfügbar, was dazu führt, dass eine zusätzliche Vorlage erforderlich ist:

template<typename T> enable_if_t<!is_arithmetic<T>::value, string> stringify(T t){
    return static_cast<ostringstream&>(ostringstream() << t).str();
}

Die Herausforderung bestand darin, die Vorlagenauswahlkriterien für den Fall zu definieren wobei to_string nicht verfügbar ist. Der folgende Versuch war erfolglos:

template<typename T> enable_if_t<!decltype(to_string(T{})::value, string> (T t){
    return static_cast<ostringstream&>(ostringstream() << t).str();
}

Um dieses Problem zu lösen, können wir das von Walter Brown eingeführte Typmerkmal void_t nutzen, das es uns ermöglicht, ein Typmerkmal zu definieren, das die Existenz einer Funktion prüft:

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

Damit können wir das gewünschte Typmerkmal wie folgt konstruieren:

template<typename T, typename = void>
struct has_to_string
: std::false_type { };

template<typename T>
struct has_to_string<T, 
    void_t<decltype(std::to_string(std::declval<T>()))>
    > 
: std::true_type { };

Mit diesem Typmerkmal können wir anschließend die Vorlage definieren, die ihre Implementierung basierend auf der Verfügbarkeit von auswählt to_string:

template<typename T> 
auto stringify(T t) 
-> std::enable_if_t<has_to_string<T>::value, std::string> 
{
    return std::to_string(t);
}

template<typename T>
auto stringify(T t)
-> std::enable_if_t<!has_to_string<T>::value, std::string> 
{
    return static_cast<ostringstream&amp;>(ostringstream() << t).str();
}

Das obige ist der detaillierte Inhalt vonWie implementiert man eine Vorlagenfunktion, die ihre Implementierung basierend auf der Verfügbarkeit von std::to_string auswählt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!