Tại sao mẫu hàm không thể chuyên biệt một phần?

Tôi biết đặc tả ngôn ngữ cấm chuyên môn hóa từng phần của mẫu hàm.

Tôi muốn biết lý do tại sao nó cấm nó? Chúng không hữu ích?

template<typename T, typename U> void f() {}   //allowed!
template<> void f<int, char>()            {}   //allowed!
template<typename T> void f<char, T>()    {}   //not allowed!
template<typename T> void f<T, int>()     {}   //not allowed!

AFAIK đã được thay đổi trong C ++ 0x.

Tôi đoán đó chỉ là một sự giám sát (xem xét rằng bạn luôn có thể nhận được hiệu ứng chuyên môn hóa từng phần với nhiều mã dài dòng hơn, bằng cách đặt hàm như một staticthành viên của một lớp).

Bạn có thể tra cứu DR (Báo cáo lỗi) có liên quan, nếu có.

CHỈNH SỬA : kiểm tra điều này, tôi thấy rằng những người khác cũng đã tin vào điều đó, nhưng không ai có thể tìm thấy bất kỳ hỗ trợ nào như vậy trong tiêu chuẩn dự thảo. Chủ đề SO này dường như chỉ ra rằng chuyên môn hóa một phần của các mẫu hàm không được hỗ trợ trong C ++ 0x .

CHỈNH SỬA 2 : chỉ là một ví dụ về ý của tôi khi "đặt hàm như một staticthành viên của một lớp":

#include <iostream>
using namespace std;

// template<typename T, typename U> void f() {}   //allowed!
// template<> void f<int, char>()            {}   //allowed!
// template<typename T> void f<char, T>()    {}   //not allowed!
// template<typename T> void f<T, int>()     {}   //not allowed!

void say( char const s[] ) { std::cout << s << std::endl; }

namespace detail {
    template< class T, class U >
    struct F {
        static void impl() { say( "1. primary template" ); }
    };

    template<>
    struct F<int, char> {
        static void impl() { say( "2. <int, char> explicit specialization" ); }
    };

    template< class T >
    struct F< char, T > {
        static void impl() { say( "3. <char, T> partial specialization" ); }
    };

    template< class T >
    struct F< T, int > {
        static void impl() { say( "4. <T, int> partial specialization" ); }
    };
}  // namespace detail

template< class T, class U >
void f() { detail::F<T, U>::impl(); }    

int main() {
    f<char const*, double>();       // 1
    f<int, char>();                 // 2
    f<char, double>();              // 3
    f<double, int>();               // 4
}

Chà, bạn thực sự không thể chuyên môn hóa một phần hàm / phương thức, tuy nhiên bạn có thể làm quá tải.

template <typename T, typename U>
T fun(U pObj){...}

// acts like partial specialization <T, int> AFAIK 
// (based on Modern C++ Design by Alexandrescu)
template <typename T>
T fun(int pObj){...} 

Đó là cách nhưng tôi không biết nó có làm hài lòng bạn không.

Nói chung, không nên chuyên biệt hóa các mẫu hàm, vì những rắc rối với quá tải. Đây là một bài báo hay từ Tạp chí Người dùng C / C ++: http://www.gotw.ca/publications/mill17.htm

Và nó chứa một câu trả lời trung thực cho câu hỏi của bạn:

Có điều, bạn không thể chuyên môn hóa chúng một phần - khá nhiều chỉ vì ngôn ngữ nói rằng bạn không thể.

Vì bạn có thể chuyên môn hóa một phần các lớp, nên bạn có thể sử dụng một trình biểu diễn:

#include <iostream>

template < typename dtype , int k > struct fun
{
 int operator()()
 {
  return k ;
 }
} ;

template < typename dtype > struct fun < dtype , 0 >
{
 int operator()()
 {
  return 42 ;
 }
} ;

int main ( int argc , char * argv[] )
{
 std::cout << fun<float,5>()() << std::endl ;
 std::cout << fun<float,0>()() << std::endl ;
}