मानक उदाहरण की शिकायत करना

इनपुट.टेक्स फ़ाइल से व्हॉट्सएप द्वारा अलग किए गए पूर्णांकों की एक सरणी पढ़ें। उन्हें क्रमबद्ध करें और output.txt पर लिखें

#include <vector> #include <algorithm> #include <fstream> int main(){ //  input.txt   std::ifstream fin("input.txt"); //  output.txt   std::ofstream fout("output.txt"); //       std::vector<int> v; //  ,           std::copy(std::istream_iterator<int>(fin), std::istream_iterator<int>(), std::inserter(v, v.end())); //   std::sort(v.begin(), v.end()); //  ,          std::copy(v.begin(), v.end(), std::ostream_iterator<int>(fout, " ")); return 0; } 

• पुस्तकालय की नींव में से एक पुनरावृत्तियों के साथ-साथ उनके द्वारा परिभाषित आधे अंतराल भी हैं। शब्दार्थ द्वारा (पढ़ें - व्यवहार से) वे संकेत के साथ मेल खाते हैं। यही है, dereferencing ऑपरेटर * आपके पास उस तत्व को लौटाएगा जो पुनरावृत्तिकर्ता को संदर्भित करता है, ++ अगले तत्व के लिए पुनरावृत्त का अनुवाद करेगा। विशेष रूप से, किसी भी कंटेनर को उसके अंत पुनरावृत्तियों [शुरुआत, अंत) द्वारा दर्शाया जाता है, जहां पहले तत्व के लिए बिंदु शुरू होते हैं, अंत - अंतिम के लिए ;
• एल्गोरिदम जो कंटेनर के साथ काम करते हैं, चूंकि पैरामीटर कंटेनर की शुरुआत और अंत (या उसके भाग) लेते हैं;
• कॉपी कॉपी एल्गोरिदम बस एक आधे-अंतराल से दूसरे तक तत्वों को फिर से लिखता है। यदि कोई स्मृति लक्ष्य कंटेनर में आवंटित नहीं की गई है, तो व्यवहार अप्रत्याशित है [ प्रतिलिपि ];
• डालने का कार्य निर्दिष्ट इट्रेटर से पहले कंटेनर में एक मूल्य सम्मिलित करता है [ प्रविष्टि ]
• istream_iterator और ostream_iterator धाराओं को कंटेनर-शैली पहुंच प्रदान करते हैं [ istream_iterator , ostream_iterator ]

Input.txt फ़ाइल में लोगों के बारे में जानकारी वाली एक सूची है: अंतिम नाम, पहला नाम, उम्र (प्रत्येक पंक्ति एक रिकॉर्ड है, डेटा को एक स्थान से अलग किया गया है)। इस डेटा को एक सरणी में पढ़ें, इसे उम्र के अनुसार क्रमबद्ध करें और output.txt फ़ाइल पर लिखें। एक ऐसे व्यक्ति के बारे में जानकारी प्रदर्शित करें, जिसकी आयु 20 से अधिक है, लेकिन 25 वर्ष से कम है।

1. एक डेटा संरचना की घोषणा करें। - आप कुछ उपयोगी परिभाषित कर सकते हैं, लेकिन एक विशेष मामले में, संरचना पर्याप्त है:
   
   

    struct man{ std::string firstname, secondname; size_t age; }; 

   
   मैं दृढ़ता से अनुशंसा करता हूं कि आप डिफ़ॉल्ट पैरामीटर और कॉपी ऑपरेटर के साथ कॉपी कंस्ट्रक्टर्स के कार्यान्वयन पर विचार करें। परियोजना के आगे विकास के साथ, आपको निश्चित रूप से उनकी आवश्यकता होगी।
2. ओवरलोड I / O ऑपरेटर - इन ऑपरेटरों को थ्रेडर्स पर पुनरावृत्तियों द्वारा हेरफेर किया जाता है। वैसे भी, उनका उपयोग करना अधिक सामान्य है।
   
   

    std::ostream& operator << (std::ostream& out, const man& p){ out << p.firstname << " " << p.secondname << " " << p.age; return out; } std::istream& operator >> (std::istream& in, man& p){ in >> p.firstname >> p.secondname >> p.age; return in; } 

3. ऑब्जेक्ट ऑर्डर करने के लिए नियमों को परिभाषित करें - यह पहले से ही एक बड़ा विस्तार है: आप ऑपरेटर को ओवरराइड कर सकते हैं <, आप एक फ़ंक्शन, फ़ंक्टर या लैम्ब्डा अभिव्यक्ति का वर्णन कर सकते हैं। इस मामले में, फ़ंक्शन का उपयोग करें।
   
   

    bool comparator(const man& p1, const man& p2){ return p1.age < p2.age; } 

4. वस्तुओं के चयन के लिए एक नियम को परिभाषित करें - फिर से, कार्यान्वयन का एक बड़ा चयन। इस बार, एक फ़नकार (उस वर्ग का एक ऑब्जेक्ट जिसमें कोष्ठक [ फ़नकार ] ऑपरेटर परिभाषित किया गया है) है, जिससे आप आयु सीमा पार कर सकते हैं:
   
   

    struct predicate{ size_t begin, end; predicate(int p1, int p2): begin(p1), end(p2) {} bool operator ()(const man& p){ return (p.age > begin) && (p.age < end); } }; 

   
   फ़नकार के निर्माता पर ध्यान दें - इस तरह हम इसके व्यवहार को अनुकूलित कर सकते हैं।

 int main(){ std::ifstream fin("input.txt"); std::ofstream fout("output.txt"); std::vector<man> v; std::copy(std::istream_iterator<man>(fin), std::istream_iterator<man>(), std::inserter(v, v.end())); std::sort(v.begin(), v.end(), comparator); std::copy_if(v.begin(), v.end(), std::ostream_iterator<man>(std::cout, "\n"), predicate(20, 25)); std::copy(v.begin(), v.end(), std::ostream_iterator<man>(fout, "\n")); return 0; } 

1. मानक पुस्तकालय के एल्गोरिदम का उपयोग करके जानना और सक्रिय रूप से विकास को गति देता है (अधिक सटीक रूप से, यह स्वचालितता की ओर जाता है)।
2. विभिन्न रचनाकारों की घोषणा करना और डेटा संरचनाओं के लिए कॉपी ऑपरेटर्स उपयोगी है। वे विभिन्न स्थितियों में उपयोग किए जाते हैं, विशेष रूप से जब कंटेनर में तत्व सम्मिलित करते हैं।
3. सुविधा के लिए, आप इनपुट और आउटपुट ऑपरेटरों के साथ-साथ तुलना ऑपरेटर और ऑर्डर करने वाले ऑपरेटर को अधिभारित कर सकते हैं।
4. फ़ंक्टर - एक शक्तिशाली उपकरण जो आपको "मेमोरी" या अतिरिक्त व्यवहार के साथ कार्यों को लागू करने की अनुमति देता है
5. ... शायद कुछ और ...

 #include <string> #include <vector> #include <fstream> #include <algorithm> #include <iostream> #include <iterator> struct man{ std::string firstname, secondname; size_t age; }; std::ostream& operator << (std::ostream& out, const man& p){ out << p.firstname << " " << p.secondname << " " << p.age; return out; } std::istream& operator >> (std::istream& in, man& p){ in >> p.firstname >> p.secondname >> p.age; return in; } bool comparator(const man& p1, const man& p2){ return p1.age < p2.age; } struct predicate{ size_t begin, end; predicate(int p1, int p2): begin(p1), end(p2) {} bool operator ()(const man& p){ return (p.age > begin) && (p.age < end); } }; int main(){ std::ifstream fin("input.txt"); std::ofstream fout("output.txt"); std::vector<man> v; std::vector<man>::iterator i; std::copy(std::istream_iterator<man>(fin), std::istream_iterator<man>(), std::inserter(v, v.end())); std::sort(v.begin(), v.end(), comparator); std::copy_if(v.begin(), v.end(), std::ostream_iterator<man>(std::cout, "\n"), predicate(20, 25)); std::copy(v.begin(), v.end(), std::ostream_iterator<man>(fout, "\n")); return 0; } 

1. Stepanov अल। ली मेंग, द स्टैंडर्ड टेम्पलेट लाइब्रेरी, 1995
2. CPP संदर्भ, प्रतिलिपि
3. सीपीपी संदर्भ, आवेषण
4. CPP संदर्भ, istream_iterator
5. CPP संदर्भ, ostream_iterator
6. विकी फनकार