इटरेटर पैटर्न: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
 
(4 intermediate revisions by 3 users not shown)
Line 1: Line 1:
[[ ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग |ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] में, '''[[इटरेटर]] पैटर्न''' डिज़ाइन पैटर्न (कंप्यूटर साइंस) है जिसमें इटरेटर का उपयोग संग्रह (अमूर्त डेटा प्रकार) को पार करने और कंटेनर के तत्वों तक पहुंचने के लिए किया जाता है। पुनरावर्तक पैटर्न कंटेनरों से एल्गोरिदम को अलग करता है; कुछ मामलों में, एल्गोरिदम आवश्यक रूप से कंटेनर-विशिष्ट होते हैं और इस प्रकार उन्हें अलग नहीं किया जा सकता है।
[[ ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग |ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] में, '''[[इटरेटर]] पैटर्न''' डिज़ाइन पैटर्न (कंप्यूटर साइंस) है जिसमें कंटेनर को पार करने और कंटेनर के एलेमेंट्स तक पहुंचने के लिए इटरेटर का उपयोग किया जाता है। पुनरावर्तक पैटर्न कंटेनरों से एल्गोरिदम को भिन्न करता है; कुछ स्थितियों में, एल्गोरिदम आवश्यक रूप से कंटेनर-विशिष्ट होते हैं और इस प्रकार इन्हें भिन्न नहीं किया जा सकता है।


उदाहरण के लिए, काल्पनिक [[ कलन विधि ]] ''SearchForElement'' को कंटेनर-विशिष्ट एल्गोरिथम के रूप में लागू करने के बजाय आमतौर पर निर्दिष्ट प्रकार के पुनरावर्तक का उपयोग करके कार्यान्वित किया जा सकता है। यह ''SearchForElement'' को किसी भी कंटेनर पर उपयोग करने की अनुमति देता है जो आवश्यक प्रकार के पुनरावर्तक का समर्थन करता है।
उदाहरण के लिए, काल्पनिक [[ कलन विधि |कलन विधि]] SearchForElement को कंटेनर-विशिष्ट एल्गोरिथम के रूप में प्रारम्भ करने के अतिरिक्त सामान्यतः निर्दिष्ट प्रकार के इटरेटर का उपयोग करके कार्यान्वित किया जा सकता है। यह SearchForElement को किसी भी कंटेनर पर उपयोग करने की अनुमति देता है जो आवश्यक प्रकार के इटरेटर का समर्थन करता है।
{{TOC limit|3}}
{{TOC limit|3}}


== सिंहावलोकन ==
== अवलोकन ==
इटरेटर
इटरेटर<ref name="GoF">{{cite book|url=https://archive.org/details/designpatternsel00gamm/page/257|title=Design Patterns: Elements of Reusable Object-Oriented Software|author=Erich Gamma|last2=Richard Helm|last3=Ralph Johnson|last4=John Vlissides|publisher=Addison Wesley|year=1994|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/257 257ff]|url-access=registration}}</ref>[[डिजाइन पैटर्न्स]] 23 प्रसिद्ध GoF डिज़ाइन पैटर्न में से है जो बताता है कि प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर को डिज़ाइन करने के लिए आवर्ती डिज़ाइन समस्याओं को कैसे समाधान किया जाए, अर्थात ऐसी वस्तुएं जिन्हें प्रारंभ करना, परिवर्तित करना सरल हो। परीक्षण करें, और पुन: उपयोग करें।
<ref name="GoF">{{cite book|url=https://archive.org/details/designpatternsel00gamm/page/257|title=Design Patterns: Elements of Reusable Object-Oriented Software|author=Erich Gamma|last2=Richard Helm|last3=Ralph Johnson|last4=John Vlissides|publisher=Addison Wesley|year=1994|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/257 257ff]|url-access=registration}}</ref>
डिजाइन पैटर्न तेईस प्रसिद्ध में से है
[[डिजाइन पैटर्न्स]]
यह वर्णन करता है कि लचीले और पुन: प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर को डिज़ाइन करने के लिए आवर्ती डिज़ाइन समस्याओं को कैसे हल किया जाए, अर्थात ऐसी वस्तुएँ जिन्हें लागू करना, बदलना, परीक्षण करना और पुन: उपयोग करना आसान हो।


=== इटरेटर डिज़ाइन पैटर्न किन समस्याओं को हल कर सकता है? ===
=== इटरेटर डिज़ाइन पैटर्न किन समस्याओं को समाधान कर सकता है? ===
<ref>{{cite web|title=इटरेटर डिजाइन पैटर्न - समस्या, समाधान और प्रयोज्यता|url=http://w3sdesign.com/?gr=b04&ugr=proble|website=w3sDesign.com|access-date=2017-08-12}}</ref>
<ref>{{cite web|title=इटरेटर डिजाइन पैटर्न - समस्या, समाधान और प्रयोज्यता|url=http://w3sdesign.com/?gr=b04&ugr=proble|website=w3sDesign.com|access-date=2017-08-12}}</ref>
* समग्र वस्तु के तत्वों को इसके प्रतिनिधित्व (डेटा संरचनाओं) को उजागर किए बिना एक्सेस और ट्रैवर्स किया जाना चाहिए।
* किसी समग्र वस्तु के एलिमेंट्स को इसके प्रतिनिधित्व (डेटा संरचनाओं) को उजागर किए बिना एक्सेस और ट्रैवर्स किया जाना चाहिए।
* नए ट्रैवर्सल ऑपरेशंस को इसके इंटरफ़ेस को बदले बिना कुल ऑब्जेक्ट के लिए परिभाषित किया जाना चाहिए।
* किसी समग्र ऑब्जेक्ट के इंटरफ़ेस को परिवर्तन किये बिना उसके लिए नए ट्रैवर्सल ऑपरेशंस को परिभाषित किया जाना चाहिए।


एग्रीगेट इंटरफ़ेस में एक्सेस और ट्रैवर्सल ऑपरेशंस को परिभाषित करना अनम्य है क्योंकि यह एग्रीगेट को विशेष एक्सेस और ट्रैवर्सल ऑपरेशंस के लिए प्रतिबद्ध करता है और नए ऑपरेशंस को जोड़ना असंभव बनाता है
एग्रीगेट इंटरफेस में एक्सेस और ट्रैवर्सल ऑपरेशंस को परिभाषित करना अनम्य है क्योंकि यह एग्रीगेट को विशेष एक्सेस और ट्रैवर्सल ऑपरेशंस के लिए प्रतिबद्ध करता है और एग्रीगेट इंटरफेस को परिवर्तन किये बिना पश्चात में नए ऑपरेशंस को जोड़ना असंभव बनाता है।
बाद में समग्र इंटरफ़ेस को बदले बिना।


=== इटरेटर डिज़ाइन पैटर्न किस समाधान का वर्णन करता है? ===
=== इटरेटर डिज़ाइन पैटर्न किस समाधान का वर्णन करता है? ===


* अलग (इटरेटर) ऑब्जेक्ट को परिभाषित करें जो समग्र ऑब्जेक्ट तक पहुँचने और ट्रैवर्सिंग को एनकैप्सुलेट करता है।
* भिन्न (इटरेटर) ऑब्जेक्ट को परिभाषित करें जो समग्र ऑब्जेक्ट तक पहुँचने और ट्रैवर्सिंग को समाहित करता है।
* ग्राहक इसके प्रतिनिधित्व (डेटा संरचनाओं) को जानने के बिना कुल तक पहुँचने और पार करने के लिए पुनरावर्तक का उपयोग करते हैं।
* ग्राहक इसके प्रतिनिधित्व (डेटा संरचनाओं) को जाने बिना किसी समुच्चय तक पहुंचने और उसे पार करने के लिए पुनरावर्तक का उपयोग करते हैं।


अलग-अलग तरीकों से समुच्चय तक पहुँचने और पार करने के लिए अलग-अलग पुनरावृत्तियों का उपयोग किया जा सकता है।
भिन्न-भिन्न विधियों से किसी समुच्चय तक पहुँचने और पार करने के लिए भिन्न-भिन्न पुनरावृत्तियों का उपयोग किया जा सकता है।<br>नए पुनरावृत्तियों को परिभाषित करके नई पहुंच और ट्रैवर्सल संचालन को स्वतंत्र रूप से परिभाषित किया जा सकता है।
<br>नए पुनरावर्तकों को परिभाषित करके नई पहुंच और ट्रैवर्सल संचालन को स्वतंत्र रूप से परिभाषित किया जा सकता है।


नीचे यूएमएल क्लास और सीक्वेंस डायग्राम भी देखें।
नीचे यूएमएल वर्ग और अनुक्रम आरेख भी देखें।


== परिभाषा ==
== परिभाषा ==
Iterator पैटर्न का सार किसी समग्र वस्तु के तत्वों को उसके अंतर्निहित प्रतिनिधित्व को उजागर किए बिना क्रमिक रूप से एक्सेस करने का तरीका प्रदान करना है। .<ref>[[Design Patterns (book)|Gang Of Four]]</ref>
इटरेटर पैटर्न का सार "किसी समग्र वस्तु के एलिमेंट्स को उसके अंतर्निहित प्रतिनिधित्व को उजागर किए बिना क्रमिक रूप से एक्सेस करने की विधि प्रदान करना है।"<ref>[[Design Patterns (book)|Gang Of Four]]</ref>
 


== संरचना ==
== संरचना ==


=== यूएमएल वर्ग और अनुक्रम आरेख ===
=== यूएमएल वर्ग और अनुक्रम आरेख ===
[[File:w3sDesign Iterator Design Pattern UML.jpg|frame|none|Iterator डिज़ाइन पैटर्न के लिए नमूना UML वर्ग और अनुक्रम आरेख।<ref>{{cite web|title=इटरेटर डिजाइन पैटर्न - संरचना और सहयोग|url=http://w3sdesign.com/?gr=b04&ugr=struct|website=w3sDesign.com|access-date=2017-08-12}}</ref>]]उपरोक्त [[ एकीकृत मॉडलिंग भाषा ]] [[ वर्ग आरेख ]] में, <code>Client</code> वर्ग (1) को संदर्भित करता है <code>Aggregate</code> बनाने के लिए इंटरफ़ेस <code>Iterator</code> वस्तु (<code>createIterator()</code>) और (2) से <code>Iterator</code> ट्रैवर्सिंग के लिए इंटरफ़ेस <code>Aggregate</code> वस्तु (<code>next(),hasNext()</code>). <code>Iterator1</code> e> वर्ग लागू करता है <code>Iterator</code> इंटरफ़ेस का उपयोग करके <code>Aggregate1</code> कक्षा।
[[File:w3sDesign Iterator Design Pattern UML.jpg|frame|none|इटरेटर डिज़ाइन पैटर्न के लिए प्रारूप यूएमएल वर्ग और अनुक्रम आरेख।<ref>{{cite web|title=इटरेटर डिजाइन पैटर्न - संरचना और सहयोग|url=http://w3sdesign.com/?gr=b04&ugr=struct|website=w3sDesign.com|access-date=2017-08-12}}</ref>]]उपरोक्त [[ एकीकृत मॉडलिंग भाषा |एकीकृत मॉडलिंग भाषा]] [[ वर्ग आरेख |वर्ग आरेख]] में, <code>Client</code> क्लास (1) इटरेटर ऑब्जेक्ट बनाने के लिए एग्रीगेट <code>Aggregate</code> इंटरफ़ेस को संदर्भित करता है (<code>createIterator()</code>) बनाने और एग्रीगेट ऑब्जेक्ट को ट्रैवर्स करने के लिए इटरेटर इंटरफ़ेस को संदर्भित करता है (<code>next(),hasNext()</code>) <code>Iterator1</code> क्लास <code>Aggregate1</code> क्लास तक पहुँच कर <code>Iterator</code> इंटरफ़ेस को कार्यान्वित करता है।


एकीकृत मॉडलिंग भाषा [[अनुक्रम आरेख]]
एकीकृत मॉडलिंग भाषा [[अनुक्रम आरेख]] रन-टाइम इंटरैक्शन दिखाता है: <code>Client</code> ऑब्जेक्ट पर <code>createIterator()</code> को कॉल करता है, जो <code>Iterator1</code> ऑब्जेक्ट बनाता है और इसे क्लाइंट को रिटर्न करता है। क्लाइंट <code>Aggregate1</code> ऑब्जेक्ट के एलिमेंट्स को पार करने के लिए <code>Iterator1</code> का उपयोग करता है।
रन-टाइम इंटरैक्शन दिखाता है: <code>Client</code> ई> वस्तु कॉल <code>createIterator()</code> पर <code>Aggregate1</code> वस्तु, जो बनाता है <code>Iterator1</code> वस्तु और उसे लौटाता है
तक <code>Client</code>. <code>Client</code> e> तब उपयोग करता है <code>Iterator1</code> के तत्वों को पार करने के लिए <code>Aggregate1</code> वस्तु।


=== यूएमएल वर्ग आरेख ===
=== यूएमएल वर्ग आरेख ===
Line 46: Line 37:


== उदाहरण ==
== उदाहरण ==
{{main|Iterator}}
{{main|इटरेटर}}
कुछ भाषाएँ सिंटैक्स को मानकीकृत करती हैं। C++ और Python उल्लेखनीय उदाहरण हैं।
 
<!-- READ NOTE BELOW BEFORE ADDING EXAMPLES
कुछ भाषाएँ वाक्यविन्यास का मानकीकरण करती हैं। सी++ और पाइथन इसके उल्लेखनीय उदाहरण हैं।
Wikipedia is not a list of examples. Do not add examples from your favorite programming language here; this page exists to explain the design pattern, not to show how it interacts with subtleties of every language extant. Feel free to add examples here: http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Iterator
 
-->
[[सी ++|'''सी++''']]


सी++ उस भाषा में [[सूचक (कंप्यूटर प्रोग्रामिंग)|पॉइंटर्स (कंप्यूटर प्रोग्रामिंग)]] के शब्दार्थ के साथ पुनरावृत्तियों को प्रारम्भ करता है। सी ++ में, क्लास सभी पॉइंटर ऑपरेशंस को ओवरलोड कर सकती है, इसलिए पुनरावर्तक को प्रारम्भ किया जा सकता है जो कमोबेश पॉइंटर के जैस कार्य करता है, जो डीरेफ़रेंस, इंक्रीमेंट और डिक्रीमेंट के साथ पूर्ण होता है। इसका लाभ यह है कि सी++ एल्गोरिदम जैसे <code>std::sort</code> को प्लेन प्राचीन मेमोरी बफ़र्स पर प्रारंभ किया जा सकता है, और सीखने के लिए कोई नया सिंटैक्स नहीं है। चूँकि, समानता के परीक्षण के लिए "अंत" पुनरावर्तक की आवश्यकता होती है, इसके अतिरिक्त कि पुनरावर्तक को यह ज्ञात हो कि वह अंत तक पहुँच गया है। सी ++ भाषा में, हम कहते हैं कि इटरेटर [[अवधारणा (जेनेरिक प्रोग्रामिंग)]] को मॉडल करता है।


=== [[सी ++]] ===
यह सी++ 11 कार्यान्वयन अध्याय "वेक्टर को फिर से सामान्य बनाने" पर आधारित है।<ref>{{cite book |author=Bjarne Stroustrup |title=Programming: Principles and Practice using C++ |edition=2 |publisher=Addison Wesley |year=2014 |isbn=978-0-321-99278-9 |pages=729 ff.}}</ref>
सी ++ उस भाषा में [[सूचक (कंप्यूटर प्रोग्रामिंग)]] के शब्दार्थ के साथ पुनरावृत्तियों को लागू करता है। सी ++ में, वर्ग सभी पॉइंटर ऑपरेशंस को अधिभारित कर सकता है, इसलिए पुनरावर्तक को लागू किया जा सकता है जो सूचक की तरह अधिक या कम कार्य करता है, जो कि डीरेफरेंस, इंक्रीमेंट और डिक्रीमेंट के साथ पूरा होता है। इसका लाभ यह है कि सी ++ एल्गोरिदम जैसे <code>std::sort</code> सादे पुराने मेमोरी बफ़र्स पर तुरंत लागू किया जा सकता है, और यह कि सीखने के लिए कोई नया सिंटैक्स नहीं है। हालांकि, पुनरावर्तक को यह जानने की अनुमति देने के बजाय समानता के लिए परीक्षण करने के लिए अंत पुनरावर्तक की आवश्यकता होती है कि यह अंत तक पहुंच गया है। सी ++ भाषा में, हम कहते हैं कि इटरेटर इटरेटर [[अवधारणा (जेनेरिक प्रोग्रामिंग)]] का मॉडल करता है।
  #include <iostream>


यह C++ 11 कार्यान्वयन अध्याय सामान्यीकरण वेक्टर पर फिर से आधारित है।<ref>{{cite book |author=Bjarne Stroustrup |title=Programming: Principles and Practice using C++ |edition=2 |publisher=Addison Wesley |year=2014 |isbn=978-0-321-99278-9 |pages=729 ff.}}</ref>
#include <stdexcept>
<वाक्यविन्यास प्रकाश लैंग = सी ++>
#include <initializer_list>
#शामिल <iostream>
# शामिल करें
# शामिल करें <प्रारंभकर्ता_सूची>


वर्ग वेक्टर {
class Vector {
जनता:
  इटरेटर = डबल * का उपयोग करना;
  पुनरावर्तक प्रारंभ () {वापसी तत्व; }
  पुनरावर्तक अंत () {वापसी हाथ + sz; }
 
  वेक्टर (std::initializer_list<double> lst):elem(nullptr), sz(0) {
    एसजे = एलएसटी आकार ();
    एलएम = नया डबल [एसजेड];
    डबल * पी = एलएम;
    for (auto i = lst.begin(); i != lst.end(); ++i, ++p) {
      *पी = *मैं;
    }
  }
  ~ वेक्टर () {हटाएं [] तत्व; }
  int आकार () कास्ट {वापसी sz; }
  डबल और ऑपरेटर [] (इंट एन) {
    if (n <0 || n >= sz) std::out_of_range(वेक्टर::ऑपरेटर[]);
    वापसी तत्व [एन];
  }
  वेक्टर (स्थिरांक वेक्टर और) = हटाएं; // तीन का नियम
  वेक्टर और ऑपरेटर = (स्थिरांक वेक्टर और) = हटाएं;
निजी:
  डबल * तत्व;
  इंट एसजेड;
};


मुख्य प्रवेश बिंदु() {
public:
  वेक्टर वी = {1.1*1.1, 2.2*2.2};
 
  के लिए (स्थिरांक ऑटो और एक्स: वी) {
    एसटीडी :: अदालत << एक्स << '\n';
  }
  for (auto i = v.begin(); i != v.end(); ++i) {
    एसटीडी :: अदालत << * मैं << '\n';
  }
  for (auto i = 0; i <= v.size(); ++i) {
    एसटीडी :: अदालत << वी ​​[i] << '\n';
  }
}
</वाक्यविन्यास हाइलाइट>


using iterator = double*;
iterator begin() { return elem; }
  iterator end() { return elem + sz; }
  Vector(std::initializer_list<double> lst) :elem(nullptr), sz(0) {
    sz = lst.size();
    elem = new double[sz];
    double* p = elem;
    for (auto i = lst.begin(); i != lst.end(); ++i, ++p) {
      *p = *i;
}
} 
  ~Vector() { delete[] elem; }
  int size() const { return sz; }
  double& operator[](int n) {
    if (n < 0 || n >= sz) throw std::out_of_range("Vector::operator[]");
    return elem[n];
  }
  Vector(const Vector&) = delete; // rule of three
  Vector& operator=(const Vector&) = delete;
private:
  double* elem;
  int sz;
};
int main() {
  Vector v = {1.1*1.1, 2.2*2.2};