Mengapa template fungsi tidak dapat dikhususkan sebagian?

Saya tahu spesifikasi bahasa melarang spesialisasi parsial dari template fungsi.

Saya ingin tahu alasan mengapa melarangnya? Apakah mereka tidak berguna?

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!

AFAIK yang diubah di C ++ 0x.

Saya kira itu hanya kekeliruan (mengingat Anda selalu bisa mendapatkan efek spesialisasi parsial dengan kode yang lebih verbose, dengan menempatkan fungsi sebagai staticanggota kelas).

Anda dapat mencari DR (Laporan Cacat) yang relevan, jika ada.

EDIT : memeriksa ini, saya menemukan bahwa orang lain juga percaya itu, tetapi tidak ada yang dapat menemukan dukungan seperti itu dalam standar draf. Utas SO ini tampaknya menunjukkan bahwa spesialisasi sebagian dari templat fungsi tidak didukung di C ++ 0x .

EDIT 2 : hanya contoh dari apa yang saya maksud dengan "menempatkan fungsi sebagai staticanggota kelas":

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

Nah, Anda benar-benar tidak dapat melakukan spesialisasi fungsi / metode parsial namun Anda dapat melakukan 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){...} 

Ini adalah jalannya tetapi saya tidak tahu apakah itu memuaskan Anda.

Secara umum, tidak disarankan untuk mengkhususkan template fungsi sama sekali, karena ada masalah dengan kelebihan muatan. Berikut artikel bagus dari C / C ++ Users Journal: http://www.gotw.ca/publications/mill17.htm

Dan itu berisi jawaban jujur ​​atas pertanyaan Anda:

Untuk satu hal, Anda tidak dapat mengkhususkan mereka sebagian - cukup banyak hanya karena bahasanya mengatakan Anda tidak bisa.

Karena Anda dapat mengkhususkan sebagian kelas, Anda dapat menggunakan 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 ;
}