शुरुआती के लिए एसटीएल। कंटेनर श्रेणी कार्यान्वयन

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

यह लेख केवल उन शुरुआती लोगों के लिए दिलचस्प होगा जो मानक पुस्तकालय का अध्ययन करना शुरू करते हैं, पेशेवरों को यहां अपने लिए कुछ भी नया नहीं मिलेगा।

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

और अब टिप्पणियों के साथ बहुत सारे कोड होंगे।
फ़ाइल "dlist.h"

#ifndef DLIST_H_ #define DLIST_H_ #include <iostream> template <typename T> class Double_list { public: class iterator; friend class iterator; //        Double_list private: class Double_node; friend class Double_node; class Double_node // { public: friend class Double_list<T>; friend class iterator; //      T Double_node(T node_val): val(node_val) {} Double_node() {} ~Double_node() {} void print_val() {std::cout << val << " "; } Double_node *next; //     Double_node *prev; //   . T val; //. }; public: class iterator { friend class Double_list<T>; public: //   iterator() :the_node(0) {} //        Double_node iterator(Double_node *dn): the_node(dn) {} //  iterator(const iterator &it): the_node(it.the_node) {} iterator& operator=(const iterator &it) { the_node = it.the_node; return *this; } //     == ,      //      bool operator == (const iterator &it) const { return (the_node == it.the_node); } bool operator!=(const iterator &it) const { return !(it == *this); } //     . iterator& operator++() { if (the_node == 0) throw "incremented an empty iterator"; if (the_node->next == 0) throw "tried to increment too far past the end"; the_node = the_node->next; return *this; } //   і  . iterator & operator--() { if (the_node == 0) throw "decremented an empty iterator"; if (the_node->prev == 0) throw "tried to decrement past the beginning"; the_node = the_node->prev; return *this; } //  . T& operator*() const { if (the_node == 0) throw "tried to dereference an empty iterator"; return the_node->val; } private: Double_node *the_node; }; private: Double_node *head; //   . Double_node *tail; //  ,     iterator head_iterator; //,       iterator tail_iterator; //,     ,    . public: Double_list() { head = tail = new Double_node; tail->next = nullptr; tail->prev = nullptr; //  head_iterator = iterator(head); tail_iterator = iterator(tail); } // ,    . Double_list(T node_val) { head = tail = new Double_node; tail->next = nullptr; tail->prev = 0; head_iterator = iterator(head); tail_iterator = iterator(tail); add_front(node_val); } ~Double_list() { Double_node *node_to_delete = head; for (Double_node *sn = head; sn != tail;) { sn = sn->next; delete node_to_delete; node_to_delete = sn; } delete node_to_delete; } bool is_empty() {return head == tail;} iterator front() {return head_iterator;} iterator rear() {return tail_iterator;} //     void add_front(T node_val) { Double_node *node_to_add = new Double_node (node_val); node_to_add->next = head; node_to_add->prev = nullptr; head->prev = node_to_add; head = node_to_add; //  head ,   head_iterator head_iterator= iterator(head); } //     void add_rear(T node_val) { if (is_empty()) add_front(node_val); else { Double_node *node_to_add = new Double_node(node_val); node_to_add->next = tail; node_to_add->prev = tail->prev; tail->prev->next = node_to_add; tail->prev = node_to_add; // tail_iterator tail_iterator = iterator(tail); } } //   node_val   key_i bool insert_after(T node_val, const iterator &key_i) { for (Double_node *dn = head; dn != tail; dn = dn->next) { //      if (dn == key_i.the_node) { Double_node *node_to_add = new Double_node(node_val); node_to_add->prev = dn; node_to_add->next = dn->next; dn->next->prev = node_to_add; dn->next = node_to_add; return true; } } return false; } //   . T remove_front() { if (is_empty()) throw "tried to remove from an empty list"; Double_node *node_to_remove = head; T return_val = node_to_remove->val; head = node_to_remove->next; head->prev = 0; head_iterator = iterator(head); delete node_to_remove; return return_val; } T remove_rear() { if (is_empty()) throw "tried to remove from an empty list"; Double_node *node_to_remove = tail->prev; if(node_to_remove->prev == 0) { return remove_front(); } else { T return_val = node_to_remove->val; node_to_remove->prev->next = tail; tail->prev = node_to_remove->prev; delete node_to_remove; return return_val; } } bool remove_it(iterator &key_i) { for (Double_node *dn = head; dn != tail; dn = dn-next) { //      if (dn == key+i.the_node) { dn->prev->next = dn->next; dn->next->prev = dn->prev; delete dn; key_i.the_node =0; return true; } } return false; } //  ,   node_val iterator find(T node_val) const { for (double_node *dn = head; dn != tail; dn = dn->next) { if (dn->val == node_val) return iterator(dn); } // node_val     tail_iterator return tail_iterator; } // ,    n-   iterator get_nth(const int element_num) const { if (element_num < 1) return tail_iterator; int count = 1; for(Double_node *dn = head; dn != tail; dn = dn->next) { if (count++ == element_num) return iterator(dn); } return tail_iterator; } //   . int size() const { int count = 0; for (Double_node *dn = head; dn != tail; dn = dn->next) ++count; return count; } void print() const { for (Double_node *dn = head; dn!= tail; dn = dn->next) { dn->print_val(); } std::cout << std::endl; } }; #endif 

सूची का उपयोग करें

 #include "dlist.h" int main() { Double_list<int> the_list; Double_list<int>::iterator list_iter; for (int i=0; i<5; ++i) { the_list.add_front(i); } the_list.print(); the_list.remove_front(); for (list_iter = the_list.front(); list_iter != the_list.rear(); ++ list_iter) { std::cout << *list_iter << " "; } std::cout << std:: endl; //    for (list_iter = the_list.rear(); list_iter != the_list.front();) { --list_iter; std::cout << *list_iter << " "; } std::cout << std::endl; system("PAUSE"); return 0; } 

कोड विश्लेषण

एक पुनरावृत्त को एक खुले नेस्टेड वर्ग के रूप में लागू किया जाता है। चूंकि कक्षा खुली है, उपयोगकर्ता ऑब्जेक्ट बना सकते हैं। इट्रेटर क्लास को डबल_लिस्ट क्लास के कुछ निजी तत्वों के बारे में जानने की आवश्यकता है, इसलिए हम इट्रेटर क्लास को डबल_लिस्ट क्लास के अनुकूल घोषित करते हैं , और इट्रेटर क्लास में हम एक और डबल_लिस्ट क्लास घोषित करते हैं ।

अब आइए Double_list :: iterator वर्ग के आंतरिक उपकरण को देखें। इसमें एक एकल डेटा आइटम है: Double_node * the_node । यह वह है जिसे पुनरावृत्त को छिपाना चाहिए। पुनरावृति वर्ग में घोषित ऑपरेशन उपयोगकर्ताओं को एक विशिष्ट तरीके से इस नोड को हेरफेर करने की अनुमति देते हैं।

अंत

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