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... } }