chuyên môn mẫu cho các hàm thành viên tĩnh; làm thế nào để?

Question

Tôi đang cố triển khai một hàm mẫu có các chốt điều khiển khác nhau bằng cách sử dụng chuyên môn mẫu.

Các mã sau đây mang lại cho tôi một "chuyên môn hóa rõ ràng trong phạm vi không gian tên" trong gcc:

template <typename T> 
static T safeGuiCall(boost::function<T()> _f) 
{ 
    if (_f.empty()) 
     throw GuiException("Function pointer empty"); 
    { 
     ThreadGuard g; 
     T ret = _f(); 
     return ret; 
    } 
} 

// template specialization for functions wit no return value 
template <> 
static void safeGuiCall<void>(boost::function<void()> _f) 
{ 
    if (_f.empty()) 
     throw GuiException("Function pointer empty"); 
    { 
     ThreadGuard g; 
     _f(); 
    } 
} 

Tôi đã cố gắng di chuyển nó ra khỏi lớp (lớp không được templated) và vào namespace nhưng sau đó tôi nhận được lỗi "Chuyên sâu rõ ràng không thể có một lớp lưu trữ". Tôi đã đọc nhiều cuộc thảo luận về điều này, nhưng mọi người dường như không đồng ý làm thế nào để chuyên về các mẫu chức năng. Bất kỳ ý tưởng?

Answer 1

Khi bạn chuyên một phương pháp templated, bạn phải làm như vậy bên ngoài dấu ngoặc lớp:

template <typename X> struct Test {}; // to simulate type dependency 

struct X // class declaration: only generic 
{ 
    template <typename T> 
    static void f(Test<T>); 
}; 

// template definition: 
template <typename T> 
void X::f(Test<T>) { 
    std::cout << "generic" << std::endl; 
} 
template <> 
inline void X::f<void>(Test<void>) { 
    std::cout << "specific" << std::endl; 
} 

int main() 
{ 
    Test<int> ti; 
    Test<void> tv; 
    X::f(ti); // prints 'generic' 
    X::f(tv); // prints 'specific' 
} 

Khi bạn mang nó bên ngoài của lớp, bạn phải loại bỏ các từ khóa 'tĩnh'. Từ khóa tĩnh bên ngoài lớp có một ý nghĩa cụ thể khác với những gì bạn có thể muốn.

template <typename X> struct Test {}; // to simulate type dependency 

template <typename T> 
void f(Test<T>) { 
    std::cout << "generic" << std::endl; 
} 
template <> 
void f<void>(Test<void>) { 
    std::cout << "specific" << std::endl; 
} 

int main() 
{ 
    Test<int> ti; 
    Test<void> tv; 
    f(ti); // prints 'generic' 
    f(tv); // prints 'specific' 
} 

Answer 2

Bạn có thể khai báo chuyên môn hóa rõ ràng trong cùng một cách bạn muốn định nghĩa một hàm thành viên bên ngoài lớp học của nó:

class A 
{ 
public: 
    template <typename T> 
    static void foo() {} 
}; 

template <> 
void A::foo<void>() 
{ 
} 

Answer 3

Vấn đề của bạn dường như là với boost :: Chức năng - các chuyên ngành sau đây làm việc:

Answer 4

Nó không phải trực tiếp một câu trả lời cho câu hỏi của bạn, nhưng bạn có thể viết này

template <typename T> 
static T safeGuiCall(boost::function<T()> _f) 
{ 
     if (_f.empty()) 
       throw GuiException("Function pointer empty"); 
     { 
       ThreadGuard g; 
       return _f(); 
     } 
} 

Nó sẽ hoạt động ngay cả khi _f() trả lại 'void'

Chỉnh sửa: Trong trường hợp tổng quát hơn, tôi nghĩ chúng ta nên thích quá tải hàm thay vì chuyên môn hóa. Dưới đây là một lời giải thích tốt cho việc này: http://www.gotw.ca/publications/mill17.htm

Answer 5

Tôi gặp sự cố tương tự. Nếu bạn nhìn vào bài viết gốc, tôi để lại cái tĩnh đầu tiên, nhưng lấy ra lỗi thứ hai và BOTH đã biến mất.