अंतराल: आगामी सी ++ विकास

सी ++ 20 मानक जल्द ही दिखाई देगा, जो कि श्रेणियों की अवधारणा को जोड़ने की संभावना है, लेकिन कुछ लोग जानते हैं कि वे क्या हैं और वे क्या खाते हैं। मुझे इस जानवर के बारे में सुलभ रूसी-भाषी स्रोत नहीं मिले, यही कारण है कि इस लेख में मैं आपको इसके बारे में और अधिक बताना चाहूंगा, जो कि Arno Schödl के एक व्याख्यान "Iterators से लेकर Ranges: The Upcoming Evolution of the STL" सम्मेलन की बैठक C ++ 2015 तक है। वर्ष का। मैं इस लेख को यथासंभव उन लोगों के लिए स्पष्ट करने का प्रयास करूंगा जो पहले इस अवधारणा का सामना करते हैं, और साथ ही मैं उन सभी प्रकार के चिप्स के बारे में बात करूंगा जो उन लोगों के लिए अंतराल एडेप्टर हैं जो पहले से ही इस अवधारणा से परिचित हैं और अधिक जानना चाहते हैं।

रेंज के साथ पुस्तकालय

इस लेखन के समय, तीन मुख्य पुस्तकालय हैं जो अंतराल को लागू करते हैं:

• Boost.Range
• रेंज v3
• थिंक-सेल पब्लिक लाइब्रेरी

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

क्यों अंतराल हमारे भविष्य है?

उन लोगों के लिए जो एक अंतराल की अवधारणा से परिचित नहीं हैं, हम इस गैर-तुच्छ अवधारणा को उस रूप में परिभाषित करते हैं जिसमें एक शुरुआत और एक अंत ( पुनरावृत्तियों की एक जोड़ी ) है।

आइए अब निम्नलिखित कार्य पर विचार करें: एक वेक्टर है, इसमें से सभी दोहराए जाने वाले तत्वों को निकालना आवश्यक है। वर्तमान मानक के तहत, हम इसे इस तरह हल करेंगे:

std::vector<T> vec=...; std::sort( vec.begin(), vec.end() ); vec.erase( std::unique( vec.begin(), vec.end() ), vec.end() ); 

इस मामले में, हम वेक्टर के नाम को 6 बार के रूप में इंगित करते हैं! हालांकि, अंतराल की अवधारणा का उपयोग करते हुए (वेक्टर को एक वस्तु में शुरुआत और अंत में संयोजन करना), हम केवल एक बार वांछित वेक्टर को निर्दिष्ट करके कई बार आसान लिख सकते हैं:

 tc::unique_inplace( tc::sort(vec) ); 

वर्तमान में कौन से अंतराल वर्तमान मानक के भीतर हैं?

C ++ 11 मानक में, कंटेनरों की शुरुआत / अंत में लूप और सार्वभौमिक पहुंच के लिए एक श्रेणी-आधारित जोड़ा गया था, और नवीनतम C ++ 17 मानक में, अंतराल से संबंधित कुछ भी नया नहीं जोड़ा गया था।

 for ( int& i : <range_expression> ) { ... } 

 std::begin/end(<range_expression>) 

भविष्य के अंतराल

आइए अब पहले उल्लिखित रेंज V3 लाइब्रेरी पर ध्यान दें। एरिक निबलर, इसके निर्माता, के रूप में अपने घर परियोजना ने रेंज की तकनीकी विशिष्टता बनाई, अंतराल का समर्थन करने के लिए एल्गोरिथ्म लाइब्रेरी को संशोधित किया। यह कुछ इस तरह दिखता है:

 namespace ranges { template< typename Rng, typename What > decltype(auto) find( Rng && rng, What const& what ) { return std::find( ranges::begin(rng), ranges::end(rng), what ); } } 

उसकी साइट पर कुछ पूर्वावलोकन है कि वह क्या मानकीकरण करना चाहता है, यह रेंज V3 है ।

रेंज को क्या माना जा सकता है?

सबसे पहले, कंटेनर (वेक्टर, स्ट्रिंग, सूची आदि), क्योंकि उनके पास एक शुरुआत और एक अंत है। यह स्पष्ट है कि कंटेनरों के अपने तत्व होते हैं, अर्थात जब हम कंटेनरों का उल्लेख करते हैं, तो हम उनके सभी तत्वों का उल्लेख करते हैं। इसी तरह, जब एक निरंतर (गहरी नकल और स्थिरता) की नकल और घोषणा की जाती है। दूसरे, विचारों को अंतराल भी माना जा सकता है। दृश्य क्रमशः शुरुआत और अंत की ओर इशारा करते हुए पुनरावृत्तियों की एक जोड़ी है। यहाँ उनका सरलतम कार्यान्वयन है:

 template<typename It> struct iterator_range { It m_itBegin; It m_itEnd; It begin() const { return m_itBegin; } It end() const { return m_itEnd; } }; 

दृश्य, बदले में, केवल तत्वों को संदर्भित करते हैं, इसलिए प्रतिलिपि बनाना और संगति आलसी है (यह तत्वों को प्रभावित नहीं करता है)।

अंतराल एडेप्टर

अंतराल के आविष्कारक इस पर नहीं रुके, क्योंकि अन्यथा यह अवधारणा बेकार हो जाती। इसलिए, उन्होंने इस तरह की अवधारणा को रेंज एडेप्टर के रूप में पेश किया।

एडॉप्टर एडॉप्टर

निम्नलिखित कार्य पर विचार करें: एक इंट वेक्टर दिया जाना चाहिए, जिसमें हमें 4 के बराबर पहला तत्व खोजने की आवश्यकता है:

 std::vector<int> v; auto it = ranges::find(v, 4); 

अब आइए कल्पना करें कि वेक्टर का प्रकार int नहीं है, लेकिन कुछ प्रकार की जटिल स्व-लिखित संरचना है, लेकिन जिसमें एक int है, और कार्य अभी भी समान है:

 struct A { int id; double data; }; std::vector<A> v={...}; auto it = ranges::find_if( v, [](A const& a) { return a.id == 4; } ); 

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

 struct A { int id; double data; }; std::vector<A> v={...}; auto it = ranges::find( tc::transform(v, std::mem_fn(&A::id)), 4); 

वास्तव में, ट्रांसफ़ॉर्मिंग एडेप्टर, इंट फील्ड के चारों ओर एक रैपर क्लास बनाकर हमारी संरचना को "रूपांतरित" करता है। यह स्पष्ट है कि सूचक आईडी फ़ील्ड को इंगित करता है, लेकिन अगर हम चाहते थे कि यह पूरी संरचना को इंगित करे, तो हमें tobase () के अंत में जोड़ना होगा । यह कमांड फ़ील्ड को एनकैप कर देता है, जिसकी वजह से पॉइंटर पूरे स्ट्रक्चर से चल सकता है:

 auto it = ranges::find( tc::transform(v, std::mem_fn(&A::id)), 4).base(); 

यहां एक ट्रांसफ़ॉर्म एडॉप्टर का एक उदाहरण कार्यान्वयन है (इसमें पुनरावृत्तियों शामिल हैं, जिनमें से प्रत्येक का अपना फ़नकार है):

 template<typename Base, typename Func> struct transform_range { struct iterator { private: Func m_func; //    decltype( tc::begin(std::declval<Base&>()) ) m_it; public: decltype(auto) operator*() const { return m_func(*m_it); } decltype(auto) base() const { return (m_it); } ... }; }; 

फ़िल्टर एडाप्टर

और अगर अंतिम कार्य में हमें पहले ऐसे तत्व को खोजने की आवश्यकता है, लेकिन ऐसे तत्वों की उपस्थिति के लिए int के पूरे क्षेत्र को "फ़िल्टर" करें? इस स्थिति में, हम एक फ़िल्टर एडेप्टर का उपयोग करेंगे:

 tc::filter( v, [](A const& a) { return 4 == a.id; } ); 

ध्यान दें कि फ़िल्टर को पुनरावृत्तियों के दौरान निष्पादित किया गया है।

और यहाँ उसका भोली कार्यान्वयन है (कुछ ऐसा ही Boost.Range में लागू किया गया है):

 template<typename Base, typename Func> struct filter_range { struct iterator { private: Func m_func; //     decltype( ranges::begin(std::declval<Base&>()) ) m_it; decltype( ranges::begin(std::declval<Base&>()) ) m_itEnd; public: iterator& operator++() { ++m_it; while( m_it != m_itEnd && !static_cast<bool>(m_func(*m_it)) ) ++m_it; return *this; } ... }; }; 

जैसा कि हम देख सकते हैं, एक के बजाय दो पुनरावृत्तियों की आवश्यकता है, क्योंकि यह ट्रांसफ़ॉर्म एडाप्टर में था। पुनरावृत्तियों के दौरान कंटेनर की सीमाओं से आगे नहीं जाने के लिए दूसरा पुनरावृत्ति आवश्यक है।

कुछ अनुकूलन

ठीक है, लेकिन क्या itter tc से दिखता है :: फ़िल्टर (tc :: filter (tc :: filter) (...)) ?

Boost.Range

उपरोक्त कार्यान्वयन के भाग के रूप में, यह इस तरह दिखता है:


जाहिर है, यह बहुत अक्षम है।

रेंज v3

आइए इस एडेप्टर को कैसे अनुकूलित करें, इसके बारे में सोचें। एरिक निबलर का विचार एडॉप्टर ऑब्जेक्ट में सामान्य जानकारी (अंत में एक फ़ंक्टर और एक पॉइंटर) डालना था, और फिर हम इस एडेप्टर ऑब्जेक्ट और वांछित इटिटर के लिए एक लिंक स्टोर कर सकते हैं
*m_rng
m_it

फिर, ऐसे कार्यान्वयन के ढांचे में, ट्रिपल फ़िल्टर कुछ इस तरह दिखाई देगा:


यह अभी भी सही नहीं है, हालांकि पिछले कार्यान्वयन की तुलना में कई गुना तेज है।

थिंक-सेल, इंडेक्स कॉन्सेप्ट

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

 template<typename Base, typename Func> struct index_range { ... using Index = ...; Index begin_index() const; Index end_index() const; void increment_index( Index& idx ) const; void decrement_index( Index& idx ) const; reference dereference( Index& idx ) const; ... }; 

हम दिखाते हैं कि एक नियमित पुनरावृत्ति के साथ सूचकांक को कैसे संयोजित किया जाए।

यह स्पष्ट है कि एक नियमित पुनरावृत्ति सूचकांक भी माना जा सकता है। विपरीत दिशा में, संगतता को लागू किया जा सकता है, उदाहरण के लिए, निम्नानुसार है:

 template<typename IndexRng> struct iterator_for_index { IndexRng* m_rng; typename IndexRng::Index m_idx; iterator& operator++() { m_rng.increment_index(m_idx); return *this; } ... }; 

फिर ट्रिपल फिल्टर को सुपर-कुशलता से लागू किया जाएगा:

 template<typename Base, typename Func> struct filter_range { Func m_func; Base& m_base; using Index = typename Base::Index; void increment_index( Index& idx ) const { do { m_base.increment_index(idx); } while ( idx != m_base.end_index() && !m_func(m_base.dereference_index(idx)) ); } }; 

 template<typename IndexRng> struct iterator_for_index { IndexRng* m_rng; typename IndexRng::Index m_idx; ... }; 

इस तरह के कार्यान्वयन के ढांचे में, फिल्टर की गहराई की परवाह किए बिना एल्गोरिथ्म जल्दी से काम करेगा।

अंतराल और अंतराल कंटेनर के साथ अंतराल

अब देखते हैं कि अंतराल अंतराल और रेल्वे कंटेनर के साथ कैसे काम करता है:

lvalue

रेंज V3 और थिंक-सेल लैवल्यू के साथ ऐसा ही व्यवहार करते हैं। मान लीजिए कि हमारे पास इस तरह का कोड है:

 auto rng = view::filter(vec, pred1); bool b = ranges::any_of(rng, pred2); 

यहां हमारे पास पहले से घोषित वेक्टर है जो मेमोरी (अंतराल) में निहित है, और हमें एक अंतराल बनाने और फिर किसी तरह इसके साथ काम करने की आवश्यकता है। हम दृश्य :: फ़िल्टर या टीसी :: फ़िल्टर का उपयोग करके एक दृश्य बनाते हैं और खुश हो जाते हैं, कोई त्रुटि नहीं है, और हम इस दृश्य का उपयोग कर सकते हैं, उदाहरण के लिए, any_of में।

रेंज V3 और rvalue

हालाँकि, यदि हमारा वेक्टर अभी तक मेमोरी में नहीं था (उदाहरण के लिए, यदि हम इसे बना रहे थे), और हमने एक ही कार्य का सामना किया होगा, तो हम लिखने का प्रयास करेंगे और एक त्रुटि के साथ सामना करेंगे:

 auto rng = view::filter(create_vector(), pred1); //   bool b = ranges::any_of(rng, pred2); 

क्यों उत्पन्न हुई? इस तथ्य के कारण कि हम एक वेक्टर बनाते हैं और सीधे इसे एक फ़िल्टर में डालते हैं, यानि फ़िल्टर में एक लिंक लिंक होगा, जो फ़िल्टर में एक rvalue लिंक होगा, जो तब किसी अज्ञात चीज़ को इंगित करेगा जब कंपाइलर अगली पंक्ति में जाता है और एक त्रुटि उत्पन्न होती है। इस समस्या को हल करने के लिए, रेंज V3 कार्रवाई के साथ आया:

 auto rng = action::filter(create_vector(), pred1); //   bool b = ranges::any_of(rng, pred2); 

कार्रवाई एक ही बार में सब कुछ करती है, अर्थात, यह बस एक वेक्टर लेता है, विधेय से फ़िल्टर करता है और एक अंतराल में डालता है। हालांकि, माइनस यह है कि यह अब आलसी नहीं है, और थिंक-सेल ने इस माइनस को ठीक करने की कोशिश की।

थिंक-सेल और प्रतिद्वंद्विता

थिंक-सेल ने इसे बनाया ताकि देखने के बजाय एक कंटेनर बनाया जाए:

 auto rng = tc::filter(creates_vector(), pred1); bool b = ranges::any_of(rng, pred2); 

नतीजतन, हम एक समान त्रुटि का सामना नहीं करते हैं, क्योंकि उनके कार्यान्वयन में फ़िल्टर लिंक के बजाय rvalue कंटेनर एकत्र करता है, इसलिए यह आलसी होता है। रेंज V3 ऐसा नहीं करना चाहता था क्योंकि उन्हें डर था कि फिल्टर के कारण या तो एक दृश्य के रूप में या कंटेनर के रूप में व्यवहार करने के कारण त्रुटियां होंगी, हालांकि थिंक-सेल आश्वस्त हैं कि प्रोग्रामर समझते हैं कि फ़िल्टर कैसे व्यवहार करता है, और इस "आलस्य" के कारण अधिकांश त्रुटियां ठीक होती हैं।

जेनरेटर अंतराल

हम अंतराल की अवधारणा को सामान्य करते हैं। वास्तव में, पुनरावृत्तियों के बिना अंतराल हैं। उन्हें जनरेटर रेंज कहा जाता है । मान लीजिए हमारे पास एक GUI विजेट (एक इंटरफ़ेस तत्व) है और हम एक चाल विजेट कहते हैं। हमारे पास एक विंडो है जो अपने विजेट को स्थानांतरित करने के लिए कहती है, हमारे पास सूची बॉक्स में एक बटन भी है, और एक अन्य विंडो को भी अपने विजेट के माध्यम से स्क्रॉल करना चाहिए, अर्थात, हम traverse_widgets कहते हैं , जो तत्वों को एक फ़नकार से जोड़ता है ( आप कह सकते हैं कि एक एन्यूमरेशन फ़ंक्शन है जहां आप फ़नकार को कनेक्ट करें, और फ़ंक्शन उन सभी तत्वों को सूचीबद्ध करता है जो इस फ़नकार में हैं )।

 template<typename Func> void traverse_widgets( Func func ) { if (window1) { window1->traverse_widgets(std::ref(func)); } func(button1); func(listbox1); if (window2) { window2->traverse_widgets(std::ref(func)); } } 

यह कुछ हद तक विजेट स्पेसिंग की याद दिलाता है, लेकिन यहां कोई पुनरावृत्त नहीं हैं। उन्हें सीधे लिखना अक्षम और सब से ऊपर, बहुत मुश्किल होगा। इस मामले में, हम कह सकते हैं कि ऐसी संरचनाओं को भी अंतराल माना जाता है। फिर ऐसे मामलों के लिए उपयोगी अंतराल विधियों का उपयोग होता है, जैसे कि any_of :

 mouse_hit_any_widget=tc::any_of( [] (auto func) { traverse_widgets(func); }, [] (auto const& widget) { return widget.mouse_hit(); } ); 

थिंक-सेल तरीकों को लागू करने की कोशिश करता है ताकि उनके पास सभी प्रकार के अंतराल के लिए एक ही इंटरफ़ेस हो:

 namespace tc { template< typename Rng > bool any_of( Rng const& rng ) { bool bResult = false; tc::enumerate( rng, [&](bool_context b) { bResult = bResult || b; } ); return bResult; } } 

Tc :: enumerate का उपयोग करते हुए, अंतराल के बीच का अंतर छिपा हुआ है, क्योंकि ऐसा कार्यान्वयन आंतरिक पुनरावृत्ति की अवधारणा का पालन करता है (व्याख्यान में बाहरी और आंतरिक पुनरावृत्ति की अवधारणाओं को अधिक विस्तार से वर्णित किया गया है), हालांकि, यह कार्यान्वयन इसकी कमियां हैं, अर्थात् std :: any_of जैसे ही सच होता है, रुक जाता है। वे इस समस्या को हल करने की कोशिश करते हैं, उदाहरण के लिए, अपवाद (तथाकथित बाधित जनरेटर अंतराल ) को जोड़कर।

निष्कर्ष

मैं लूप के लिए रेंज-आधारित से नफरत करता हूं क्योंकि यह लोगों को इसे लिखने के लिए प्रेरित करता है जहां जरूरत होती है और जहां जरूरत नहीं होती है, इस कारण कोड की संगति अक्सर खराब हो जाती है, उदाहरण के लिए, लोग इसे लिखते हैं:

 bool b = false; for (int n : rng) { if ( is_prime(n) ) { b = true; break; } } 

बजाय:

 bool b = tc::any_of( rng, is_prime );