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!
template<typename T, typename U> void f(T t, U u) {}
jugatemplate<> void f(int t, char u) {}
diperbolehkan.Jawaban:
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
static
anggota 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
static
anggota 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 }
sumber
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.
sumber
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:
sumber
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 ; }
sumber
()()
sintaks yang jelek .