为什么函数模板不能部分专门化？

AFAIK that's changed in C++0x.

I guess it was just an oversight (considering that you can always get the partial specialization effect with more verbose code, by placing the function as a static member of a class).

You might look up the relevant DR (Defect Report), if there is one.

EDIT: checking this, I find that others have also believed that, but no-one is able to find any such support in the draft standard. This SO thread seems to indicate that partial specialization of function templates is not supported in C++0x.

EDIT 2: just an example of what I meant by "placing the function as a static member of a class":

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

In general, it's not recommended to specialize function templates at all, because of troubles with overloading. Here's a good article from the C/C++ Users Journal: http://www.gotw.ca/publications/mill17.htm

And it contains an honest answer to your question:

For one thing, you can't partially specialize them -- pretty much just because the language says you can't.

Well, you really can't do partial function/method specialization however you can do overloading.

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

It is the way but I do not know if it satisfy you.

Since you can partially specialize classes, you can use a functor:

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