Comment vérifier le type d’un paramètre de modèle?

Supposons que j’ai une fonction de template et deux classes

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

Comment est-ce que je fais le chèque pour que T soit animal? Je ne veux pas avoir quelque chose qui vérifie pendant l’exécution. Merci

Utilisez is_same :

 #include  template  void foo() { if (std::is_same::value) { /* ... */ } // optimizable... } 

En général, c’est une conception totalement impraticable, et vous voulez vraiment vous spécialiser :

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

Notez également qu’il est inhabituel d’avoir des modèles de fonction avec des arguments explicites (non déduits). Ce n’est pas rare, mais souvent, il y a de meilleures approches.

Je pense qu’aujourd’hui, il est préférable d’utiliser, mais seulement avec C ++ 17.

 #include  template  void foo() { if constexpr (std::is_same_v) { // use type specific operations... } } 

Si vous utilisez des opérations de type spécifique dans le corps de l’expression if sans constexpr , ce code ne sera pas compilé.

Vous pouvez spécialiser vos modèles en fonction de ce qui est passé dans leurs parameters comme ceci:

 template <> void foo { } 

Notez que cela crée une fonction entièrement nouvelle en fonction du type transmis en tant que T Ceci est généralement préférable car cela réduit l’encombrement et est essentiellement la raison pour laquelle nous avons des modèles en premier lieu.

En C ++ 17, nous pouvons utiliser des variantes .

Pour utiliser std::variant , vous devez inclure l’en-tête:

 #include  

Après cela, vous pouvez append std::variant dans votre code comme ceci:

 using Type = std::variant ; template  void too (Type t) { if (std::is_same_v ) { // Do stuff... } else { // Do stuff... } }