[ACCEPTED]-Why function template cannot be partially specialized?-function-templates

Accepted answer

Score: 60

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

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

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

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

EDIT 2: just an example of what I meant by "placing 1 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
}

Score: 19

Well, you really can't do partial function/method 3 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 2 is the way but I do not know if it satisfy 1 you.

Score: 15

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

And it contains 4 an honest answer to your question:

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

Score: 11

Since you can partially specialize classes, you 1 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 ;
}

Source: stackoverflow.com

[ACCEPTED]-Why function template cannot be partially specialized?-function-templates

C++ template specialization on functions

Declaration of template class member specialization

How to conditionally add a function to a class template?

Partial specialization of templates with integer parameters

Cannot be explicitly specialized

How to enforce use of template specialization?

Why is it not possible to overload class templates?

Inlining Template Specialization

template<>" vs "template" without brackets - what's the difference?

Template member function specialization in a template class