C ++ 0x में वैरेडिक टेम्प्लेट

जो लोग आंद्रेई अलेक्जेंड्रेस्कु "मॉडर्न सी ++ प्रोग्रामिंग" की किताब पढ़ते हैं, वे जानते हैं कि कार्यों की एक व्यापक श्रेणी है (टेम्पलेट का उपयोग करते हुए मेटाप्रोग्रामिंग के क्षेत्र में), जब एक टेम्पलेट को तर्कों की एक चर (पूर्व अज्ञात) संख्या निर्दिष्ट करने की आवश्यकता होती है। ऐसे कार्यों के विशिष्ट उदाहरण:
- टुपल्स का विवरण
- विकल्पों की तरह प्रकार का विवरण
- फंक्शनलर्स का विवरण (इस मामले में, तर्क प्रकारों की सूची फ़ंक्शन के हस्ताक्षर पर निर्भर करती है)
- पूर्वनिर्धारित सेटों के आधार पर वर्गीकरण
- आदि।

इस तरह के प्रत्येक कार्य में, तर्कों के अनुसार पारित किए गए प्रकारों की सही संख्या अग्रिम में निर्धारित करना मुश्किल है। और, आम तौर पर बोलना, यह उसी की इच्छा और जरूरतों पर निर्भर करता है जो संबंधित टेम्पलेट वर्ग का उपयोग करने का इरादा रखता है।
वर्तमान सी ++ मानक के तहत, ऐसी समस्याओं का कोई सुविधाजनक समाधान नहीं है। टेम्प्लेट मापदंडों की कड़ाई से परिभाषित संख्या ले सकते हैं और कुछ नहीं। ए। अलेक्जेंड्रेस्कु (ऊपर उल्लिखित पुस्तक में) तथाकथित के आधार पर एक सामान्य समाधान प्रदान करता है। "टाइप सूची", जिसमें प्रकारों को पुनरावर्ती पैटर्न के माध्यम से कार्यान्वित एक एकल लिंक की गई सूची के रूप में दर्शाया गया है। एक वैकल्पिक समाधान (उदाहरण के लिए, बढ़ावा देने में :: वैरिएंट और बूस्ट :: टपल) को बड़ी संख्या में मापदंडों के साथ एक टेम्प्लेट क्लास घोषित करना है, जिसमें (सभी लेकिन पहले) कुछ डिफ़ॉल्ट मूल्य हैं। ये दोनों समाधान आधे-अधूरे हैं और संभव कार्यों की पूरी श्रृंखला को कवर नहीं करते हैं। इसलिए, मौजूदा समाधानों की कमियों को खत्म करने और कोड को सरल बनाने के लिए, नया मानक C ++ - डेवलपर्स को टेम्प्लेट घोषित करने का एक नया विकल्प प्रदान करता है? "पैरामीटर की एक चर संख्या के साथ टेम्पलेट" या, मूल में, "वैरेडिक टेम्पलेट"।

सरल उपयोग के मामले

मापदंडों की एक चर संख्या के साथ एक टेम्पलेट घोषणा निम्नानुसार है:
टेम्पलेट < टाइपनेम ... प्रकार>
वर्ग VariadicTemplate
{
};

गैर-प्रकार के मापदंडों की एक चर संख्या के साथ टेम्पलेट उसी तरह से घोषित किए जाते हैं:
टेम्पलेट < int ... स्याही>
वर्ग VariadicTemplate
{
};

यहां यह ध्यान दिया जाना चाहिए कि वर्तमान मानक के ढांचे में इसका अनुकरण करना एक बहुत ही गैर-तुच्छ कार्य है (यदि यह कहना असंभव नहीं है कि यह असंभव है)।
टेम्प्लेट कक्षाओं के अतिरिक्त, आप मापदंडों को एक चर संख्या के साथ टेम्पलेट फ़ंक्शन भी घोषित कर सकते हैं। समान विज्ञापन इस तरह दिख सकते हैं:
टेम्पलेट < टाइपनाम ... टाइप>
शून्य प्रिंटफ़ ( कास्ट चार * प्रारूप, प्रकार ... आर्ग्स);

जाहिर है, इस तरह के टेम्पलेट पैरामीटर (उन्हें "पैरामीटर पैक" या "पैरामीटर पैक" कहा जाता है) जहां भी नियमित (एकल) टेम्पलेट पैरामीटर का उपयोग नहीं किया जा सकता है। आप निम्नलिखित संदर्भों में पैरामीटर पैकेज का उपयोग कर सकते हैं:

• टेम्पलेट (बेस-स्पेसियर-लिस्ट) के बेस कक्षाओं की गणना में;
• कंस्ट्रक्टर (मेमर्स-इनिशियलाइज़र-लिस्ट) में डेटा सदस्यों की इनिशियलाइज़ेशन सूची में;
• आरंभीकरण सूचियों में (initializer-list)
• अन्य टेम्प्लेट के पैरामीटर सूचियों में (टेम्पलेट-तर्क-सूची);
• अपवादों के विनिर्देश में (डायनेमिक-अपवाद-विनिर्देश);
• विशेषता सूची (विशेषता-सूची) में;
• एक लंबो फ़ंक्शन (कैप्चर-सूची) की कैप्चर सूची में।

पैरामीटर पैकेज कहां उपयोग किया जाता है, इसके आधार पर, इस पैकेज के तत्वों की व्याख्या की जाती है। पैरामीटर पैकेज के उपयोग को स्वयं "पैकेज विस्तार" कहा जाता है, और कोड में निम्नानुसार लिखा जाता है:

Types ...

प्रकार कहाँ पैरामीटर पैकेज का नाम है।
उदाहरण के लिए, ऐसे टेम्पलेट के लिए घोषणा:
टेम्पलेट < टाइपनेम ... प्रकार>
वर्ग VariadicTemplate
{
};

मापदंडों के पैकेज के विस्तार के लिए संभावित विकल्प इस तरह दिख सकते हैं:
वर्ग VariadicTemplate: सार्वजनिक प्रकार ... // बेस कक्षाओं की सूची में विस्तार। 'सार्वजनिक प्रकार' - पैटर्न
{
// ...
// दूसरे टेम्पलेट के मापदंडों की सूची का विस्तार करना। पैटर्न - प्रकार
typedef OtherVariadicTemplate <प्रकार ...> OtherVT;
// अधिक जटिल विकल्प। पैटर्न - प्रकार *
typedef OtherVariadicTemplate <प्रकार * ...> SomeOtherVT;
// फ़ंक्शन मापदंडों की सूची का विस्तार करना। पैटर्न प्रकार है, एक args एक नया पैरामीटर सूची है:
शून्य ऑपरेटर () (प्रकार ... arg)
{
// फ़ंक्शन को कॉल करते समय तर्क सूची में विस्तार करना
foo (& args ...);
}
// निर्माणकर्ता में आरंभीकरण सूची में विस्तार:
VariadicTemplate (): प्रकार () ...
};

यहाँ "पैटर्न" शब्द, उन मापदंडों के पैकेज के नाम के आसपास कोड के एक टुकड़े को संदर्भित करता है जो संबंधित पैकेज को खोले जाने पर दोहराया जाएगा। उपरोक्त उदाहरण में, यदि आप मैन्युअल रूप से मापदंडों का विस्तार करते हैं, तो यह पता चलता है कि टेम्पलेट का तात्कालिकता क्या है:
/ * ... * / वारियडिक्टेमप्लेट < int , char , double > / * ... * /

यह निम्नानुसार खुलासा किया जाएगा:
वर्ग VariadicTemplate: सार्वजनिक int , सार्वजनिक चार , सार्वजनिक डबल
{
// ...
typedef OtherVariadicTemplate < int , char , double > OtherVT;
typedef OtherVariadicTemplate < int *, char *, double *> SomeOtherVT;
शून्य ऑपरेटर () ( int args1, char args2, डबल args3)
{
foo (& args1, & args2, & args3);
}
VariadicTemplate (): int (), char (), डबल () // स्पष्ट रूप से, यह कोड इस तरह की सूची के लिए अप्रयुक्त हो जाएगा
};

मापदंडों की एक चर संख्या के साथ टेम्पलेट्स का उपयोग करने का एक काफी सरल उदाहरण के रूप में, हम एक फ़नकार के कार्यान्वयन का उपयोग कर सकते हैं। यह कार्यान्वयन इस तरह दिखता है:
# < iostream > शामिल करें

// टेम्पलेट के एक सामान्य संस्करण को घोषित करें जो सूचक को फ़ंक्शन में संग्रहीत करता है। इस मामले में, सभी संभावित प्रकार जो टेम्पलेट में आ सकते हैं
// तात्कालिकता प्रक्रिया में, हम मापदंडों के एक पैकेज में पैक करते हैं
टेम्पलेट < टाइपनेम ... आर्ग्स> संरचना फंक्शनलइम्प्ल;

// सरल कार्यों के लिए एक पॉइंटर के लिए टेम्पलेट को विशेष करें। उसी समय, हम इंगित करते हैं कि पैरामीटर पैकेज में रिटर्न प्रकार शामिल है
// मान (R) और तर्क (Args)। इन दो मापदंडों (सरल और बैच) से, हम तब फ़ंक्शन हस्ताक्षर बनाते हैं
टेम्पलेट < टाइपनेम R, टाइपनेम ... Args>
संरचना फंक्शनलइम्प्ल <R (Args ...)>
{
// हम वांछित हस्ताक्षर के साथ फ़ंक्शन के सूचक के प्रकार का वर्णन करते हैं। इस मामले में, मापदंडों का पैकेज खोलें
टाइपडिफ आर (* एफटी) (आर्ग्स ...);

फ़नियोरिंप्ल (एफटी fn): m_fn (fn) {;}

// एक फ़ंक्शन कॉल ऑपरेटर की घोषणा करें ताकि यह तर्क के रूप में बिल्कुल कई मापदंडों को ले जाए
// संग्रहित फ़ंक्शन प्रकार।
आर ऑपरेटर () (Args ... args)
{
// हम इसे प्राप्त होने वाले सभी तर्कों को फ़ंक्शन कहते हैं
वापसी m_fn (args ...);
}

एफटी m_fn;
};

// एक सामान्य प्रेषण पैटर्न घोषित करें
साँचा < टाइपनाम एफटी>
संरचना फ़ंक्टर: सार्वजनिक फ़ंक्शनलइमप्लेट <FT>
{
फ़ंक्टर (): फ़नएक्टरइम्प्ल <FT> ( NULL ) {;}
फ़ंक्टर (एफटी fn): फ़नएक्टरइम्प्ल <FT> (fn) {;};
};

int plus_fn ( int a, int b) { रिटर्न ए + बी ;;
int minus_fn ( int a, int b) { वापसी a - b;}
int increment ( इंट & ए) { रिटर्न ए ++ ;;

int main ()
{
फ़ंक्टर < int ( int , int )> प्लस (plus_fn);
फ़नकार < int ( इंट , इंट )> माइनस (माइनस_फ़्न);
फ़ंक्टर < int ( इंट &)> इंक (वेतन वृद्धि);

std :: cout << plus ( 10 , 20 ) << "" << माइनस ( 10 , 20 ) << std :: endl ;

int a = 100 ;
std :: cout << inc (a) << "" ;
std :: cout << a << std :: endl ;
}

इस कोड को निष्पादित करने का परिणाम काफी अपेक्षित है:

30 -10
100 101

और कोड सरल और सीधा है। तुलना के लिए, आप फ़ाइलों को बढ़ावा देने के कार्यान्वयन के साथ देख सकते हैं :: फ़ंक्शन।
ऊपर वर्णित टेम्प्लेट सदस्य कार्यों के लिए संकेत के लिए विशेषज्ञ के लिए आसान हैं:
// हम पैरामीटर के एक ही पैकेज को समेटते हुए सदस्य फ़ंक्शन को पॉइंटर के लिए फ़ंक्शन कंटेनर की विशेषज्ञता की घोषणा करते हैं
टेम्पलेट < टाइपनेम टी, टाइपनेम आर, टाइपनेम ... आर्ग्स>
संरचना फंक्शनलइम्प्ल <R (T :: *) (आर्ग्स ...)>
{
टाइपडिफ आर (टी :: * एफटी) (आर्ग्स ...);
टाइपडिफ टी होस्ट टाइप;

FunctorImpl (FT fn = NULL , T * obj = NULL ): m_fn (fn), m_obj (obj) {;};

// हम फ़ंक्शन कॉल ऑपरेटर के दो वेरिएंट घोषित करते हैं - उस स्थिति के लिए जब फ़ंक्टर को "बंद" के रूप में उपयोग किया जाता है, और जब ऑब्जेक्ट,
// जिसके लिए विधि कहा जाता है, पहले तर्क के रूप में पारित किया गया
आर ऑपरेटर () (Args ... args)
{
(m_obj -> * m_fn) (args ...);
}

आर ऑपरेटर () (टी * ओब्ज, आर्ग्स ... आर्ग्स)
{
(obj -> * m_fn) (args ...);
}

एफटी m_fn;
टी * m_obj;
};


// एक क्लोजर क्लास को डिक्लेयर करता है जो कंस्ट्रक्टर में एक ऑब्जेक्ट लेता है जिसके लिए मेंबर फंक्शन को बुलाया जाएगा। यह बहुत सरल दिखता है।
साँचा < टाइपनाम एफटी>
संरचना बंद: सार्वजनिक FunctorImpl <FT>
{
typedef टाइपनेम फनटेरइम्प्ल <FT> :: HostType HostType;
बंद (HostType * obj, FT fn): फनकारइम्प्ल <FT> (fn, obj {};
};

// का उपयोग करें
कक्षा ए
{
जनता :
A ( int base = 0 ): m_base (बेस) {;}
int foo ( इंट ) a {{a + m_base ;;

निजी :
int m_base
};

ए बी 1 ( 10 ), बी 2;
बंद करना < int (A :: *) ( int )> a_foo (& b1, & A :: foo);
// आप देख सकते हैं कि समग्र फ़नकार कार्यान्वयन पॉइंटर्स से सदस्य कार्यों के लिए भी सही ढंग से काम करता है
फ़नकार < int (A :: *) ( int )> b_foo (& A :: foo);

std :: cout << a_foo ( 20 ) << "" << b_foo (& b2, 20 ) << "" << b_foo (& b1, 20 ) << std :: endl ;

उपरोक्त उदाहरण काफी सरल है और स्पष्ट रूप से मापदंडों की एक मुख्य संख्या के साथ टेम्पलेट्स की मुख्य विशेषताओं को दर्शाता है। इसका विश्लेषण करके, आप मापदंडों की एक चर संख्या के साथ टेम्पलेट का उपयोग करने के लिए निम्न सामान्य पैटर्न निर्धारित कर सकते हैं:
1. सबसे सामान्य टेम्पलेट घोषित किया गया है, जिसमें से अंतिम पैरामीटर को मापदंडों के पैकेज के रूप में वर्णित किया गया है। उदाहरण में, यह
टेम्पलेट < टाइपनेम ... आर्ग्स> संरचना फंक्शनलइम्प्ल;

2. इस टेम्पलेट की आंशिक विशेषज्ञता निर्धारित की जाती है जो पैरामीटर पैकेज के एक या दूसरे भाग को निर्दिष्ट करती है। उपरोक्त उदाहरण में, यह परिभाषा
टेम्पलेट < टाइपनेम R, टाइपनेम ... Args>
संरचना फंक्शनलइम्प्ल <R (Args ...)>

3. कुछ मामलों में, जब विशेषज्ञता होती है, तो आपको यह विचार करना पड़ सकता है कि पैरामीटर पैकेज खाली हो सकता है। यह, आम तौर पर बोल रहा है, अनुमेय है।
यह याद रखना चाहिए कि टेम्पलेट कक्षाओं के मामले में, पैकेज में पैक किए गए मापदंडों को पैकेज के प्रमुख से शुरू किया जा सकता है। पैकेज की पूंछ से शुरू होने वाले मापदंडों को निर्दिष्ट करना असंभव है (इस तथ्य के कारण कि पैरामीटर पैकेज केवल टेम्पलेट मापदंडों की सूची को बंद कर सकता है)। टेम्प्लेट फ़ंक्शंस के संबंध में ऐसी कोई सीमा नहीं है।

अधिक जटिल मामले

जैसा कि ऊपर उल्लेख किया गया है, पैरामीटर पैकेज में न केवल प्रकार, बल्कि गैर-प्रकार भी हो सकते हैं। उदाहरण के लिए:
// एक टेम्पलेट की घोषणा करें जो पूर्णांक की एक चर संख्या लेता है
टेम्पलेट < int ... नम्स>
संरचना सुन्न
{
// एक स्थिर सरणी घोषित करें जिसका आकार वास्तव में पारित तर्कों की संख्या के बराबर है
स्थिर int m_nums [ sizeof ... (Nums)];
// और यह भी एक घोषणा है कि सरणी में तत्वों की संख्या संग्रहीत करता है
enum {nums_count = sizeof ... (नम्स)};
};

// स्टेटिक ऐरे को इनिशियलाइज़ करें
टेम्पलेट < int ... नम्स>
int NumsPack <Nums ...> :: m_nums [] = {Nums ...};
सत्यापन कोड:
typedef NumsPack < 10 , 20 , 30 , 40 , 50 > Nums_5;
std :: cout << Nums_5 :: nums_count << std :: endl ;
for ( int n = 0 ; n <nums_5 :: nums_count; ++ n)
std :: cout << Nums_5 :: m_nums [n] << "" ;
std :: cout << std :: endl ;

कंसोल को प्रिंट होने की उम्मीद है
5
१० २० ३० ४० ५०

इस उदाहरण में दिखाए गए आकार का आकार (नम्स) निर्माण का उपयोग पैकेज में मापदंडों की संख्या प्राप्त करने के लिए किया जाता है। इसमें, Nums पैरामीटर पैकेज का नाम है। दुर्भाग्य से, मापदंडों की एक चर संख्या के साथ टेम्पलेट्स का डिजाइन ऐसा है कि यह एकमात्र ऐसी चीज है जो मापदंडों के पैकेज (इसके प्रत्यक्ष प्रकटीकरण के अलावा) के साथ किया जा सकता है। उदाहरण के लिए, या नए मानक प्रोजेक्ट के ढांचे के भीतर किसी भी अधिक जटिल जोड़तोड़ को निष्पादित करने के लिए पैकेज से पैरामीटर प्राप्त करना असंभव है।

पैकेज खोलते समय, आप अधिक जटिल पैटर्न लागू कर सकते हैं। उदाहरण के लिए, उपरोक्त कोड में, आप निम्नलिखित प्रतिस्थापन कर सकते हैं:
टेम्पलेट < int ... नम्स>
int NumsPack <Nums ...> :: m_nums [] = {Nums * 10 ...};

जिससे एक अलग अनुक्रम प्रदर्शित होगा:
100 200 300 400 500

सामान्य तौर पर, विशेष प्रकार का पैटर्न उस संदर्भ पर निर्भर करता है जिसमें यह प्रकट होता है। इसके अलावा, पैटर्न में एक से अधिक मापदंडों के संदर्भ हो सकते हैं। इस स्थिति में, पैटर्न में उल्लिखित सभी संकुल समकालिक रूप से खोले जाएंगे, और इसलिए उनमें वास्तविक मापदंडों की संख्या का मिलान होना चाहिए।

ऐसी स्थिति उत्पन्न हो सकती है जब मूल्यों के ट्यूपल्स को निर्धारित करना आवश्यक हो। मान लीजिए कि एक सार्वभौमिक फ़न-कंपोज़र को व्यवस्थित करना आवश्यक है जिसका कार्य किसी फ़ंक्शन के लिए दिए गए फ़ंक्शन के निष्पादन के परिणामों को कुछ फ़ंक्शन के लिए स्थानांतरित करना है। कार्यों का एक निश्चित सेट होने दें:
डबल fn1 ( डबल ए)
{
वापसी एक * 2 ;
}

int fn2 ( इंट )
{
वापसी एक * 3 ;
}

int fn3 ( int )
{
वापसी एक * 4 ;
}

और दो ऑपरेशन:
int test_opr ( इंट ए, इंट बी)
{
वापसी एक + बी;
}

int test_opr3 ( इंट ए, इंट बी, इंट सी)
{
वापसी एक + बी * सी;
}

यह एक सार्वभौमिक फ़नकार लिखने के लिए आवश्यक है, फ़ंक्शन कॉल ऑपरेशन का अनुप्रयोग जिससे इस तरह के कोड का निष्पादन होगा:
test_opr(f1(x), f2(x));
या
test_opr3(f1(x), f2(x), f3(x));

फ़नकार को एक ऑपरेशन और इनपुट के रूप में कार्यों की एक सूची को स्वीकार करना चाहिए, जिसके परिणाम इस ऑपरेशन के तर्क के रूप में पारित होने चाहिए। इस तरह के एक फन्नेकार की परिभाषा के लिए रूपरेखा इस तरह दिख सकती है:
टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
क्लास कंपोजिटर
{
जनता :
रचनाकार (सेशन op, F ... fs);
};

पहली समस्या जिसे हल करने की आवश्यकता है वह यह है कि स्थानांतरित कार्यों को कैसे बचाया जाए। ऐसा करने के लिए, आप उन वर्गों से कई वंशानुक्रम लागू कर सकते हैं जो किसी दिए गए प्रकार के डेटा को सीधे संग्रहीत करते हैं:
टेम्पलेट < टाइपनेम टी>
स्ट्रक्चर डेटाहार्ड
{
टी m_data;
};

टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
श्रेणी संगीतकार: सार्वजनिक डेटा फ़ोल्डर <F> ...
{
// ...
};

लेकिन यहां पहली समस्या उत्पन्न होती है - यदि हस्तांतरित कार्यों की सूची में कई कार्य हैं जिनके प्रकार मेल खाते हैं, तो कोड संकलित नहीं करेगा, क्योंकि आधार वर्गों की सूची में एक ही वर्ग मौजूद होगा। इस अस्पष्टता को खत्म करने के लिए, पैकेज के प्रकारों को अनुक्रमित किया जा सकता है। इसके लिए, सहायक प्रकार "पूर्णांक के टपल" का उपयोग किया जाएगा, जिसमें पैरामीटर एन के रूप में निर्दिष्ट 0 से एक तक की संख्याएं हैं:
// टपल की कक्षा को ही परिभाषित करें
टेम्पलेट < int ... Idxs> स्ट्रक्चर इंडेक्सटुपल
{
};

// टपल उत्पन्न करने के लिए उपयोग किए जाने वाले टेम्पलेट के सामान्य दृश्य को परिभाषित करें
टेम्पलेट < int Num, typename Tp = IndexesTuple <>>
संरचना IndexTupleBuilder;

// एक विशेषज्ञता को परिभाषित करें जो पूर्णांक मापदंडों के एक पैकेट के रूप में संख्याओं का एक क्रम उत्पन्न करता है।
// इसके लिए, टपल के प्रकार का उपयोग टेम्पलेट घोषणा में दूसरे पैरामीटर के रूप में नहीं किया जाता है, लेकिन पहले से उत्पन्न एक
// पैकेज। अंतिम पैकेज प्राप्त करने के लिए, हमें पैकेज में एक नया नंबर जोड़कर, उत्पन्न टेम्पलेट से विरासत में मिला है
टेम्पलेट < int Num, int ... Idxs>
संरचना IndexTupleBuilder <Num, IndexesTuple <Idxs ... >>: IndexTupleBuilder <Num - 1 , IndexesTuple <Idxs ..., sizeof ... (Idxs) >>
{
};

// पुनरावर्तन विशेषज्ञता की समाप्ति। संख्या के वांछित सेट के साथ एक ट्यूल को परिभाषित करने वाले परिणामी टाइपफेड शामिल हैं
टेम्पलेट < int ... Idxs>
स्ट्रक्चर इंडेक्सटुपलेबल < 0 , इंडेक्ससटुपल <आईडीएक्स ... >>
{
typedef IndexesTuple <Idxs ...> अनुक्रमणिका;
};

परिणामस्वरूप, आप इस टेम्पलेट का उपयोग इस प्रकार कर सकते हैं:
typedef typename IndexTupleBuilder < 6 > अनुक्रमित;
इस स्थिति में, IndexesTuple <0, 1, 2, 3, 4, 5> के बराबर होंगे

संगीतकार के कार्यान्वयन में उपयोग किए जाने वाले इस वर्ग के लिए, एक मध्यवर्ती आधार वर्ग शुरू करना आवश्यक है, जो डेटा वर्गों से विरासत में मिलेगा। इसके अलावा, प्रत्येक डेटा वर्ग को अपने स्वयं के अनूठे सूचकांक के साथ प्रदान किया जाएगा:
टेम्पलेट < int idx, टाइपनैम टी>
स्ट्रक्चर डेटाहार्ड
{
DataHolder (टी कास्ट और डेटा): m_data (डेटा) {;}

टी m_data;
};

// सबसे पहले, एक जेनेरिक टेम्प्लेट घोषित करें जो एक इनपुट के रूप में टपल को स्वीकार करता है। हमें इस रूप में सीधे विज्ञापन की आवश्यकता नहीं है, लेकिन
// यह बाद के विशेषज्ञता के लिए आवश्यक है।
टेम्पलेट < टाइपनामे IdxsTuple, typename ... F> संरचनात्मक संगीतकार;

// हम एक सामान्य टेम्पलेट के विशेषज्ञ हैं, एक ट्यूपल से मापदंडों के पैकेज को निकालते हैं।
// इस मामले में, पैरामीटर को दो पैकेजों के साथ घोषित किया जाता है। इसकी अनुमति है क्योंकि पैकेटों को विशिष्ट रूप से विभाजित किया जा सकता है।
// इनहेरिट करते समय, एक पैटर्न का उपयोग किया जाता है जिसमें दो पैरामीटर पैकेज एक ही बार में उल्लेख किए जाते हैं। यह आपको विशिष्ट रूप से मिलान करने की अनुमति देता है
// पूर्णांक टपल के तत्व और फ़ंक्शन प्रकारों की एक सूची।
टेम्पलेट < int ... Idxs, टाइपनेम ... F>
संरचना संगीतकार <IndexesTuple <Idxs ...>, F ...>: सार्वजनिक DataHolder <Idxs, F> ...
{
// और यहां पैटर्न में एक साथ तीन पैकेज हैं - सूचकांकों के साथ एक पैकेज, फ़ंक्शन प्रकारों का एक पैकेज और तर्कों का एक पैकेज। यह सब सूची में पता चला है।
// कंस्ट्रक्टर आरंभीकरण।
कम्पोज़रबेस (एफ ... एफएस): डेटाहार्ड <इडिक्स, एफ> (एफएस) ...}};
};

// वास्तविक डेटा वाले ऊपर वर्णित टेम्पलेट से संगीतकार के टेम्पलेट को इनहेरिट करें
टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
संरचना संगीतकार: सार्वजनिक संगीतकार < टाइपनेम सूचकांक टाइपलेबल < आकार ... (एफ)> :: सूचकांक, एफ ...>
{
ऑप m_op;
जनता :
// निर्माणकर्ता की घोषणा करें
संगीतकार (op op, F const & ... fs): m_op (op), बेस (fs ...) {};
};

संगीतकार के कार्यान्वयन को पूरा करने के लिए, फ़ंक्शन कॉल ऑपरेटर को परिभाषित करना आवश्यक है। इसकी परिभाषा की सुविधा के लिए, वापसी मूल्य का प्रकार पहले निर्धारित किया जाता है:
टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
संरचना संगीतकार: / * ... * /
{
ऑप m_op;
जनता :
typedef घोषणापत्र (m_op ((* (F *) NULL ) ( 0 ) ...) result_t;
// ...
};

वापसी मान के प्रकार को निर्धारित करने के लिए, C ++ में एक और निर्माण का उपयोग किया जाता है - डिक्वेस्ट। इसके आवेदन का परिणाम (इस मामले में) फ़ंक्शन द्वारा लौटाए गए मूल्य का प्रकार है। डिजाइन थोड़ा अजीब लग रहा है। अर्थ में, यह के बराबर है
घोषणापत्र (op (fs (0) ...))
लेकिन चूंकि क्लास के दायरे में पैकेज एफएस को परिभाषित नहीं किया गया है, ऑपरेटर को संदर्भ में परिवर्तित NULL फ़ंक्शन प्रकार पर लागू किया जाता है।

अब फ़ंक्शन कॉल ऑपरेटर को निर्धारित करने के लिए सब कुछ तैयार है। चूंकि रचना में शामिल फ़ंक्शंस को स्टोर करने वाली कक्षाएं एक पूर्णांक इंडेक्स को टेम्प्लेट मापदंडों में से एक के रूप में लेती हैं, इसलिए यह ऑपरेटर एक हेल्पर फ़ंक्शन के माध्यम से कार्यान्वित किया जाता है जिसमें एक ही पूर्णांक टपल पारित किया जाता है:
टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
संरचना संगीतकार: / * ... * /
{
ऑप m_op;
जनता :
ret_type ऑपरेटर () ( int x) const
{
MakeCall (x, अनुक्रमित ());
}
निजी :
// यह उसी ट्रिक का उपयोग करता है जैसे कि कॉम्पोज़रबेस क्लास की परिभाषा में। टपल का प्रकार "पकड़ने" के लिए उपयोग किया जाता है
// पूर्णांक सूचकांकों का पैकेज
टेम्पलेट < int ... Idxs>
ret_type MakeCall ( int x, IndexesTuple <Idxs ...> const &) const
{
वापसी m_op (DataHolder <Idxs, F> :: m_data (x) ...);
}
};
यह केवल एक फ़ंक्शन को परिभाषित करने के लिए रहता है जो इस वर्ग के उदाहरणों के निर्माण की सुविधा देता है:
टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
संगीतकार <Op, F ...> रचना (Op सेशन, F ... fs)
{
वापसी संगीतकार <Op, F ...> (op, fs ...);
}

और संगीतकार तैयार है। इसके उपयोग के कुछ उदाहरण:
ऑटो f = मेकओप (test_opr, fn1, fn2);
ऑटो ff = MakeOp (test_opr3, fn1, fn2, fn3);
ऑटो ff1 = मेकओप (test_opr3, fn1, fn2, [=] ( int x) { वापसी f (x) * 5 ;}}; // यहां कंपोजर का अंतिम पैरामीटर लंबो फंक्शन है।

संगीतकार टेम्पलेट क्लास की पूरी परिभाषा इस प्रकार है:
टेम्पलेट < int ... Idxs, टाइपनेम ... F>
संरचना संगीतकार <IndexesTuple <Idxs ...>, F ...>: सार्वजनिक DataHolder <Idxs, F> ...
{
कम्पोज़रबेस (एफ ... एफएस): डेटाहार्ड <इडिक्स, एफ> (एफएस) ...}};
};


टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
संरचना संगीतकार: सार्वजनिक संगीतकार < टाइपनेम सूचकांक टाइपलेबल < आकार ... (एफ)> :: सूचकांक, एफ ...>
{
ऑप m_op;
जनता :
typedef ComposerBase < typename IndexTupleBuilder < sizeof ... (F)> :: अनुक्रमित, F ...> आधार;
typedef घोषणापत्र (m_op ((* (F *) NULL ) ( 0 ) ...) result_t;

संगीतकार (op op, F const & ... fs): m_op (op), बेस (fs ...) {};

result_t ऑपरेटर () ( int x) कांस्टेबल
{
MakeCall (x, टाइपनामेक्स IndexTupleBuilder < sizeof ... (F)> :: अनुक्रमित ());
}
निजी :

टेम्पलेट < int ... Idxs>
result_t MakeCall ( int x, IndexesTuple <Idxs ...> const &) const
{
वापसी m_op (DataHolder <Idxs, F> :: m_data (x) ...);
}
};

साथ ही इस वर्ग को STL (std :: tuple) से ट्यूपल्स के आधार पर लागू किया जा सकता है। इस स्थिति में, DataHolder वर्ग आवश्यक नहीं होगा। इस मामले में, संगीतकार का कार्यान्वयन निम्नानुसार होगा:
टेम्पलेट < टाइपनेम ओप, टाइपनेम ... एफ>
वर्ग TupleComposer
{
ऑप m_op;
std :: tuple <F ...> m_fs;
जनता :
typedef घोषणापत्र (m_op ((* (F *) NULL ) ( 0 ) ...) result_t;

TupleComposer (Op op, F ... fs): m_op (op), m_fs (f ... ... {}};

result_t ऑपरेटर () ( int x) कांस्टेबल
{
MakeCall (x, टाइपनामेक्स IndexTupleBuilder < sizeof ... (F)> :: अनुक्रमित ());
}
निजी :

टेम्पलेट < int ... Idxs>
result_t MakeCall ( int x, IndexesTuple <Idxs ...> const &) const
{
वापसी m_op ( std :: get <Idxs> (m_fs)
(x) ...);
}
};

यह विकल्प थोड़ा सरल दिखता है।

कुछ और टोटके

"इनिशियलाइज़ेशन लिस्ट" के संदर्भ में मापदंडों के पैकेज का विस्तार करना प्रोग्रामर को कार्रवाई की एक बड़ी स्वतंत्रता प्रदान करता है, क्योंकि इस मामले में एक पूर्ण अभिव्यक्ति एक पैटर्न हो सकती है। उदाहरण के लिए, तर्कों के रूप में पारित संख्याओं की राशि की गणना निम्नानुसार की जा सकती है:
टेम्पलेट < टाइपनेम ... टी>
शून्य उपेक्षा (T ...) {;;

टेम्पलेट < टाइपनेम ... टी>
int कैल्कसम (टी ... अंक)
{
int ret_val = 0 ;
उपेक्षा (ret_val + = nums ...);
वापसी ret_val;
}

जाँच करें कि क्या संचरित संख्याओं में सकारात्मक संख्याएँ हैं:
टेम्पलेट < टाइपनेम ... टी>
बूल हसपोजिटिव्स (टी ... अंक)
{
बूल ret_val = true ;
अनदेखा करना (ret_val = ret_val && nums> = 0 ...);
वापसी ret_val;
}

लेकिन इस पद्धति का उपयोग करते समय, किसी को यह नहीं भूलना चाहिए कि तर्क की गणना का क्रम, कड़ाई से बोलना, परिभाषित नहीं है, और संचालन किस क्रम में किया जाएगा यह अग्रिम में नहीं कहा जा सकता है।

संक्षेप में, हम कह सकते हैं कि मापदंडों की एक चर संख्या के साथ टेम्पलेट एक बहुत शक्तिशाली उपकरण है जो C ++ में दिखाई देता है। वे वर्तमान में मौजूद (या समान व्यवहार के अन्य अनुकरण) प्रकार की सूचियों की स्पष्ट कमियों से रहित हैं, वे कोड की अपेक्षाकृत कम मात्रा की जगह जटिल अवधारणाओं को व्यक्त करने की अनुमति देते हैं। इस आलेख में प्रस्तुत किए गए निर्माणों की तुलना वर्तमान मानक के ढांचे के भीतर किए गए समान निर्माणों से की जा सकती है (इसके लिए आप स्रोत फ़ाइलों को बढ़ावा देने के लिए देख सकते हैं :: बाँध, बढ़ावा :: कार्य, बढ़ावा :: टपल)। लेकिन वे कुछ कमियों के बिना नहीं हैं। मुख्य एक सीमित संख्या में संदर्भ है जिसमें पैरामीटर पैकेज का विस्तार किया जा सकता है। विशेष रूप से, लैंबडा फ़ंक्शंस के अंदर पैकेज का विस्तार नहीं किया जा सकता है (इसी अनुरोध को मानकीकरण समिति को भेजा जाता है, लेकिन क्या यह अनुरोध संतुष्ट होगा?), पैकेज को अभिव्यक्ति में नहीं बढ़ाया जा सकता है ताकि इसे लिखा जा सके, उदाहरण के लिए, जैसे:
ऑटो परिणाम = आर्ग + ...;
पैकेज तत्वों को अनुक्रमणिका द्वारा एक्सेस नहीं किया जा सकता है।