C++ 11: Template Function Chuyên cho Integer loại

Question

Giả sử tôi có một hàm template:

template<typename T> 
void f(T t) 
{ 
    ... 
} 

và tôi muốn viết một chuyên môn hóa cho tất cả các loại nguyên nguyên thủy. Cách tốt nhất để làm việc này là gì?

Những gì tôi có nghĩa là:

template<typename I where is_integral<I>::value is true> 
void f(I i) 
{ 
    ... 
} 

và trình biên dịch chọn phiên bản thứ hai với nhiều loại nguyên, và phiên bản đầu tiên cho tất cả mọi thứ khác?

Answer 1

Sử dụng SFINAE

// For all types except integral types: 
template<typename T> 
typename std::enable_if<!std::is_integral<T>::value>::type f(T t) 
{ 
    // ... 
} 

// For integral types only: 
template<typename T> 
typename std::enable_if<std::is_integral<T>::value>::type f(T t) 
{ 
    // ... 
} 

Lưu ý rằng bạn sẽ phải bao gồm đầy đủ các std::enable_if giá trị trả về ngay cả đối với khai báo.

Answer 2

dùng C++ 11, std :: enable_if (http://en.cppreference.com/w/cpp/types/enable_if) có thể được sử dụng để làm điều đó:

template<typename T, class = typename std::enable_if<std::is_integral<T>::value>::type> 
void f(T t) {...} 

Answer 3

Bạn có thể sử dụng một mẫu helper mà bạn có thể chuyên như thế này:

#include <string> 
#include <iostream> 
#include <type_traits> 

template <typename T, bool = std::is_integral<T>::value> 
struct Foo { 
     static void bar(const T& t) { std::cout << "generic: " << t << "\n"; } 
}; 
template <typename T> 
struct Foo<T, true> { 
     static void bar(const T& t) { std::cout << "integral: " << t << "\n"; } 
}; 

template <typename T> 
static void bar(const T& t) { 
     return Foo<T>::bar(t); 
} 

int main() { 
     std::string s = "string"; 
     bar(s); 
     int i = 42; 
     bar(i); 
     return 0; 
} 

đầu ra:

generic: string 
integral: 42 

Answer 4

Tôi sẽ sử dụng độ phân giải quá tải. Điều đó sẽ khiến bạn không phải sử dụng toàn bộ SFINAE hack. Thật không may có rất nhiều lĩnh vực mà bạn không thể tránh được nó, nhưng may mắn thay không phải là một trong số đó.

template<typename T> 
void f(T t) 
{ 
    f(t, std::is_integral<T>()); 
} 

template<typename T> 
void f(T t, std::true_type) 
{ 
    // ... 
} 

template<typename T> 
void f(T t, std::false_type) 
{ 
    // ... 
}