"Boost.Asio C ++ नेटवर्क प्रोग्रामिंग।" अध्याय 6: - अन्य विशेषताएं

सभी को नमस्कार!
मैं जॉन टोरजो की पुस्तक Boost.Asio C ++ नेटवर्क प्रोग्रामिंग का अनुवाद करना जारी रखता हूं।

सामग्री:

• अध्याय 1: Boost.Asio के साथ शुरुआत करना
• अध्याय 2: बूस्ट.आसियो मूल बातें
  
  • भाग 1: Boost.Asio की मूल बातें
  • भाग 2: अतुल्यकालिक प्रोग्रामिंग
• अध्याय 3: इको सर्वर / क्लाइंट
• अध्याय 4: क्लाइंट और सर्वर
• अध्याय 5: सिंक्रोनस बनाम एसिंक्रोनस
• अध्याय 6: Boost.Asio - अन्य विशेषताएं
• अध्याय 7: Boost.Asio - अतिरिक्त विषय

इस अध्याय में हम Boost.Asio की कुछ बहुत ही जानी-मानी विशेषताओं को देखेंगे। एसटीडी स्ट्रीम और स्ट्रीमबॉफ ऑब्जेक्ट कभी-कभी उपयोग करने के लिए थोड़ा अधिक कठिन होते हैं, लेकिन जैसा कि आप अपने लिए देख सकते हैं, उनके फायदे हैं। अंत में, आपको Boost.Asio - co-routines के बजाय एक देर से अतिरिक्त दिखाई देगा, जो आपको अतुल्यकालिक कोड रखने की अनुमति देगा, लेकिन पढ़ने में आसान (जैसे कि यह तुल्यकालिक था)। यह एक बहुत ही अद्भुत विशेषता है।

std धाराएँ और std इनपुट / आउटपुट बफ़र

इस खंड में लिखी बातों को समझने के लिए आपको एसटीएल धाराओं और एसटीएल स्ट्रीमब्यूफ जैसी वस्तुओं से परिचित होना चाहिए।
Boost.Asio में I / O के साथ काम करने के लिए दो प्रकार के बफ़र्स हैं:

• बढ़ावा :: asio :: बफर ()
• बढ़ावा देना :: asio :: streambuf

पुस्तक के दौरान, आपने मूल रूप से निम्नलिखित की तरह कुछ देखा:

size_t read_complete(boost::system::error_code, size_t bytes){ ... } char buff[1024]; read(sock, buffer(buff), read_complete); write(sock, buffer("echo\n")); 

यह आमतौर पर आपके लिए पर्याप्त होगा। लेकिन, यदि आप अधिक लचीलापन चाहते हैं, तो आप streambuf उपयोग कर सकते हैं। यहां एक सरल और सबसे खराब चीज है जिसे आप streambuf ऑब्जेक्ट के साथ कर सकते हैं:

 streambuf buf; read(sock, buf); 

यह रीडिंग तब तक streambuf जब तक कि streambuf ऑब्जेक्ट streambuf , और चूंकि स्ट्रीमबॉफ ऑब्जेक्ट अपने आप को अधिक स्थान समायोजित करने के लिए पुनर्वितरित कर सकता है, मूल रूप से, रीडिंग तब तक जाएगी जब तक कि कनेक्शन बंद न हो जाए। पिछले वर्ण को पढ़ने के लिए आप read_until फ़ंक्शन का उपयोग कर सकते हैं:

 streambuf buf; read_until(sock, buf, "\n"); 

यहां, रीडिंग '\ n' वर्ण तक जाएगी, फिर जो पढ़ा गया है उसे बफर में जोड़ा जाएगा और रीड फंक्शन से बाहर निकल जाएगा। streambuf ऑब्जेक्ट के लिए कुछ लिखने के लिए streambuf आप निम्न के समान कुछ करेंगे:

 streambuf buf; std::ostream out(&buf); out << "echo" << std::endl; write(sock, buf); 

यह काफी सरल है, आपको एसटीएल स्ट्रीम बनाने की जरूरत है, निर्माण के दौरान स्ट्रीमबॉफ ऑब्जेक्ट को वहां रखें, उस संदेश को लिखें जिसे आप इसे भेजना चाहते हैं, और फिर बफर की सामग्री भेजने के लिए write फ़ंक्शन का उपयोग करें।

Boost.Asio और STL स्ट्रीम

C Boost.Asio ने STL स्ट्रीम और नेटवर्क को एकीकृत करने के लिए एक बेहतरीन काम किया। अर्थात्, यदि आप पहले से ही व्यापक रूप से एसटीएल का उपयोग कर रहे हैं, तो आपके पास पहले से ही ओवरलोड ऑपरेटरों >> और << के साथ कई कक्षाएं होनी चाहिए। सॉकेट्स को पढ़ना और लिखना पार्क में टहलने से ज्यादा आपको पसंद आएगा।
मान लीजिए कि आपके पास निम्नलिखित कोड स्निपेट हैं:

 struct person { std::string first_name, last_name; int age; }; std::ostream& operator<<(std::ostream & out, const person & p) { return out << p.first_name << " " << p.last_name << " " << p.age; } std::istream& operator>>(std::istream & in, person & p) { return in >> p.first_name >> p.last_name >> p.age; } 

नेटवर्क पर मानव डेटा को स्थानांतरित करना उतना ही सरल है जितना नीचे दिखाया गया है:

 streambuf buf; std::ostream out(&buf); person p; // ... initialize p out << p << std::endl; write(sock, buf); 

दूसरा पक्ष इसे आसानी से पढ़ सकता है:

 read_until(sock, buf, "\n"); std::istream in(&buf); person p; in >> p; 

streambuf ऑब्जेक्ट्स और निश्चित रूप से संबंधित std::ostream का उपयोग करने का वास्तव में अच्छा पक्ष std::ostream लेखन के लिए std::ostream या std::istream पढ़ने के लिए std::istream यह है कि आप लेखन कोड को समाप्त करते हैं जिसे सामान्य माना जाएगा:

• जब कुछ ऐसा लिखा जाता है जो नेटवर्क पर प्रसारित होगा, तो यह बहुत संभावना है कि आपके पास एक से अधिक डेटा होगा। इस प्रकार, अंत में, आप बफर में डेटा जोड़ देंगे। यदि यह डेटा स्ट्रिंग नहीं है, तो आपको पहले इसे एक स्ट्रिंग में बदलना होगा। << संचालक का उपयोग करते समय यह सब डिफ़ॉल्ट रूप से होता है।
• संदेश पढ़ते समय दूसरी ओर भी यही बात होती है; आपको इसे पार्स करने की आवश्यकता है, अर्थात्, एक समय में डेटा का एक टुकड़ा पढ़ें, और यदि डेटा स्ट्रिंग नहीं है, तो आपको इसे परिवर्तित करने की आवश्यकता है। यह सब डिफ़ॉल्ट रूप से होता है यदि आप पढ़ते समय >> ऑपरेटर का उपयोग करते हैं।

अंत में, कंसोल में streambuf ऑब्जेक्ट की सामग्री को डंप करने के लिए एक बहुत अच्छा ट्रिक जाना जाता है, निम्नलिखित कोड का उपयोग करें:

 streambuf buf; ... std::cout << &buf << std::endl; // dumps all content to the console 

इसी तरह, अपनी सामग्री को स्ट्रिंग में बदलने के लिए, निम्न कोड स्निपेट का उपयोग करें:

 std::string to_string(streambuf &buf) { std::ostringstream out; out << &buf; return out.str(); } 

क्लास स्ट्रीमफ

जैसा कि मैंने कहा, streambuf std::streambuf. से लिया गया है std::streambuf. Std :: streambuf की तरह इसमें कॉपी कंस्ट्रक्टर नहीं है।
इसके अतिरिक्त, इसकी कई अतिरिक्त विशेषताएं हैं, जैसे:

• streambuf ([max_size,] [allocator]) : यह फ़ंक्शन एक स्ट्रीमब्यूफ़ ऑब्जेक्ट बनाता है। यदि आवश्यक हो, तो आप वैकल्पिक रूप से अधिकतम बफर आकार और आवंटन सेट कर सकते हैं जिसका उपयोग स्मृति को आवंटित / मुक्त करने के लिए किया जाएगा।
• prepare(n) : यह फ़ंक्शन n वर्णों के निरंतर क्रम को रखने के लिए उपयोग किए गए उप-बफर को लौटाता है। इसका उपयोग पढ़ने या लिखने के लिए किया जा सकता है। इस फ़ंक्शन के परिणाम का उपयोग Boost.Asio के किसी भी स्वतंत्र फ़ंक्शन के साथ किया जा सकता है, जो स्ट्रीमब्यूफ़ ऑब्जेक्ट्स के साथ काम करने / लिखने और न केवल streambuf है।
• data() : यह फ़ंक्शन वर्णों के निरंतर अनुक्रम के रूप में पूरे बफर को लौटाता है और लेखन के लिए उपयोग किया जाता है। इस फ़ंक्शन के परिणाम को Boost.Asio से किसी भी स्वतंत्र फ़ंक्शन के साथ उपयोग किया जा सकता है, जो रिकॉर्ड करता है, और न केवल उन है जो स्ट्रीमब्यूफ़ ऑब्जेक्ट्स के साथ काम करते हैं।
• consume(n) : इस फ़ंक्शन में, डेटा इनपुट अनुक्रम (एक रीड ऑपरेशन से) से हटा दिया जाता है।
• commit(n) : इस फ़ंक्शन में, डेटा आउटपुट अनुक्रम (राइट ऑपरेशन) से हटा दिया जाता है और इनपुट अनुक्रम (रीड ऑपरेशन में) में जोड़ा जाता है।
• size() : यह फ़ंक्शन संपूर्ण streambuf ऑब्जेक्ट के वर्णों में आकार देता है।
• max_size() : यह फ़ंक्शन अधिकतम उन वर्णों को लौटाता है जिन्हें एक streambuf ऑब्जेक्ट में शामिल किया जा सकता है।

पिछले दो कार्यों के अपवाद के साथ, बाकी को समझना इतना आसान नहीं है। सबसे पहले, ज्यादातर मामलों में, आप एक स्वतंत्र फ़ंक्शन को पढ़ने / लिखने के तर्क के रूप में streambuf का एक उदाहरण भेजेंगे, जैसा कि नीचे दिखाया गया है:

 read_until(sock, buf, "\n"); // reads into buf write(sock, buf); // writes from buf 

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

 read_until(sock, buf, '\n'); std::cout << &buf << std::endl; 

पिछला स्निपेट रीसेट करेगा जो आप सॉकेट से पढ़ते हैं। निम्न उदाहरण कुछ डंप नहीं करेगा:

 read(sock, buf.prepare(16), transfer_exactly(16) ); std::cout << &buf << std::endl; 

बाइट्स पढ़े जाते हैं, लेकिन पॉइंटर नहीं चलता। आपको इसे स्वयं स्थानांतरित करना होगा, जैसा कि नीचे दिखाया गया है:

 read(sock, buf.prepare(16), transfer_exactly(16) ); buf.commit(16); std::cout << &buf << std::endl; 

इसी तरह, यदि आप एक streambuf ऑब्जेक्ट पर लिखना चाहते हैं और यदि आप एक स्वतंत्र लेखन फ़ंक्शन का उपयोग करते हैं, तो निम्न कोड टुकड़ा का उपयोग करें:

 streambuf buf; std::ostream out(&buf); out << "hi there" << std::endl; write(sock, buf); 

निम्न कोड तीन बार hi there भेजेगा:

 streambuf buf; std::ostream out(&buf); out << "hi there" << std::endl; for ( int i = 0; i < 3; ++i) write(sock, buf.data()); 

ऐसा इसलिए होता है क्योंकि बफर कभी नष्ट नहीं होता है और डेटा वहीं रहता है। यदि आप चाहते हैं कि डेटा नष्ट हो जाए, तो देखें कि यह कैसे लागू किया जाता है:

 streambuf buf; std::ostream out(&buf); out << "hi there" << std::endl; write(sock, buf.data()); buf.consume(9); 

अंत में, आपको streambuf की पूरी आवृत्ति से निपटना पसंद करना चाहिए। यदि आप फाइन-ट्यून करना चाहते हैं तो पिछले कार्यों का उपयोग करें।
भले ही आप पढ़ने और लिखने के लिए एक ही स्ट्रीमब्यूफ उदाहरण का उपयोग कर सकते हैं, फिर भी मैं आपको दो अलग-अलग उदाहरणों की सलाह देता हूं, एक पढ़ने के लिए और एक लिखने के लिए। यह आसान और अधिक स्पष्ट रूप से माना जाता है, और आप कई संभावित गलतियों से बचेंगे।

streambuf ऑब्जेक्ट्स के साथ काम करने वाले स्वतंत्र कार्य

निम्नलिखित सूची Boost.Asio से स्वतंत्र कार्यों को दर्शाती है जो स्ट्रीमबॉफ ऑब्जेक्ट के साथ काम करते हैं:

• read (sock, buf [, completion_function]) : यह फ़ंक्शन सॉकेट से streambuf ऑब्जेक्ट तक पढ़ता है। अंतिम कार्य वैकल्पिक है। यदि यह है, तो यह प्रत्येक सफल रीड ऑपरेशन के बाद कहा जाता है और Boost.Asio को बताता है कि क्या ऑपरेशन पूरा हो गया है (यदि नहीं, तो यह पढ़ना जारी है)। इसका हस्ताक्षर इस प्रकार है: size_t completion(const boost::system::error_code & err, size_t bytes_transfered) पूरा होने पर, फ़ंक्शन 0 लौटाता है, मतलब अगर रीड ऑपरेशन पूरी तरह से पूरा हो गया है; यदि वे एक नॉनज़ेरो मान लौटाते हैं, तो इसका मतलब है कि read_some स्ट्रीम फ़ंक्शन की अगली कॉल के लिए अधिकतम बाइट्स read_some ।
• read_at(radom_stream, offset, buf [, completion_function]) : यह फ़ंक्शन एक यादृच्छिक स्ट्रीम से पढ़ता है। कृपया ध्यान दें कि यह सॉकेट्स पर लागू नहीं होता है (क्योंकि वे यादृच्छिक प्रवाह की अवधारणा को मॉडल नहीं करते हैं)।
• read_until(sock, buf, char | string | regex | match_condition) : यह फ़ंक्शन पढ़ता है जबकि यह स्थिति पूरी होती है। या तो एक निश्चित चरित्र को पढ़ा जाना चाहिए, या कुछ रेखा या नियमित अभिव्यक्ति एक पठन रेखा के साथ मेल match_condition , या match_condition फ़ंक्शन हमें बताएगा कि हमें फ़ंक्शन से बाहर निकलने की आवश्यकता है। match_condition function का हस्ताक्षर इस प्रकार है: match_conditionis pair<iterator,bool>match(iterator begin, iterator end) ; जहां मुख्य पुनरावर्तक buffers_iterator <streambuf::const_buffers_type> । यदि कोई मैच पाया जाता है, तो जोड़ी वापस आ जाएगी ( passed-end-of-match सेट टू true ), यदि कोई मैच नहीं मिला है, तो दूसरी जोड़ी वापस आ जाएगी ( begin false सेट)।
• write(sock, buf [, completion_function]) : यह फ़ंक्शन एक streambuf ऑब्जेक्ट के लिए सभी सामग्री लिखता है। समाप्ति फ़ंक्शन वैकल्पिक है और इसका व्यवहार समाप्त किए गए read() फ़ंक्शन के समान है: यह 0 वापस लौटता है जब लेखन ऑपरेशन पूरा हो जाता है या एक गैर-शून्य मान होता है जब अगले कॉल के दौरान लिखी जाने वाली बाइट्स की संख्या write_some स्ट्रीम फ़ंक्शन को write_some जाती write_some ।
• write_at(random_stream,offset, buf [, completion_function]) : यह फ़ंक्शन यादृच्छिक स्ट्रीम पर लिखता है। फिर से सॉकेट्स पर लागू नहीं होता है।
• async_read(sock, buf [, competion_function], handler) : read() फ़ंक्शन का यह एसिंक्रोनस डबल। प्रोसेसर हस्ताक्षर निम्नानुसार है: void handler(const boost::system::error_code, size_t bytes) ।
• async_read_at(radom_stream, offset, buf [, completion_function] ,handler) : यह read_at() फ़ंक्शन का एक एसिंक्रोनस डबल है।
• async_read_until (sock, buf, char | string | regex | match_condition, handler) : यह read_until() फ़ंक्शन का एसिंक्रोनस डबल है।
• async_write(sock, buf [, completion_function] , handler) : यह write() का अतुल्यकालिक डबल है write() फ़ंक्शन।
• async_write_at(random_stream,offset, buf [, completion_function], handler) : यह write_at() फ़ंक्शन का एक एसिंक्रोनस डबल है।

मान लीजिए कि आप एक स्वर तक पढ़ना चाहते हैं:

 streambuf buf; bool is_vowel(char c) { return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; } size_t read_complete(boost::system::error_code, size_t bytes) { const char * begin = buffer_cast<const char*>( buf.data()); if ( bytes == 0) return 1; while ( bytes > 0) { if ( is_vowel(*begin++)) return 0; else --bytes; } return 1; } ... read(sock, buf, read_complete); 

यदि आप, उदाहरण के लिए, नियमित अभिव्यक्ति का उपयोग करना चाहते हैं, तो यह बहुत सरल है:

 read_until(sock, buf, boost::regex("^[aeiou]+") ); 

या मुझे उदाहरण को थोड़ा संशोधित करने दें और आप कार्य करने के लिए match_condition function रख सकते हैं:

 streambuf buf; bool is_vowel(char c) { return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; } typedef buffers_iterator<streambuf::const_buffers_type> iterator; std::pair<iterator,bool> match_vowel(iterator b, iterator e) { while ( b != e) { if ( is_vowel(*b++)) return std::make_pair(b, true); } return std::make_pair(e, false); } ... size_t bytes = read_until(sock, buf, match_vowel); 

coroutine

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



पहले मामले में, सामान्य दृष्टिकोण प्रदर्शित किया जाता है। Coroutines का उपयोग करना, आप दूसरे मामले में जितना संभव हो उतना करीब हैं।
सीधे शब्दों में कहें, तो एक कोरटाइन आपको एक फ़ंक्शन के भीतर विशिष्ट स्थानों पर निष्पादन को रोकने और फिर से शुरू करने के लिए कई प्रवेश बिंदुओं का उपयोग करने की अनुमति देता है।
यदि आप coroutines का उपयोग करने जा रहे हैं, तो आपको दो हेडर फ़ाइलों को शामिल करना होगा, जिन्हें आप केवल boost/libs/asio/example/http/server4: yield.hpp में प्राप्त कर सकते हैं boost/libs/asio/example/http/server4: yield.hpp और coroutine.hpp । यहाँ Boost.Asio में, दो मैक्रोज़ और एक वर्ग को परिभाषित किया गया है:

• coroutine : यह वर्ग आपकी या व्युत्पन्न वर्ग की व्युत्पत्ति है जो आप coroutines को लागू करने के लिए उपयोग करते हैं।
• reenter(entry) : यह कोरटाइन बॉडी है। एक इनपुट तर्क एक सबरूटीन के लिए एक संकेतक है, उदाहरण के लिए, पूरे फ़ंक्शन के अंदर एक ब्लॉक के रूप में उपयोग किया जाना है।
• उपज कोड: एक कोरटाइन के हिस्से के रूप में निर्देशों को निष्पादित करता है।

बेहतर समझने के लिए, कुछ उदाहरणों पर विचार करें। हम अध्याय 4 से आवेदन को फिर से लागू करेंगे, जो एक सरल क्लाइंट है जो सिस्टम में प्रवेश करता है, जवाब देता है और आपको बता सकता है कि कौन से अन्य क्लाइंट लॉग इन हैं।
मुख्य कोड के समान है:

 class talk_to_svr : public boost::enable_shared_from_this<talk_to_svr> , public coroutine, boost::noncopyable { ... void step(const error_code & err = error_code(), size_t bytes = 0) { reenter(this) { for (;;) { yield async_write(sock_, write_buffer_, MEM_FN2(step,_1,_2) ); yield async_read_until( sock_, read_buffer_,"\n", MEM_ FN2(step,_1,_2)); yield service.post( MEM_FN(on_answer_from_server)); } } } }; 

पहली चीज़ जो बदल गई है वह यह है कि बड़ी संख्या में सदस्य फ़ंक्शन गायब हो गए हैं, जैसे कि connect(), on_connect(), on_read(),do_read(), on_write(), do_write() और इतने पर, अब हमारे पास एक फ़ंक्शन step() ।
फ़ंक्शन का शरीर reenter(this) { for (;;) { }} अंदर है reenter(this) { for (;;) { }} । आप reenter(this) बारे में सोच सकते हैं reenter(this) उस कोड के रूप में जिसे हमने पिछली बार निष्पादित किया था, ताकि हम अब निम्नलिखित कोड को लागू कर सकें।
reenter ब्लॉक के अंदर reenter आप कई चालू कॉल देख सकते हैं। पहली बार फ़ंक्शन लॉन्च किया गया है, async_write फ़ंक्शन async_write , दूसरी बार async_write फ़ंक्शन async_read_until , तीसरी बार service.post फ़ंक्शन, चौथी बार async_write फिर से और इसी तरह।
आपको for(;;) {}. उदाहरण के बारे में कभी नहीं भूलना चाहिए for(;;) {}. आइए निम्नलिखित कोड देखें:

 void step(const error_code & err = error_code(), size_t bytes = 0) { reenter(this) { yield async_write(sock_, write_buffer_, MEM_FN2(step,_1,_2) ); yield async_read_until( sock_, read_buffer_, "\n",MEM_FN2(step,_1,_2)); yield service.post( MEM_FN(on_answer_from_server)); } } 

यदि हमने तीसरी बार पिछले कोड के टुकड़े का उपयोग किया है, तो हम फ़ंक्शन में प्रवेश करेंगे और service.post निष्पादित करेंगे। चौथी बार, हम service.post पास करेंगे और कुछ नहीं करेंगे। पांचवीं बार और सभी निम्नलिखित के लिए एक ही बात होगी:

 class talk_to_svr : public boost::enable_shared_from_this<talk_to_svr> , public coroutine, boost::noncopyable { talk_to_svr(const std::string & username) : ... {} void start(ip::tcp::endpoint ep) { sock_.async_connect(ep, MEM_FN2(step,_1,0) ); } static ptr start(ip::tcp::endpoint ep, const std::string & username) { ptr new_(new talk_to_svr(username)); new_->start(ep); return new_; } void step(const error_code & err = error_code(), size_t bytes = 0) { reenter(this) { for (;;) { if ( !started_) { started_ = true; std::ostream out(&write_buf_); out << "login " << username_ << "\n"; } yield async_write(sock_, write_buf_, MEM_FN2(step,_1,_2) ); yield async_read_until( sock_,read_buf_,"\n", MEM_FN2(step,_1,_2)); yield service.post( MEM_FN(on_answer_from_server)); } } } void on_answer_from_server() { std::istream in(&read_buf_); std::string word; in >> word; if ( word == "login") on_login(); else if ( word == "ping") on_ping(); else if ( word == "clients") on_clients(); read_buf_.consume( read_buf_.size()); if (write_buf_.size() > 0) service.post( MEM_FN2(step,error_code(),0)); } ... private: ip::tcp::socket sock_; streambuf read_buf_, write_buf_; bool started_; std::string username_; deadline_timer timer_; }; 

जब हम कनेक्शन शुरू करते हैं, तो start() फ़ंक्शन को कहा जाता है, जो सर्वर से अतुल्यकालिक रूप से कनेक्ट होता है। जब कनेक्शन स्थापित होता है, तो हम पहली बार step() दर्ज करते हैं। यह तब है जब हम अपने उपयोगकर्ता नाम के साथ एक संदेश भेजते हैं।
इसके बाद हम async_write उपयोग async_write , फिर async_write और संदेश को संसाधित करते हैं ( on_answer_from_server )।
on_answer_from_server फ़ंक्शन में on_answer_from_server हम आने वाले संदेशों को संसाधित करते हैं; हम पहला शब्द पढ़ते हैं और इसे संबंधित फ़ंक्शन पर निर्देशित करते हैं, और हम शेष संदेश (किसी भी स्थिति में) को अनदेखा करते हैं:

 class talk_to_svr : ... { ... void on_login() { do_ask_clients(); } void on_ping() { std::istream in(&read_buf_); std::string answer; in >> answer; if ( answer == "client_list_changed") do_ask_clients(); else postpone_ping(); } void on_clients() { std::ostringstream clients; clients << &read_buf_; std::cout << username_ << ", new client list:" << clients. str(); postpone_ping(); } void do_ping() { std::ostream out(&write_buf_); out << "ping\n"; service.post( MEM_FN2(step,error_code(),0)); } void postpone_ping() { timer_.expires_from_now(boost::posix_time::millisec(rand() % 7000)); timer_.async_wait( MEM_FN(do_ping)); } void do_ask_clients() { std::ostream out(&write_buf_); out << "ask_clients\n"; } }; 

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

 int main(int argc, char* argv[]) { ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 8001); talk_to_svr::start(ep, "John"); service.run(); } 

कोरआउट्स का उपयोग करते हुए हमने कोड को 15 लाइनों तक कम कर दिया, और यह भी अधिक पठनीय बन गया। यहाँ हमने मुश्किल से कॉरआउट के विषय को छुआ। यदि आप इस मुद्दे पर अधिक जानकारी चाहते हैं, तो आप इस पृष्ठ पर जा सकते हैं।

सारांश

हमने देखा कि कितनी आसानी से Boost.Asio STL धाराओं और स्ट्रीमब्यूफ ऑब्जेक्ट्स के साथ काम करता है। हमने यह भी देखा कि कैसे कॉरआउट हमारे कोड को अधिक कॉम्पैक्ट बनाते हैं और इसकी समझ को सुविधाजनक बनाते हैं।
अगले अध्याय में, हम Asio बनाम Boost.Asio, प्रगतिशील डिबगिंग, SSL और साथ ही कुछ अन्य प्लेटफ़ॉर्म-विशिष्ट सुविधाओं जैसे विषयों को कवर करेंगे।

इस लेख के लिए संसाधन: लिंक

ध्यान देने के लिए आप सभी का धन्यवाद, जल्द ही मिलते हैं!