Làm cách nào để kiểm tra lớp mẫu của tôi là một loại classtype cụ thể?

Question

Trong chức năng ized mẫu của tôi, tôi đang cố gắng kiểm tra loại T là một loại cụ thể. Tôi sẽ làm như thế nào?

p/s Tôi biết cách đặc tả mẫu nhưng tôi không muốn làm điều đó.

template<class T> int foo(T a) { 
    // check if T of type, say, String? 
} 

Cảm ơn!

Answer 1

Tôi cho rằng bạn có thể sử dụng std::type_info trả về bởi các nhà điều hành typeid

Answer 2

Thay vì kiểm tra loại sử dụng chuyên môn. Nếu không, không sử dụng mẫu.

template<class T> int foo(T a) { 
     // generic implementation 
} 
template<> int foo(SpecialType a) { 
    // will be selected by compiler 
} 

SpecialType x; 
OtherType y; 
foo(x); // calls second, specialized version 
foo(y); // calls generic version 

Answer 3

Bạn có thể kiểm tra bằng type_traits (available in Boost and TR1) (ví dụ is_same hoặc is_convertible) nếu bạn thực sự muốn tránh chuyên môn hóa.

Answer 4

Nếu bạn không quan tâm đến thời gian biên dịch, bạn có thể sử dụng boost::is_same.

bool isString = boost::is_same<T, std::string>::value; 

Tính đến C++ 11, đây hiện là một phần của thư viện chuẩn

bool isString = std::is_same<T, std::string>::value 

Answer 5

Bạn có thể thực hiện kiểm tra tĩnh vào loại mà bạn đã nhận được (nhìn vào thư viện đặc điểm tăng type) , nhưng trừ khi bạn sử dụng chuyên môn (hoặc quá tải, như @litb chỉ ra chính xác) tại một điểm hay điểm khác, bạn sẽ không thể cung cấp các triển khai cụ thể khác nhau tùy thuộc vào loại đối số.

Trừ khi bạn có một lý do cụ thể (mà bạn có thể thêm vào câu hỏi) không sử dụng chuyên môn trong giao diện chỉ làm chuyên.

template <> int subtract( std::string const & str); 

Answer 6

Tôi nghi ngờ ai đó nên cho bạn biết lý do tại sao không nên sử dụng quá tải hoặc chuyên môn hóa. Xem xét:

template<class T> int foo(T a) { 
    if(isAString<T>()) { 
    return a.length(); 
    } else { 
    return a; 
    } 
} 

Bạn có thể nghĩ về một cái nhìn đầu tiên mà nó sẽ làm việc cho int quá, bởi vì nó sẽ chỉ cố gắng gọi length cho chuỗi. Nhưng trực giác đó là sai: Trình biên dịch vẫn kiểm tra nhánh chuỗi, ngay cả khi nhánh đó không được thực hiện trong thời gian chạy. Và nó sẽ tìm thấy bạn đang cố gắng gọi một chức năng thành viên trên các lớp không nếu T là một int.

Đó là lý do tại sao bạn nên tách mã nếu bạn cần hành vi khác. Nhưng tốt hơn sử dụng quá tải thay vì chuyên môn, vì nó dễ dàng hơn để có được một đầu mối làm thế nào những thứ làm việc với nó.

template<class T> int foo(T a) { 
    return a; 
} 

int foo(std::string const& a) { 
    return a.length(); 
} 

Bạn cũng đã tách mã tốt hơn cho các hành vi khác nhau. Nó không phải tất cả được gắn lại với nhau. Chú ý rằng với quá tải, các tham số có thể có các dạng khác nhau và trình biên dịch sẽ vẫn sử dụng đúng phiên bản nếu cả hai đều khớp nhau tốt, như trường hợp ở đây: Một có thể là một tham chiếu, trong khi khác thì không.

Answer 7

hmm vì tôi có phần lớn cùng mã cho đến khi phần 'đặc điểm kỹ thuật' .

Bạn có thể sử dụng quá tải, nhưng nếu một phần lớn mã sẽ hoạt động cho bất kỳ loại nào, bạn có thể xem xét giải nén phần khác biệt thành một hàm riêng biệt và quá tải.

template <class T> 
void specific(const T&); 

void specific(const std::string&); 

template <class T> 
void something(const T& t) 
{ 
    //code that works on all types 
    specific(t); 
    //more code that works on all types 
} 

Answer 8

Nếu bạn đang sử dụng C++ 11 hay muộn, std :: is_same thực hiện chính xác những gì bạn muốn:

template <typename T> 
constexpr bool IsFloat() { return std::is_same<T, float>::value; } 

template <typename T> 
void SomeMethodName() { 
    if (IsFloat<T>()) { 
    ... 
    } 
} 

http://en.cppreference.com/w/cpp/types/is_same