AFAIK qui a changé dans C ++ 0x.
Je suppose que c'était juste un oubli (étant donné que vous pouvez toujours obtenir l'effet de spécialisation partielle avec un code plus détaillé, en plaçant la fonction en tant que static
membre d'une classe).
Vous pouvez rechercher le DR (rapport d'anomalie) pertinent, s'il y en a un.
EDIT : en vérifiant cela, je trouve que d'autres ont également cru cela, mais personne n'est en mesure de trouver un tel soutien dans le projet de norme. Ce thread SO semble indiquer que la spécialisation partielle des modèles de fonctions n'est pas prise en charge dans C ++ 0x .
EDIT 2 : juste un exemple de ce que je voulais dire par "placer la fonction comme static
membre d'une classe":
#include <iostream>
using namespace std;
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" ); }
};
}
template< class T, class U >
void f() { detail::F<T, U>::impl(); }
int main() {
f<char const*, double>();
f<int, char>();
f<char, double>();
f<double, int>();
}
template<typename T, typename U> void f(T t, U u) {}
aussitemplate<> void f(int t, char u) {}
est autorisé.