Perché il modello di funzione non può essere parzialmente specializzato?

So che la specifica del linguaggio proibisce la specializzazione parziale del modello di funzione.

Vorrei conoscere la logica del perché lo vieta? Non sono utili?

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 che è cambiato in C ++ 0x.

Immagino sia stata solo una svista (considerando che puoi sempre ottenere l'effetto di specializzazione parziale con codice più dettagliato, posizionando la funzione come staticmembro di una classe).

Potresti cercare il DR (Rapporto sui difetti) pertinente, se presente.

EDIT : controllando questo, trovo che anche altri lo abbiano creduto, ma nessuno è in grado di trovare un tale supporto nella bozza di standard. Questo thread SO sembra indicare che la specializzazione parziale dei modelli di funzione non è supportata in C ++ 0x .

EDIT 2 : solo un esempio di cosa intendevo con "posizionare la funzione come staticmembro di una classe":

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

Bene, non puoi davvero fare la specializzazione parziale di funzione / metodo, tuttavia puoi eseguire il sovraccarico.

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

È così ma non so se ti soddisfa.

In generale, non è consigliabile specializzare i modelli di funzione, a causa di problemi con il sovraccarico. Ecco un buon articolo dal C / C ++ Users Journal: http://www.gotw.ca/publications/mill17.htm

E contiene una risposta onesta alla tua domanda:

Per prima cosa, non puoi specializzarli parzialmente, praticamente solo perché la lingua dice che non puoi.

Poiché puoi specializzare parzialmente le classi, puoi usare un funtore:

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