Bir şablon parametresinin türü nasıl kontrol edilir?

Bir şablon işlevim ve iki sınıfım olduğunu varsayalım

class animal {
}
class person {
}

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

T'nin hayvan olup olmadığını nasıl kontrol ederim? Çalışma süresi boyunca kontrol eden bir şeye sahip olmak istemiyorum. Teşekkürler

Kullanım is_same:

#include <type_traits>

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

Genelde bu tamamen işe yaramaz bir tasarımdır ve gerçekten uzmanlaşmak istersiniz :

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

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

Ayrıca, açık (çıkarılmamış) bağımsız değişkenlere sahip işlev şablonlarına sahip olmanın olağandışı olduğunu unutmayın. Duyulmamış bir şey değil, ama çoğu zaman daha iyi yaklaşımlar var.

Bence bugün kullanmak daha iyidir, ancak yalnızca C ++ 17 ile.

#include <type_traits>

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

İf ifade gövdesinde tipe özgü bazı işlemler kullanırsanız constexpr, bu kod derlenmeyecektir.

C ++ 17'de varyantları kullanabiliriz .

Kullanmak std::variantiçin başlığı eklemeniz gerekir:

#include <variant>

Bundan sonra, std::variantkodunuzu şu şekilde ekleyebilirsiniz :

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

Şablonlarınızı aşağıdaki gibi parametrelerine geçirilenlere göre özelleştirebilirsiniz:

template <> void foo<animal> {

}

Bunun, olarak geçirilen türe göre tamamen yeni bir işlev oluşturduğunu unutmayın T. Bu, dağınıklığı azalttığı için genellikle tercih edilir ve esasen ilk etapta şablonlara sahip olmamızın nedenidir.