😏 👩 🤶 वयस्कों के लिए बूलिंक के अंदर ➿ ☹️ 🔃

यह लेख उन लोगों के लिए है जो मेरी पिछली पोस्ट से बूलिनक लाइब्रेरी के कार्यान्वयन में रुचि रखते हैं। इस लेख में मैं स्रोत में खुदाई करूंगा और कुछ दिलचस्प ट्रिक्स दिखाऊंगा जिससे लाइब्रेरी "आलसी" और विलुप्त हो गई।

इसमें गलत क्या है?

इससे पहले कि हम लाइब्रेरी कोड देखें, मैं आपका ध्यान STL की ओर आकर्षित करना चाहूंगा। यह एक मानक टेम्पलेट लाइब्रेरी है, जिसमें कंटेनर, एल्गोरिदम आदि शामिल हैं। पुस्तकालय के सबसे दिलचस्प तत्वों में से एक एक इकाई है - एक पुनरावृत्त । कंटेनरों और एल्गोरिदम के बीच एक परत होने के लिए Iterators का आविष्कार किया गया था। ताकि किसी भी कंटेनर (किसी भी, लगभग किसी भी) के लिए किसी भी एल्गोरिदम को लागू किया जा सके।

पहली नज़र में, सब कुछ ठीक है। एल्गोरिदम और कंटेनर एक मध्यवर्ती इकाई के माध्यम से जुड़े हुए हैं - एक पुनरावृत्त। लेकिन यह केवल पहली नज़र में है, यदि आप कोड को करीब से देखते हैं:

int sum = 0; for (std::vector<int>::iterator it = candles.begin(); it != candles.end(); it++) sum += it->ClosePrice;

एसटीएल पुनरावृत्तियों की एक खामी है जो पहली नज़र में ध्यान देने योग्य नहीं हैं, जावा पुनरावृत्तियों में इस शून्य की कमी है।

 int sum = 0; Iterator it = al.iterator(); while (it.hasNext()) { it = it.next(); sum += it.ClosePrice; }

हां, ये .begin() और .end() एक ही इकाई के दो भाग हैं। यदि इन दो भागों को एक इकाई में ले लिया गया और संयुक्त कर दिया गया ... यह कहा गया - (विचार "एटरेटर्स मस्ट गो" की प्रस्तुति से अलेक्जेंड्रेस्कु से उधार लिया गया था):

 template<typename TIter> class IterRange { public: typedef typename std::iterator_traits<TIter>::value_type value_type; IterRange(TIter b, TIter e) : b(b), e(e) { } bool empty() { return (b == e); } value_type popFront() { assert(!empty()); return *(b++); } value_type popBack() { assert(!empty()); return *(--e); } value_type front() { assert(!empty()); return *b; } value_type back() { assert(!empty()); TIter tmp = e; return *(--tmp); } private: TIter b; TIter e; };

इस प्रकार, हमारे पास एक इकाई है, हम पूछ सकते हैं कि क्या अनुक्रम में अधिक तत्व हैं, एक तत्व का अनुरोध करें और अगले तत्व पर जाने का अनुरोध करें। वास्तव में, back() और popBack() विधियों को भी popBack() नहीं popBack() ।

ठीक है, फिर यह अनुमान लगाना मुश्किल नहीं है कि सभी पुस्तकालय कक्षाएं कैसे दिखती हैं - ये इस तरह की रेंज पर रैपर हैं। उदाहरण के लिए, जहाँरंग इस तरह दिखता है:

 template<typename R, typename F> class WhereRange { public: typedef typename R::value_type value_type; WhereRange(R r, F f) : r(r), f(f) , frontReady(false) , backReady(false) { } bool empty() { if (!frontReady) seekFront(); return r.empty(); } value_type popFront() { if (!frontReady) seekFront(); auto tmp = *this; r.popFront(); frontReady = false; return tmp.front(); } value_type popBack() { //  } value_type front() { if (!frontReady) seekFront(); return r.front(); } value_type back() { //  } private: void seekFront() { while(!r.empty() && !f(r.front())) r.popFront(); frontReady = true; } void seekBack() { //  } private: R r; F f; bool frontReady; bool backReady; };

संक्षेप में: क्लास कंस्ट्रक्टर में एक और रेंज लेता है, जिसमें से उसे एलीमेंट लेने पड़ते हैं, और एक प्रेडिक्ट होता है जो यह निर्धारित करता है कि प्रत्येक एलिमेंट सेलेक्ट हुआ है या नहीं। 2 चर हैं जो यह निर्धारित करते हैं कि क्या एक मान "शुरुआत से" और "एक सीमा के अंत से" है। सीकफ्रंट () और सीकबैक () फ़ंक्शंस सीधे अगले मोर्चे और अगले बैक की खोज करते हैं।

वास्तव में, अन्य सभी रेंज समान दिखते हैं। अगली समस्या डॉट नोटेशन के उपयोग को कम करने की थी ...

मुझे एक प्वाइंट नोटेशन चाहिए

एक ओर, मैं विधियों का उपयोग उसी तरह करना चाहता था जैसे कि वे .NET LINQ में उपयोग किए जाते हैं, लेकिन C ++ में C #: की तरह विस्तार विधियाँ नहीं हैं।

 int max = arr.Where(...).OrderBy(...).Select(...).Max();

दूसरी तरफ, मैं पुस्तकालय को विस्तार योग्य बनाना चाहता था ... और यहाँ मुझे यह विचार मिला)) सभी श्रेणी के शीर्ष पर लाइनक वर्ग को लपेटा जाएगा, जब आप अनुक्रम को परिवर्तित करने वाले तरीकों को कॉल करेंगे, तो लाइनक में संलग्न वर्ग को लपेटा जाएगा, और लाइनक वर्ग सभी के शीर्ष पर रहेगा।

प्रत्येक वर्ग के लिए, रेंज ने मिक्सिंग रैपिंग क्लास में निम्न कार्य किया:

 template<template<typename> class TLinq, typename R> class WhereRange_mixin { public: template<typename F> TLinq<WhereRange<R,F> > where(F f) const { return boolinq::where(((TLinq<R>*)this)->r,f); } };

फिर, मुझे सभी आवश्यक मिक्सिन से लाइनक वर्ग विरासत में मिला:

 template<typename R> class Linq : public SkipRange_mixin<Linq,R> , public TakeRange_mixin<Linq,R> , public WhereRange_mixin<Linq,R> , public SelectRange_mixin<Linq,R> , public ReverseRange_mixin<Linq,R> , public OrderByRange_mixin<Linq,R> // ...   ... { public: typedef typename R::value_type value_type; Linq(const R & r) : r(r) { } bool empty() { return r.empty(); } value_type popFront() { return r.popFront(); } value_type popBack() { return r.popBack(); } value_type front() { return r.front(); } value_type back() { return r.back(); } public: R r; };

तत्व तत्व उलटा

मैं इस सुविधा पर अलग से ध्यान देना चाहता था। यह उल्लेखनीय है कि मैं वास्तव में एक डबल रिवर्स अनुक्रम नाखून करना चाहता था। और एक संकलन त्रुटि नहीं, बल्कि एक अच्छे तरीके से हरा करने के लिए। वर्ग कोड बहुत सरल है:

 template<typename R> class ReverseRange { public: typedef typename R::value_type value_type; ReverseRange(R r) : r(r) { } bool empty() { return r.empty(); } value_type popFront() { return r.popBack(); } value_type popBack() { return r.popFront(); } value_type front() { return r.back(); } value_type back() { return r.front(); } template<typename R2> friend R2 reverse(ReverseRange<R2> r); // smart needed private: R r; };

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

 template<typename R> ReverseRange<R> reverse(R r) { return r; } // Unwrap for double-reverse case template<typename R> R reverse(ReverseRange<R> r) { return rr; // smart }

हाँ! फ़ंक्शन एक नहीं है - उनमें से दो हैं। पहला काम यह करना चाहिए - यह हमारे ReaverseRange के साथ रेंज को लपेटता है (एक अंतर्निहित निर्माता कॉल है)। दूसरा, इसके विपरीत, ReverseRange को चित्रित करता है। यह महत्वपूर्ण है कि यह संकलन स्तर पर होता है, न कि रन टाइम पर। लेकिन यह सबसे मुश्किल नहीं है - नरक तब शुरू हुआ जब मैंने मिक्सिन में इसे चित्रित करने की कोशिश की:

 template<template<typename> class TLinq, typename R> class ReverseRange_mixin { public: TLinq<ReverseRange<R> > reverse() const { return boolinq::reverse(((TLinq<R>*)this)->r); } }; // Unwrap for double-reverse case template<template<typename> class TLinq, typename T> class ReverseRange_mixin<TLinq,ReverseRange<T> > { public: TLinq<T> reverse() const { return boolinq::reverse(((TLinq<ReverseRange<T> >*)this)->r); } };

फिर से, पहला मिक्सिन असामान्य कुछ भी नहीं करता है, लेकिन संकलन चरण में दूसरा Linq<ReverseRange<XxxRange<...>>> प्रकार का पता लगाता है और इसे Linq<XxxRange<...>> । संकलित कोड प्राप्त करते समय मस्तिष्क टूट गया।

एक उपयोगकर्ता एक पुस्तकालय का विस्तार कैसे कर सकता है?

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

 boolinq::from<CustomLinq>(arr)

इसके बजाय:

 boolinq::from(arr)

खैर, उपयोगकर्ता इस सब के बिना कर सकते हैं और डॉट नोटेशन का उपयोग बिल्कुल नहीं करते हैं। आखिरकार, आप इस तरह कोड लिख सकते हैं:

 using namespace boolinq; int sum = sum(select(where(from(arr), [](...){...}), [](...){...}));

प्रदर्शन परीक्षण

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

1. हम 100 मिलियन छद्म यादृच्छिक तत्व उत्पन्न करते हैं:

 srand(0xDEADBEEF); std::vector<int> vec(100000000, 0); for (unsigned i = 0; i < vec.size(); i++) vec[i] = rand();

2. हम C ++ में एक एल्गोरिथ्म लिखते हैं

 //      double sum = 0; int count = 0; for (unsigned i = 0; i < vec.size(); i++) { if (vec[i] % 2 == 1) { sum += vec[i]; count++; } } double avgValue = sum / count; //       avgValue double disperSum = 0; for (unsigned i = 0; i < vec.size(); i++) if (vec[i] % 2 == 1) disperSum += (vec[i] - avgValue)*(vec[i] - avgValue); double disper = disperSum / count;

3. हम एल्गोरिथ्म को बूलिनक पर लिखेंगे

 //      double avgValue = from(vec).where( [](int a){return a%2 == 1;}) .cast<double>() .avg(); //       avgValue double disper = from(vec).where( [](int a){return a%2 == 1;}) .select([=](int a){return (a-avgValue)*(a-avgValue);}) .cast<double>() .avg();

यह मत देखो कि C ++ कोड पुनरावृत्तियों का उपयोग नहीं करता है। मैंने पुनरावृत्तियों के साथ कोड लिखा था, लेकिन मुझे इसे बिछाने नहीं दिया - यह बिल्कुल वैसा ही है। अब MS Visual C ++ 2010 में रिलीज़ को संकलित करें और मेरी मशीन पर चलाएँ ...

C ++ कोड	1207 मि
सी ++ कोड के साथ पुनरावृत्तियों	1224 मि
बूलिनक कोड	1564 मि

बेशक, बूलिनक थोड़ा खो देता है (एक तिहाई से) - लेकिन फिर से यह कार्यों पर निर्भर करता है। सिद्धांत रूप में, आपको सभी तरीकों का अलग-अलग परीक्षण करने की आवश्यकता है। वैसे, .NET LINQ अपने समकक्षों को बहुत अधिक, बहुत मजबूत चक्रों में खो देता है।

निकट भविष्य में इसे एसटीएल के साथ पिछड़े संगतता के लिए .begin() और .end() तरीके को Linq वर्ग में जोड़ने की योजना है।

वयस्कों के लिए बूलिंक के अंदर

इसमें गलत क्या है?

मुझे एक प्वाइंट नोटेशन चाहिए

तत्व तत्व उलटा

एक उपयोगकर्ता एक पुस्तकालय का विस्तार कैसे कर सकता है?

प्रदर्शन परीक्षण

More articles: