Wie überprüfe ich den Typ eines Vorlagenparameters?

Angenommen, ich habe eine Vorlagenfunktion und zwei Klassen

class animal {
}
class person {
}

template<class T>
void foo() {
  if (T is animal) {
    kill();
  }
}

Wie überprüfe ich, ob T ein Tier ist? Ich möchte nichts haben, das während der Laufzeit überprüft wird. Vielen Dank

Verwendung is_same:

#include <type_traits>

template <typename T>
void foo()
{
    if (std::is_same<T, animal>::value) { /* ... */ }  // optimizable...
}

Normalerweise ist das jedoch ein völlig unbrauchbares Design, und Sie möchten sich wirklich spezialisieren :

template <typename T> void foo() { /* generic implementation  */ }

template <> void foo<animal>()   { /* specific for T = animal */ }

Beachten Sie auch, dass es ungewöhnlich ist, Funktionsvorlagen mit expliziten (nicht abgeleiteten) Argumenten zu haben. Es ist nicht ungewöhnlich, aber oft gibt es bessere Ansätze.

Ich denke heutzutage ist es besser zu verwenden, aber nur mit C ++ 17.

#include <type_traits>

template <typename T>
void foo() {
    if constexpr (std::is_same_v<T, animal>) {
        // use type specific operations... 
    } 
}

Wenn Sie einige typspezifische Operationen in if expression body without verwenden constexpr, wird dieser Code nicht kompiliert.

In C ++ 17 können wir Varianten verwenden .

Zur Verwendung std::variantmüssen Sie den Header einschließen:

#include <variant>

Danach können Sie std::variantIhren Code wie folgt hinzufügen :

using Type = std::variant<Animal, Person>;

template <class T>
void foo(Type type) {
    if (std::is_same_v<type, Animal>) {
        // Do stuff...
    } else {
        // Do stuff...
    }
}

Sie können Ihre Vorlagen basierend auf den folgenden Parametern spezialisieren:

template <> void foo<animal> {

}

Beachten Sie, dass dadurch eine völlig neue Funktion erstellt wird, die auf dem Typ basiert, der als übergeben wird T. Dies ist normalerweise vorzuziehen, da es die Unordnung verringert und im Wesentlichen der Grund ist, warum wir überhaupt Vorlagen haben.