কেন ফাংশন টেমপ্লেট আংশিকভাবে বিশেষজ্ঞ করা যায় না?

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

~~আফাইক যে সি ++ 0x এ পরিবর্তিত হয়েছে।~~

আমার ধারণা এটি কেবল একটি পর্যবেক্ষণ ছিল (এই বিষয়টি বিবেচনা করে যে আপনি সবসময় আরও ভার্বোজ কোড সহ আংশিক বিশেষায়নের প্রভাব পেতে পারেন static, কোনও শ্রেণীর সদস্য হিসাবে ফাংশন স্থাপন করে )।

যদি কোনও থাকে তবে আপনি প্রাসঙ্গিক ডিআর (ত্রুটি প্রতিবেদন) সন্ধান করতে পারেন।

সম্পাদনা : এটি পরীক্ষা করে, আমি দেখতে পেলাম যে অন্যরাও বিশ্বাস করেছে যে, তবে খসড়া স্ট্যান্ডার্ডে কেউ এ জাতীয় সমর্থন খুঁজে পাচ্ছে না। এই SO থ্রেডটি ইঙ্গিত দেয় যে ফাংশন টেম্পলেটগুলির আংশিক বিশেষত্ব C ++ 0x এ সমর্থিত নয় ।

সম্পাদনা 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

সাধারণভাবে, ওভারলোডিংয়ের ঝামেলার কারণে ফাংশন টেম্পলেটগুলিকে মোটেও বিশেষায়িত করার পরামর্শ দেওয়া হয় না। এখানে সি / সি ++ ব্যবহারকারী জার্নালের একটি ভাল নিবন্ধ: 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 ;
}