Neden işlev şablonu kısmen özelleştirilemez?

Dil belirtiminin kısmen yasakladığını biliyorum , işlev şablonunun uzmanlaşmasını .

Bunu neden yasakladığının gerekçesini bilmek isterim? Yararlı değiller mi?

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!

C ++ 0x'de değiştirilen AFAIK.

Sanırım bu sadece bir gözetimden ibaretti (kısmi uzmanlaşma etkisini her zaman daha ayrıntılı kodla, işlevi staticbir sınıfın üyesi olarak yerleştirerek elde edebileceğinizi düşünürsek ).

Varsa, ilgili DR'ye (Kusur Raporu) bakabilirsiniz.

DÜZENLEME : Bunu kontrol ederek, başkalarının da buna inandığını görüyorum, ancak taslak standartta hiç kimse böyle bir destek bulamıyor. Bu SO iş parçacığı , işlev şablonlarının kısmi uzmanlaşmasının C ++ 0x'de desteklenmediğini gösteriyor gibi görünüyor .

DÜZENLEME 2 : "işlevi staticbir sınıfın üyesi olarak yerleştirmekle" ne demek istediğime dair sadece bir örnek :

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

Pekala, gerçekten kısmi işlev / yöntem uzmanlığı yapamazsınız, ancak aşırı yükleme yapabilirsiniz.

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

Bu yol ama seni tatmin edip etmediğini bilmiyorum.

Genel olarak, aşırı yükleme ile ilgili sorunlar nedeniyle işlev şablonlarının hiç özelleştirilmesi önerilmez. İşte C / C ++ Users Journal'dan güzel bir makale: http://www.gotw.ca/publications/mill17.htm

Ve sorunuza dürüst bir cevap içerir:

Birincisi, onları kısmen uzmanlaştıramazsınız - büyük ölçüde sadece dil yapamayacağınızı söylediği için.

Sınıfları kısmen özelleştirebildiğiniz için bir functor kullanabilirsiniz:

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