Có thể sử dụng std :: enable_if để chọn chuyên môn về mẫu thành viên không?

Question

Cho một khai báo lớp

class A { 
    template <typename T> T foo(); 
}; 

Tôi muốn chuyên A::foo với nhiều loại hình (int, ...) và các lớp học kiểu (POD, không POD) của T. Thật không may, tôi dường như không thể sử dụng std::enable_if cho mục đích sau. Sau đây không biên dịch:

template <> int A::foo<int>(); // OK 

template <typename T> 
typename std::enable_if<is_pod<T>::value, T>::type foo(); // <<<< NOT OK! 

template <typename T> 
typename std::enable_if<!is_pod<T>::value, T>::type foo(); // <<<< NOT OK! 

Vấn đề này có lẽ là do sự std::enable_if<...> thứ là một phần của chữ ký chức năng, và rằng tôi đã không công bố bất kỳ thành viên đó bên A. Vì vậy, làm thế nào tôi có thể chuyên một thành viên mẫu dựa trên các đặc điểm kiểu?

Answer 1

Tôi thấy không có lý do gì để chuyên đây, quá tải chức năng dường như đủ trong tâm trí tôi.

struct A 
{ 
    template <typename T> 
    typename std::enable_if<std::is_integral<T>::value, T>::type foo() 
    { 
     std::cout << "integral" << std::endl; 
     return T(); 
    } 

    template <typename T> 
    typename std::enable_if<!std::is_integral<T>::value, T>::type foo() 
    { 
     std::cout << "not integral" << std::endl; 
     return T(); 
    } 
} 

Khi kiểm tra POD hoặc không có POD, bạn chỉ có hai lựa chọn này, vì vậy chức năng chung hơn là không cần thiết (và không được phép, vì sẽ mơ hồ). Bạn cần nhiều hơn thế? Bạn có thể kiểm tra các loại rõ ràng mà không cần chuyên môn hóa với sự trợ giúp của std::enable_if<std::is_same<int, T>::value, T>::type.

Answer 2

tôi muốn chỉ về phía trước này cho một cấu trúc, mà xử lý này cũng:

#include <type_traits> 
#include <iostream> 

template <typename T, typename = void> 
struct FooCaller; 

class A { 
public: 
    template <typename T> 
    T foo() { 
     // Forward the call to a structure, let the structure choose 
     // the specialization. 
     return FooCaller<T>::call(*this); 
    } 
}; 

// Specialize for PODs. 
template <typename T> 
struct FooCaller<T, typename std::enable_if<std::is_pod<T>::value>::type> { 
    static T call(A& self) { 
     std::cout << "pod." << std::endl; 
     return T(); 
    } 
}; 

// Specialize for non-PODs.  
template <typename T> 
struct FooCaller<T, typename std::enable_if<!std::is_pod<T>::value>::type> { 
    static T call(A& self) { 
     std::cout << "non-pod." << std::endl; 
     return T(); 
    } 
}; 

// Specialize for 'int'. 
template <> 
struct FooCaller<int> { 
    static int call(A& self) { 
     std::cout << "int." << std::endl; 
     return 0; 
    } 
};