क्यों फ़ंक्शन टेम्पलेट आंशिक रूप से विशेष नहीं हो सकता है?

Question 1

मुझे पता है कि भाषा विनिर्देश फ़ंक्शन टेम्पलेट के आंशिक विशेषज्ञता को मना करता है।

मैं तर्क को जानना चाहूंगा कि यह क्यों मना करता है? क्या वे उपयोगी नहीं हैं?

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!

Question 2

~~AFAIK जो C ++ 0x में बदल गया है।~~

मुझे लगता है कि यह सिर्फ एक निरीक्षण था (यह विचार करते हुए कि आप हमेशा staticएक वर्ग के सदस्य के रूप में फ़ंक्शन को रखकर अधिक क्रिया कोड के साथ आंशिक विशेषज्ञता प्रभाव प्राप्त कर सकते हैं )।

आप प्रासंगिक डीआर (दोष रिपोर्ट) देख सकते हैं, यदि कोई है।

EDIT : इसे जाँचते हुए , मुझे लगता है कि अन्य लोगों ने भी माना है कि, लेकिन कोई भी मसौदा मानक में ऐसा कोई समर्थन नहीं पा रहा है। यह SO थ्रेड इंगित करता है कि C ++ 0x में फ़ंक्शन टेम्प्लेट का आंशिक विशेषज्ञता समर्थित नहीं है ।

EDIT 2 : मेरे द्वारा " staticएक वर्ग के सदस्य के रूप में कार्य को प्रस्तुत करने" का सिर्फ एक उदाहरण है :

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

Question 3

हालांकि, आप वास्तव में आंशिक कार्य / विधि विशेषज्ञता नहीं कर सकते हैं, हालांकि आप ओवरलोडिंग कर सकते हैं।

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

यह तरीका है लेकिन मुझे नहीं पता कि यह आपको संतुष्ट करता है।

Question 4

सामान्य तौर पर, ओवरलोडिंग से होने वाली परेशानियों के कारण, फंक्शन टेम्प्लेट्स को विशेषज्ञ बनाने की सिफारिश नहीं की जाती है। यहाँ C / C ++ उपयोगकर्ता जर्नल से एक अच्छा लेख है: http://www.gotw.ca/publications/mill17.htm

और इसमें आपके प्रश्न का ईमानदार उत्तर है:

एक बात के लिए, आप उन्हें आंशिक रूप से विशेषज्ञ नहीं बना सकते हैं - बहुत ज्यादा सिर्फ इसलिए क्योंकि भाषा कहती है कि आप नहीं कर सकते।

Question 5

चूँकि आप आंशिक रूप से वर्गों का विशेषज्ञ बन सकते हैं, आप एक फ़नकार का उपयोग कर सकते हैं:

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