Làm cách nào để kiểm tra loại tham số mẫu?

Giả sử tôi có một hàm mẫu và hai lớp

class animal {
}
class person {
}

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

Làm cách nào để kiểm tra T là động vật? Tôi không muốn có thứ gì đó kiểm tra trong thời gian chạy. Cảm ơn

Sử dụng is_same:

#include <type_traits>

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

Thông thường, đó là một thiết kế hoàn toàn không thể thực hiện được và bạn thực sự muốn chuyên môn hóa :

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

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

Cũng lưu ý rằng thật bất thường khi có các mẫu hàm với các đối số rõ ràng (không được suy luận). Nó không phải là chưa từng thấy, nhưng thường có những cách tiếp cận tốt hơn.

Tôi nghĩ rằng ngày nay, tốt hơn là sử dụng, nhưng chỉ với C ++ 17.

#include <type_traits>

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

Nếu bạn sử dụng một số thao tác cụ thể kiểu trong if nội dung biểu thức mà không có constexpr, mã này sẽ không biên dịch.

Trong C ++ 17, chúng ta có thể sử dụng các biến thể .

Để sử dụng std::variant, bạn cần bao gồm tiêu đề:

#include <variant>

Sau đó, bạn có thể thêm std::variantmã của mình như sau:

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

Bạn có thể chuyên biệt hóa các mẫu của mình dựa trên những gì được truyền vào các tham số của chúng như sau:

template <> void foo<animal> {

}

Lưu ý rằng điều này tạo ra một hàm hoàn toàn mới dựa trên kiểu được truyền là T. Điều này thường thích hợp hơn vì nó làm giảm sự lộn xộn và về cơ bản là lý do chúng tôi có các mẫu ngay từ đầu.