¿Por qué la plantilla de función no puede ser parcialmente especializada?

Question

Sé que la especificación de idioma prohíbe parcial especialización de plantilla de función.

Me gustaría saber la razón por la que lo prohíbe? ¿No son útiles?

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! 

Answer 1

yo sepa lo que ha cambiado en C++ 0x.

Supongo que fue solo un descuido (teniendo en cuenta que siempre se puede obtener el efecto de especialización parcial con un código más detallado, al colocar la función como miembro static de una clase).

Puede buscar el DR relevante (Informe de defectos), si lo hay.

EDIT: comprobando esto, me parece que otros también lo han creído, pero nadie puede encontrar tal soporte en el borrador del estándar. This SO thread parece indicar que especialización parcial de plantillas de funciones no es compatible con C++ 0x.

EDIT 2: sólo un ejemplo de lo que quería decir con "la colocación de la función como miembro static de una clase":

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

Answer 2

En general, no es recomendable para especializarse plantillas de función en absoluto, debido a problemas con la sobrecarga He aquí un buen artículo de la C/C++ Diario Usuarios: http://www.gotw.ca/publications/mill17.htm

Y contiene una respuesta sincera a su pregunta:

Por un lado, no se puede especializar en parte de ellos - más o menos sólo porque el lenguaje dice que no puedes.

Answer 3

Bueno, realmente no se puede hacer una especialización parcial de función/método, pero se puede sobrecargar.

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

Es el camino, pero no sé si te satisface.

Answer 4

Ya que se puede especializar parcialmente clases, puede utilizar un funtor:

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