अपरिवर्तित पुनरावृत्तियों

यह मानक एसटीएल टेम्पलेट लाइब्रेरी के बारे में है। मौजूदा प्रकार के पुनरावृत्तियों और उनके वर्गीकरण पर विचार किया जाएगा, और पुनरावृत्तियों पर कई नए आवरण प्रस्तावित किए जाएंगे। जो कुछ मामलों में लंबोदर अभिव्यक्तियों से बचने की अनुमति देगा, जो कि C ++ 11 से पहले थे।

उद्घाटन टिप्पणी

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

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

एसटीएल में Iterators के प्रकार

एक विशेष कंटेनर के डेटा तक पहुँचने वाले पुनरावृत्तियों के अलावा, STL लाइब्रेरी में कई और पुनरावृत्तियाँ हैं:
1. back_insert_iterator और front_insert_iterator
2. सम्मिलित_लेखक
3. istream_iterator और ostream_iterator

प्रकार के I_ators back_insert_iterator और front_insert_iterator, जब सामग्री को संशोधित करते हैं, तो push_back () या push_front () विधि का उपयोग करके एक तत्व डालें। ये पुनरावृत्त बस कंटेनर के पिछले / अगले तत्व पर जाने के संचालन को अनदेखा करते हैं।

जब डेटा को सम्मिलित किया जाता है, तो Insert_iterator पुनरावृत्ति, डेटा सम्मिलित करता है। एक कंटेनर और एक पुनरावृत्ति निर्माणकर्ता को उस स्थान पर पारित किया जाता है जहां डेटा डाला जाना चाहिए।

Istream_iterator और ostream_iterator पुनरावृत्तियाँ स्ट्रीम से डेटा पढ़ते हैं और स्ट्रीम में डेटा लिखते हैं। इन पुनरावृत्तियों के डिजाइनरों को एक इनपुट या आउटपुट स्ट्रीम पास करने की आवश्यकता होती है।

इटरेटर वर्गीकरण

पुनरावृत्तियों के मौजूदा वर्गीकरण में पुनरावृत्तियों की 5 श्रेणियां हैं:
1. इनपुट इटरेटर
2. आउटपुट इटरेटर
3. फॉरवर्ड इटरेटर
4. द्विदिश यात्रा करनेवाला
5. रैंडम एक्सेस इटरेटर

विभिन्न श्रेणियों से संबंधित Iterators मान्य परिचालनों का एक अलग सेट है। संचालन को निम्नानुसार वर्गीकृत किया गया है:

इटरेटर श्रेणी				सुविधा	मान्य अभिव्यक्ति
सभी श्रेणियां				इसे इमेज में कॉपी और क्रिएट किया जा सकता है	एक्स बी (ए); बी = ए;
				एक से बढ़ सकते हैं	++ ए ए ++ * ए ++
रैंडम एक्सेस	द्विदिश	आगे	इनपुट	समानता / असमानता की तुलना का समर्थन करता है	a == बी ए = बी
				यह केवल मूल्य पाने के लिए एक प्रतिद्वंद्विता के रूप में dereferenced जा सकता है	* ए a-> मी
			उत्पादन	असाइनमेंट साइन के बाईं ओर उपयोग के लिए एक अंतराल के रूप में उल्लिखित किया जा सकता है	* ए = टी * ए ++ = टी
				इसे दोहराया और दोहराया ट्रैवर्सल के लिए उपयोग किया जा सकता है।	एक्स (बी); ++ a == ++ b
				एक करके कम किया जा सकता है	--a एक-- * ए -
				अंकगणितीय संचालन + और - का समर्थन करता है	ए + एन एन + ए ए - एन ए - बी
				पुनरावृत्तियों के बीच तुलना (<,>, <= और> =) का समर्थन करता है	a <b ए> बी अ <= ख ए> = बी
				संचालन में वृद्धि का समर्थन करता है + = और कमी - =	ए + = एन a - = n
				अनुक्रमणिका ([]) द्वारा डेरेफेरिंग का समर्थन करता है	[[एन]

Iterator डेकोरेटर विकास

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

एक अच्छे व्यक्ति के साथ परिणामस्वरूप संरचना की एक छोटी चर्चा के बाद, एक नई संरचना विकसित की गई थी। टेम्प्लेट और अधिक संक्षिप्त के साथ संतृप्त नहीं। यह तय किया गया था कि पुनरावृत्त श्रेणी के सभी श्रेणियों के सभी तरीकों को लागू करने का निर्णय लिया गया है। निम्नलिखित C ++ भाषा गुण का उपयोग किया गया था: केवल टेम्पलेट वर्ग के उन तरीकों को संकलित किया जाता है जिन्हें वास्तव में कहा जाता है।

इस प्रकार, यदि आपको इनपुट श्रेणी के एक पुनरावृत्त को लपेटने की आवश्यकता है, तो केवल उन विधियों को जो इनपुट श्रेणी से संबंधित हैं, संकलित किए जाएंगे और कॉल किए जाएंगे। यदि आप ऐसी विधि को कॉल करने का प्रयास करते हैं जो इस श्रेणी से संबंधित नहीं है, तो संकलन त्रुटि उत्पन्न होगी। और यह वही है जिसके लिए हम प्रयास कर रहे थे।

बिट इटरेटर

एक बिट पुनरावृत्ति आपको बिट द्वारा कंटेनर तत्वों को बायपास करने की अनुमति देता है। बिटर्स को पढ़ने और लिखने के लिए एक इटैलर का उपयोग किया जा सकता है। पुनरावृत्त पैरामीटर है:
1. कंटेनर तत्वों के बाइट्स को बायपास करने के लिए किस क्रम में
2. बाइट्स में बिट्स को बायपास करने के लिए किस क्रम में

उपयोग उदाहरण:

{ // 00001010 00001011 00001010 00001011 // * * * ** * * * ** char input[] = "\x0A\x0B\x0A\x0B"; char * input_ptr = input; int a = std::count(bit_walker(input_ptr), bit_walker(input_ptr+4), 1); EXPECT_EQ(2 + 3 + 2 + 3, a); } 

फील्ड इट्रेटर

एक फ़ील्ड इटरेटर एक ऐसा इटरेटर है, जो डीरिफ़र्ड होने पर, स्ट्रक्चर में से किसी एक फ़ील्ड का मान लौटाता है। किसी एक फ़ील्ड के मान से ऑब्जेक्ट ढूंढने के लिए यह बहुत उपयोगी हो सकता है। उपयोग उदाहरण:

 { // What to find: [200] "puper" // // {100,"hello"} // {200,"super"} => {200,"super"} // {300,"puper"} => {300,"puper"} struct ABC { int value; std::string str; }; ABC input[] = { {100,"hello"}, {200,"super"}, {300,"puper"} }; ABC * input_ptr = input; int a = std::find(field_walker(input_ptr, fieldof(ABC,value)), field_walker(input_ptr+3, fieldof(ABC,value)), 200) - input_ptr; int b = std::find(field_walker(input_ptr, fieldof(ABC,str)), field_walker(input_ptr+3, fieldof(ABC,str)), "puper") - input_ptr; EXPECT_EQ(1, a); EXPECT_EQ(2, b); } 

मैक्रो फील्डऑफ (क्लास, फील्ड) इस प्रकार है:

 #define fieldof(Object,field) (&(((Object*)NULL)->field)) 

युपीडी
जैसा कि उपयोगकर्ता महापौर ने उल्लेख किया है , आप एक पॉइंटर के साथ एक वर्ग क्षेत्र के लिए प्राप्त कर सकते हैं:

 &Object::field 

सॉर्ट Iterator

एक सॉर्टिंग पुनरावृत्ति एक पुनरावृत्ति है जो सॉर्ट क्रम में तत्वों का पता लगाता है। कंटेनर तत्वों को पुनरावृत्ति ट्रैवर्सल के दौरान संशोधित नहीं किया गया है। इस मामले में लाभ यह है कि छंटाई के लिए समय बर्बाद नहीं होता है (छंटाई के लिए आवंटित समय का कोई विशिष्ट खंड नहीं है)।

जब इट्रेटर अगले तत्व पर जाता है, तो यह शेष लोगों में सबसे छोटे तत्व को खोजता है जो पिछले वाले से अधिक या बराबर होते हैं। इस प्रकार, एल्गोरिथ्म की जटिलता ओ (एन ² ) है, लेकिन छंटाई के लिए कोई विशेष समय आवंटित नहीं किया गया है। डेटा तक पहुंचने की प्रक्रिया में छंटनी की जाती है। Iterators कदम से कदम संभाल रहे हैं - छँटाई भी stepwise है।

इट्रेटर को सॉर्ट क्रम द्वारा पैरामीटरित किया जाता है। डिफ़ॉल्ट: आरोही क्रमबद्ध करें।

उपयोग उदाहरण:

 { // A:{ 5,2,1,2,2 } => A:{ 5,2,1,2,2 } // B:{ 0,0,0,0,0 } => B:{ 5,2,2,2,1 } int input[5] = { 5,2,1,2,2 }; int output[5] = { 0,0,0,0,0 }; int * input_ptr = (int *)input; int * output_ptr = (int *)output; std::copy(sorter<Descending>(input_ptr,input_ptr+5), sorter<Descending>(input_ptr+5), output_ptr); // Expect input EXPECT_EQ(5, input[0]); EXPECT_EQ(2, input[1]); EXPECT_EQ(1, input[2]); EXPECT_EQ(2, input[3]); EXPECT_EQ(2, input[4]); // Expect output EXPECT_EQ(5, output[0]); EXPECT_EQ(2, output[1]); EXPECT_EQ(2, output[2]); EXPECT_EQ(2, output[3]); EXPECT_EQ(1, output[4]); } 

टिप्पणी:

1. पुनरावृत्तियों की श्रेणियों की तालिका यहाँ से उधार ली गई है (इसमें कुछ कीड़े पाए गए - स्रोत साइट त्रुटियों के बारे में सूचित है): http://www.cplusplus.com/reference/std/iterator/
2. जैसा कि आप में से कई ने देखा होगा, कोड उदाहरण Google C ++ टेस्टिंग फ्रेमवर्क के लिए परीक्षण हैं , जिसका अर्थ है कि कोड रिपॉजिटरी में निहित है और इसके लिए परीक्षण हैं। यदि आपको कोई बग मिलता है - एक परीक्षण लिखें जो इसे प्रकट करता है)) यह वह जगह है जहां पूरा कोड निहित है: http://code.google.com/p/stliw/ कोड पर टिप्पणियाँ पंजीकरण के बिना छोड़ दी जा सकती हैं - स्वागत है।

पुनश्च
यह लेख मेरे द्वारा छह महीने पहले लिखा गया था। आज मैंने इसे लगभग पूर्ण स्थिति में पाया और इसे प्रकाशित किया। यह कहना मुश्किल है कि उसने मेरे ड्राफ्ट में छह महीने क्यों लगाए। हो सकता है कि मैं किसी भी मामले में कुछ खत्म या रीमेक करना चाहता था - मैं अब या कभी नहीं प्रकाशित करता हूं।