Supponiamo che io abbia una funzione template e due classi
class animal {
}
class person {
}
template<class T>
void foo() {
if (T is animal) {
kill();
}
}Come faccio a verificare se T is animal? Non voglio avere qualcosa che controlli durante il tempo di esecuzione. Grazie
Risposte:
Usa is_same:
#include <type_traits>
template <typename T>
void foo()
{
if (std::is_same<T, animal>::value) { /* ... */ } // optimizable...
}Di solito, è un design totalmente impraticabile, però, e vuoi davvero specializzarti :
template <typename T> void foo() { /* generic implementation */ }
template <> void foo<animal>() { /* specific for T = animal */ }Nota anche che è insolito avere modelli di funzioni con argomenti espliciti (non dedotti). Non è inaudito, ma spesso ci sono approcci migliori.
Tnon si deduce, non c'è molto che puoi fare. Puoi lasciare il modello principale non implementato e creare una specializzazione, oppure puoi aggiungere un'asserzione statica con is_same.
Penso che oggi sia meglio usare, ma solo con C ++ 17.
#include <type_traits>
template <typename T>
void foo() {
if constexpr (std::is_same_v<T, animal>) {
// use type specific operations...
}
}Se si utilizzano alcune operazioni specifiche del tipo nel corpo dell'espressione if senza constexpr, questo codice non verrà compilato.
std::is_same<T, U>::valuepotresti usare più brevi:std::is_same_v<T, U>
In C ++ 17 possiamo usare varianti .
Per utilizzarlo std::variant, devi includere l'intestazione:
#include <variant>Successivamente, puoi aggiungere il std::varianttuo codice in questo modo:
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...
}
}typeche è il valore del tipo Typeo un modello che non ha senso qui) is_same_vnon è significativo nel contesto di variant. Il "tratto" corrispondente è holds_alternative.
std::variantè totalmente inutile qui
Puoi specializzare i tuoi modelli in base a ciò che viene passato nei loro parametri in questo modo:
template <> void foo<animal> {
}Nota che questo crea una funzione completamente nuova basata sul tipo passato come T. Questo di solito è preferibile in quanto riduce il disordine ed è essenzialmente il motivo per cui abbiamo i modelli in primo luogo.