संकलन के चरण में टेम्प्लेट जादू या तथ्यात्मक कंप्यूटिंग

शुभ दिन, हबरलुडी!

C ++ गुरु, साथ ही जो लोग टेम्पलेट मेटाप्रोग्रामिंग जानते हैं, वे इस विषय को सुरक्षित रूप से छोड़ सकते हैं, उन्हें यहां अपने लिए कुछ भी नया नहीं मिलेगा। हालाँकि, यदि शीर्षक पढ़ने के बाद, आपको अभी भी इस समस्या का हल नहीं मिला है (और भले ही यह उठी हो, लेकिन टेम्पलेट्स की मदद से नहीं), तो बिल्ली के नीचे आपका स्वागत है।


दरअसल, समस्या का हल:

#include <iostream> template<int n> class Factorial { public: static const int f = Factorial<n - 1>::f * n; }; template<> class Factorial<0> { public: static const int f = 1; }; int main() { std::cout << Factorial<5>::f << std::endl; // 120 } 

आइये देखते हैं क्या है। सबसे पहले, कुछ पूछ सकते हैं - संकलन चरण में मूल्य क्यों गणना की जाती है? उत्तर C ++ में टेम्पलेट्स का आधार है। विशिष्ट कोड को संकलन चरण में उत्पन्न किया जाता है, जो इस बात पर निर्भर करता है कि वास्तव में किस प्रकार का पैरामीटर पैरामीटर किया गया था। लब्बोलुआब यह है कि यदि आप उपयोग करते हैं, उदाहरण के लिए, एक फ़ंक्शन टेम्पलेट जो न्यूनतम दो मान लौटाता है:

 template<class T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; } 

फिर यदि किसी कार्यक्रम में उपयोग किया जाता है, उदाहरण के लिए:

 min(2, 3) 

टाइप इंट के लिए केवल विशेषज्ञता उत्पन्न होती है। और अगर आप लिखते हैं, कुछ इस तरह:

 min(2.0, 3.0) 

यह दोहरे के लिए एक विशेषज्ञता उत्पन्न करता है।

अब, अपने तथ्य पर लौटते हुए, हम यह समझ सकते हैं कि फैक्टरियल <5> टेम्प्लेट जनरेट करने के लिए, फैक्टरियल <4> टेम्प्लेट जेनरेट करना होगा और इसी तरह शून्य पर, जहाँ फैक्टरियल <0> :: f में लिखा गया है ( टेम्प्लेट की स्पष्ट विशेषज्ञता के कारण < > )। यह अंतिम चरण "पुनरावर्ती" टेम्पलेट पीढ़ी को रोकता है, जिसके बाद स्वयं तथ्यात्मक मूल्य की गणना की जाती है। संकलन चरण में क्यों? क्योंकि स्थिर स्थिरांक int int f एक स्थिर समय स्थिरांक है। यदि कोई इस पर विश्वास नहीं करता है, तो आप कुछ टेम्प्लेट मान को सरणी की लंबाई के रूप में सेट कर सकते हैं, और कार्यक्रम का एक शांत संकलन देख सकते हैं।

ब्रूस एकेल की पुस्तक फिलोसॉफी ऑफ सी ++ में। व्यावहारिक प्रोग्रामिंग । इस समस्या का निम्नलिखित समाधान दिया गया है (जो अनिवार्य रूप से उपरोक्त से भिन्न नहीं है):

 template<int n> struct { enum {val = Factorial<n - 1> * n}; }; template<> struct Factorial<0>{ enum {val = 1}; }; 

सामान्य तौर पर, इस तरह की एक तथ्यात्मक गणना टेम्पलेट मेटाप्रोग्रामिंग का एक विशेष मामला है। उदाहरण के लिए, एक पावर q, पूर्णांक p तक बढ़ाकर, लूप में लिखा जा सकता है:

 int power = 1; while (q--) power *= p; 

लेकिन यह टेम्पलेट मेटाप्रोग्रामिंग की मदद से भी संभव है:

 template<int p, int q> class Power { public: static const int value = p * Power<p, q - 1>::value; }; template<int p> class Power<p, 0> { public: static const int value = 1; } 

आप इसके बारे में अधिक पढ़ सकते हैं, उदाहरण के लिए, इकोल पर, फिलॉसफी सी ++ पुस्तक में । प्रैक्टिकल प्रोग्रामिंग , या अलेक्जेंड्रेस्कु की पुस्तक मॉडर्न डिज़ाइन इन सी ++ ।

आपका ध्यान के लिए धन्यवाद!