Supposons que j'ai une fonction de modèle et deux classes
class animal {
}
class person {
}
template<class T>
void foo() {
if (T is animal) {
kill();
}
}Comment vérifier si T est un animal? Je ne veux pas avoir quelque chose qui vérifie pendant l'exécution. Merci
Réponses:
Utilisez is_same:
#include <type_traits>
template <typename T>
void foo()
{
if (std::is_same<T, animal>::value) { /* ... */ } // optimizable...
}Habituellement, c'est une conception totalement irréalisable, cependant, et vous voulez vraiment vous spécialiser :
template <typename T> void foo() { /* generic implementation */ }
template <> void foo<animal>() { /* specific for T = animal */ }Notez également qu'il est inhabituel d'avoir des modèles de fonctions avec des arguments explicites (non déduits). Ce n'est pas rare, mais il existe souvent de meilleures approches.
Tn'est pas déduit, vous ne pouvez pas faire grand-chose. Vous pouvez laisser le modèle principal non implémenté et créer une spécialisation, ou vous pouvez ajouter une assertion statique avec is_same.
Je pense qu'aujourd'hui, il vaut mieux l'utiliser, mais uniquement avec C ++ 17.
#include <type_traits>
template <typename T>
void foo() {
if constexpr (std::is_same_v<T, animal>) {
// use type specific operations...
}
}Si vous utilisez des opérations spécifiques au type dans le corps de l'expression if sans constexpr, ce code ne sera pas compilé.
std::is_same<T, U>::valuevous pourriez utiliser plus court:std::is_same_v<T, U>
En C ++ 17, nous pouvons utiliser des variantes .
Pour l'utiliser std::variant, vous devez inclure l'en-tête:
#include <variant>Après cela, vous pouvez ajouter std::variantvotre code comme ceci:
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...
}
}typequi est la valeur de type Typeou un modèle qui n'a pas de sens ici) is_same_vne sont pas significatives dans le contexte de variant. Le "trait" correspondant est holds_alternative.
std::variantest totalement inutile ici
Vous pouvez spécialiser vos modèles en fonction de ce qui est passé dans leurs paramètres comme ceci:
template <> void foo<animal> {
}Notez que cela crée une fonction entièrement nouvelle basée sur le type passé en tant que T. Ceci est généralement préférable car cela réduit l'encombrement et c'est essentiellement la raison pour laquelle nous avons des modèles en premier lieu.