Чому шаблон функції не може бути частково спеціалізованим?

Я знаю, що специфікація мови забороняє часткову спеціалізацію шаблону функції.

Я хотів би знати обгрунтування, чому це забороняє? Вони не корисні?

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 ++ 0x.

Я припускаю, що це був просто недогляд (враховуючи, що ви завжди можете отримати ефект часткової спеціалізації за допомогою більш детального коду, розмістивши функцію як staticчлена класу).

Ви можете переглянути відповідний DR (Звіт про дефекти), якщо він є.

РЕДАКТУВАТИ : перевіряючи це, я виявляю, що інші також вірили в це, але ніхто не може знайти такої підтримки в проекті стандарту. Цей потік SO, схоже, вказує на те, що часткова спеціалізація шаблонів функцій не підтримується в C ++ 0x .

EDIT 2 : лише приклад того, що я мав на увазі під "розміщенням функції як staticчлена класу":

#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
}

Ну, ви дійсно не можете зробити часткову спеціалізацію функцій / методів, однак ви можете зробити перевантаження.

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){...} 

Це шлях, але я не знаю, чи задовольнить він вас.

Загалом, не рекомендується спеціалізуватись на шаблонах функцій взагалі через проблеми з перевантаженням. Ось хороша стаття з журналу користувачів C / C ++: http://www.gotw.ca/publications/mill17.htm

І він містить чесну відповідь на ваше запитання:

З одного боку, ви не можете частково їх спеціалізувати - в основному лише тому, що мова говорить, що ви не можете.

Оскільки ви можете частково спеціалізуватись на заняттях, ви можете використовувати функтор:

#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 ;
}