Como verificar o tipo de parâmetro de modelo?

Suponha que eu tenha uma função de modelo e duas classes

class animal {
}
class person {
}

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

Como faço para verificar se é animal? Não quero ter algo que verifique durante o tempo de execução. obrigado

Use is_same:

#include <type_traits>

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

Normalmente, esse é um design totalmente impraticável, e você realmente quer se especializar :

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

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

Observe também que é incomum ter modelos de função com argumentos explícitos (não deduzidos). Não é inédito, mas geralmente existem abordagens melhores.

Acho que hoje é melhor usar, mas só com C ++ 17.

#include <type_traits>

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

Se você usar algumas operações específicas de tipo em if expression body sem constexpr, este código não será compilado.

Em C ++ 17, podemos usar variantes .

Para usar std::variant, você precisa incluir o cabeçalho:

#include <variant>

Depois disso, você pode adicionar std::variantseu código da seguinte forma:

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

Você pode especializar seus modelos com base no que é passado em seus parâmetros, como este:

template <> void foo<animal> {

}

Observe que isso cria uma função totalmente nova com base no tipo que é passado como T. Isso geralmente é preferível, pois reduz a desordem e é essencialmente a razão pela qual temos modelos em primeiro lugar.