সংক্ষেপে, সিআরটিপি হয় যখন কোনও ক্লাসের Aএকটি বেস ক্লাস থাকে যা ক্লাসের জন্য Aনিজেই একটি টেম্পলেট বিশেষীকরণ । যেমন
template <class T>
class X{...};
class A : public X<A> {...};
এটা তোলে হয় অদ্ভুতভাবে, আবর্তক তাই না? :)
এখন, এটি আপনাকে কী দেয়? এটি প্রকৃতপক্ষে Xটেমপ্লেটটিকে তার বিশেষত্বের জন্য বেস বর্গ হওয়ার ক্ষমতা দেয় ।
উদাহরণস্বরূপ, আপনি এর মতো জেনেরিক সিঙ্গলটন ক্লাস (সরলীকৃত সংস্করণ) তৈরি করতে পারেন
template <class ActualClass>
class Singleton
{
public:
static ActualClass& GetInstance()
{
if(p == nullptr)
p = new ActualClass;
return *p;
}
protected:
static ActualClass* p;
private:
Singleton(){}
Singleton(Singleton const &);
Singleton& operator = (Singleton const &);
};
template <class T>
T* Singleton<T>::p = nullptr;
এখন, একটি স্বেচ্ছাসেবক শ্রেণিকে Aএকটি সিঙ্গলটন করার জন্য আপনার এটি করা উচিত
class A: public Singleton<A>
{
//Rest of functionality for class A
};
তাহলে তুমি দেখ? সিঙ্গেলটন টেমপ্লেট ধরে নিয়েছে যে কোনও ধরণের জন্য এর বিশেষীকরণটি Xউত্তরাধিকার সূত্রে প্রাপ্ত singleton<X>হবে এবং সুতরাং এর সাথে তার সমস্ত (জনসাধারণ, সুরক্ষিত) সদস্য অ্যাক্সেসযোগ্য থাকবে GetInstance! সিআরটিপি এর অন্যান্য দরকারী ব্যবহার রয়েছে। উদাহরণস্বরূপ, আপনি যদি বর্তমানে আপনার শ্রেণীর জন্য বিদ্যমান সমস্ত উদাহরণ গণনা করতে চান তবে এই যুক্তিটিকে একটি পৃথক টেম্পলেটে আবদ্ধ করতে চান (একটি কংক্রিট বর্গের ধারণাটি বেশ সহজ - একটি স্ট্যাটিক ভেরিয়েবল, সিটারে বর্ধন, ডিটারে হ্রাস) )। অনুশীলন হিসাবে এটি করার চেষ্টা করুন!
তবুও আরেকটি দরকারী উদাহরণ, বুস্টের জন্য (তারা কীভাবে এটি প্রয়োগ করেছে তা আমি নিশ্চিত নই, তবে সিআরটিপিও তা করবে) do কল্পনা করুন আপনি <নিজের ক্লাসের জন্য কেবল অপারেটর সরবরাহ করতে চান তবে ==তাদের জন্য স্বয়ংক্রিয়ভাবে অপারেটর !
আপনি এটি এইভাবে করতে পারে:
template<class Derived>
class Equality
{
};
template <class Derived>
bool operator == (Equality<Derived> const& op1, Equality<Derived> const & op2)
{
Derived const& d1 = static_cast<Derived const&>(op1);//you assume this works
//because you know that the dynamic type will actually be your template parameter.
//wonderful, isn't it?
Derived const& d2 = static_cast<Derived const&>(op2);
return !(d1 < d2) && !(d2 < d1);//assuming derived has operator <
}
এখন আপনি এটি এর মতো ব্যবহার করতে পারেন
struct Apple:public Equality<Apple>
{
int size;
};
bool operator < (Apple const & a1, Apple const& a2)
{
return a1.size < a2.size;
}
এখন, আপনি স্পষ্টভাবে অপারেটর প্রদান করেন নি ==জন্য Apple? তবে আপনি এটি আছে! তুমি লিখতে পারো
int main()
{
Apple a1;
Apple a2;
a1.size = 10;
a2.size = 10;
if(a1 == a2) //the compiler won't complain!
{
}
}
এই মনে করতে পারে যে আপনি কম লিখতে হবে যদি আপনি শুধু অপারেটর লিখেছিলেন ==জন্য Apple, কিন্তু কল্পনা Equalityটেমপ্লেট না শুধুমাত্র প্রদান করবে ==কিন্তু >, >=, <=ইত্যাদি আপনার জন্য এই সংজ্ঞা ব্যবহার করতে পারে একাধিক ক্লাস, কোড পুনঃব্যবহার!
সিআরটিপি একটি দুর্দান্ত জিনিস :) এইচটিএইচ