👐🏼 🕘 👩🏻‍🤝‍👨🏼 C ++ के लिए एक और Linq 👉🏾 🐛 👩‍🏭

परिचय

लंबे ब्रेक के बाद, मुझे C ++ प्रोग्रामिंग पर लौटना पड़ा। C # के बाद, var कीवर्ड और linq क्वेरीज़ बनाने की क्षमता में कमी थी। हालाँकि, जैसा कि यह निकला, प्रगति अभी भी स्थिर नहीं है और मेरी अनुपस्थिति के दौरान C ++ 11 का एक नया संस्करण जारी किया गया था, जिसमें नई दिलचस्प विशेषताएं हैं, इसके अलावा, यह अधिकांश संकलक में लागू किया गया है। मैं एक क्रॉस-प्लेटफॉर्म प्रोजेक्ट में शामिल था और मुझे लिनक्स, विजुअल स्टूडियो और विंडोज की दुनिया के लिए मिंगव के लिए जीसीसी कंपाइलर में दिलचस्पी थी। एक लाइनेक जैसी लाइब्रेरी को खोजने की कोशिश असफल रही, मैंने पाया कि मेरे घुटने पर एक गैर-व्यवहार्य शिल्प था। इस्तीफा दे दिया, मैंने खोज करना छोड़ दिया, लेकिन अप्रैल 2012 में, C ++ में ऑब्जेक्ट्स लेख के लिए एक उत्साहजनक LINQ जारी किया गया था, जिसमें एक पुस्तकालय का वर्णन किया गया था जो मुझे अनुकूल था। अभ्यास में इसे आज़माकर और इसकी डिवाइस को छांटकर, मैं अक्षमता से निराश था, लेकिन मैं कुछ विचारों के साथ आया। केवल एक ही चीज़ बची थी - एक ही लिखने के लिए, केवल लाठी के साथ, जिसे मैंने github.com/drbasic/CppLinq में किया था, उसी समय स्वचालित प्रकार की निष्कासन (ऑटो) और लैम्ब्डा अभिव्यक्तियों को छांटना।

पुस्तकालय को इस तरह से डिज़ाइन किया गया था कि धाराप्रवाह-वाक्यविन्यास और लैम्ब्डा अभिव्यक्ति की मदद से, उपयोगकर्ता एक परिवर्तन ग्राफ बना सकता है। इन ग्राफ को कॉपी, पूरा, संयुक्त किया जा सकता है, अर्थात सी # दुनिया से ऑब्जेक्ट्स प्रोटोटाइप के लिए लाइनक के जितना संभव हो उतना व्यवहार लागू करें। लाइब्रेरी कार्यक्षमता, दो बार बिना सोचे-समझे, मैंने C # से उधार लिया, एक स्पष्ट लेफ्ट जॉइन और फुल जॉइन को जोड़ा। लाइब्रेरी की एक महत्वपूर्ण सीमा रूपांतरण ग्राफ़ के साथ प्रतिलिपि की नहीं, बल्कि मूल अनुक्रम के तत्वों की ओर जा रही है। यह आपको संग्रह के जटिल तत्वों से प्रभावी ढंग से निपटने की अनुमति देता है, क्योंकि अब नकल के लिए कोई ओवरहेड नहीं है, लेकिन इस वजह से मूल अनुक्रम "आभासी" नहीं होना चाहिए। यानी काम की शुरुआत तक, मूल अनुक्रम के प्रत्येक तत्व का एक अद्वितीय पता होना चाहिए और तत्वों को लाइनक परिवर्तनों के संचालन के दौरान स्मृति में स्थानांतरित नहीं किया जाना चाहिए। सामान्य तौर पर, सरणियाँ, क्यूटी कंटेनर, एसटीडी को छोड़कर सभी मानक कंटेनर :: बिटसेट इसके लिए उपयुक्त हैं। मुश्किलें केवल निरंतर दृश्यों के साथ पैदा हुईं, जिन्हें मैंने कभी पूरा नहीं किया, क्योंकि मुझे वास्तव में उनकी आवश्यकता नहीं थी। लाइब्रेरी को सत्यापित किया गया है और विजुअल स्टूडियो 2010 और 2012 को सफलतापूर्वक संकलित किया गया है, gcc 4.8, mingw 4.8। यह माइक्रोसॉफ्ट कंपाइलर को नियंत्रित करने का सबसे आसान तरीका निकला, जीसीसी को खुश करना अधिक कठिन था, और आंतरिक त्रुटि के साथ सभी कंपाइलर गिर गए, कभी-कभी बिना बुद्धिमानी के चिल्लाए भी।

लड़ाई में

इसलिए, CppLinq का उपयोग करने के एक उदाहरण के लिए, हम 10 तत्वों का एक क्रम लेते हैं, उन लोगों का चयन करते हैं जिनके क्षेत्र iVal> 5, फ़ील्ड sVal द्वारा सॉर्ट करते हैं, और परिणाम को std :: वेक्टर में डालते हैं:

TestClass1 data[10]; auto t1 = Linq::from(data) .where([](const TestClass1 &a){return a.iVal >= 5; }) .orderBy([](const TestClass1 &a){return a.sVal; }) .toVector();

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

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

 auto src = Linq::from(data) .where([](const TestClass1 &a){return a.iVal >= 5; }); if (order == ascending) src = src.orderBy([](const TestClass1 &a){return a.sVal; }); else src = src.orderByDesc([](const TestClass1 &a){return a.sVal; }); auto result = src.toVector();

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

 auto t4 = Linq::from(src1) .orderByDesc([](const TestClass1 &a){return a.sVal; }) .thenBy([](const TestClass1 &a){return a.iVal; }) .toVector();

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

ज्वाइनिंग को लागू करते समय, ऑपरेटर ==, या समकक्ष, ऑपरेटर <के माध्यम से, समानता पर अनुक्रम तत्वों की तुलना को लागू करने के तरीके पर दुविधा थी। दोनों विकल्पों में पेशेवरों और विपक्ष हैं। कम संचालन को लागू करने के मामले में, इनपुट अनुक्रमों को क्रमबद्ध करना और अधिक कुशलता से विलय करना संभव होगा, क्योंकि पहले अनुक्रम के प्रत्येक तत्व की दूसरे अनुक्रम के प्रत्येक तत्व के साथ तुलना करना आवश्यक नहीं है। हालाँकि, वस्तुओं के लिए Linq में, यह ऑपरेटर == के माध्यम से समानता के लिए विशेष रूप से एक तुलना को लागू करने के लिए प्रथागत है, यही वजह है कि मैंने एल्गोरिथम जटिलता ओ (एन * एम) प्राप्त करते हुए, ऐसा ही किया।

यह कैसे काम करता है?

एक Linq इंटरफ़ेस वर्ग है जो सभी रूपांतरण विधियों का वर्णन करता है। तरीकों को दो समूहों में विभाजित किया जा सकता है, जो कि ग्राफ के आगे निर्माण की ओर ले जाते हैं, वे Linq <?> उदाहरण के लिए कहाँ लौटते हैं:

 template <typename U> Linq<T> where(U f);

और "टर्मिनल" वाले जो उदाहरण के लिए ग्राफ निष्पादन शुरू करते हैं:

 size_t count(); std::vector<T> toVector();

परिवर्तन ग्राफ़ हमेशा मूल्य में दिया जाता है, लेकिन यह कोई समस्या नहीं है, क्योंकि ज्यादातर मामलों में विस्थापन शब्दार्थों का उपयोग करके पूरी नकल के बिना करना संभव था। उदाहरण के लिए, पहले उदाहरण में, कोई गहरी नकल नहीं होती है।

दिलचस्प बात यह है कि अतिरिक्त ऑर्डरिंग तब और फिरबायस्क के संचालन किए गए। चूँकि वे केवल तभी उपलब्ध होने चाहिए जब पिछला कथन क्रमबद्ध या ऑर्डरबायस्क हो, तो इसके लिए लाइनक वंशज बनाया जाता है, लिनकॉर्ड क्लास जिसमें ये ऑपरेशन किए जाते हैं, और ऑर्डरबाय या ऑर्डरबायस्क तरीकों को लिनक्ऑर्ड के रूप में घोषित किया जाता है:

 LinqOrd<T> orderBy(); LinqOrd<T> orderByDesc();

इस प्रकार, ऑर्डरबाय ऑपरेशन के बाद, LinqOrd प्रकार का एक ऑब्जेक्ट लौटाया जाता है, जिसमें पहले से ही अतिरिक्त ऑर्डर ऑपरेशन होते हैं।

Linq वर्ग के अंदर, एक एकल डेटा सदस्य है, रेंज इंटरफ़ेस वर्ग के लिए एक सूचक है। यह परिवर्तन ग्राफ का गियर है जो सभी काम करता है।

 template<typename T> class Range { public: Range(){} virtual ~Range(){} virtual bool empty() = 0; virtual T& popFront() = 0; virtual T& front() = 0; virtual void rewind() = 0; virtual Range* clone() = 0; };

इंटरफ़ेस काफी सरल है, बड़े और यह एक यूनिडायरेक्शनल पुनरावृत्ति है। खाली () विधि लौटाती है कि क्या अधिक तत्व हैं। पॉपफ्रंट () विधि अनुक्रम के अगले तत्व को पुनः प्राप्त करता है, और सामने () वर्तमान तत्व को वापस करता है। रिवाइंड () विधि सूचक को अनुक्रम की शुरुआत में ले जाती है। क्लोन () विधि एक नई वस्तु बनाती है और संपूर्ण आंतरिक फ़िल्टर श्रृंखला की गहरी प्रतिलिपि बनाती है।

परिवर्तन संचालन रेंज इंटरफ़ेस को लागू करते हैं। उदाहरण के लिए, मैं ऑपरेशन के लिए परिवर्तन कोड दूंगा जहां: व्हेयररेंज <टी, एफ>। जहां टी तत्व का प्रकार है, और एफ फ़िल्टरिंग के लिए उपयोग की जाने वाली वस्तु का वर्ग है। इस स्थिति में, F के पास एक ऐसी विधि होनी चाहिए जो T या T के सन्दर्भ को स्वीकार करे और यदि तत्व फ़िल्टरिंग स्थितियों से मेल खाता है तो यह सही है।

 template<typename T, typename F> class WhereRange : public Range<T> { public: WhereRange(Range<T> *src, F f) : src_(src) , f_(f) , frontReady(false) { } ~WhereRange() { delete src_; }; bool empty() override { if (!frontReady) seekFront(); return src_->empty(); } T& popFront() override { if (!frontReady) seekFront(); auto &result = src_->front(); frontReady = false; src_->popFront(); seekFront(); return result; } T& front() override { return src_->front(); } void rewind() override { frontReady = false; src_->rewind(); } Range<T>* clone() override { auto result = new WhereRange(CloneRange(src_), f_); return result; } private: Range<T> *src_; F f_; bool frontReady; void seekFront() { while(!src_->empty() && !f_(src_->front())) src_->popFront(); frontReady = true; } };

कंपाइलर को और भी अधिक काम सौंपने के लिए, लैम्ब्डा एक्सप्रेशंस में आप एलिमेंट कीवर्ड का उपयोग करके एलिमेंट टाइप को अपने आप प्रदर्शित कर सकते हैं। आप इस तरह से पहले उदाहरण को फिर से लिख सकते हैं:

 TestClass1 data[10]; auto src = Linq::from(data); auto result = src .where([](decltype(src.const_reference()) a){return a.iVal >= 5; }) .orderBy([](decltype(src.const_reference()) a){return a.sVal; }) .toVector();

जैसा कि आप देख सकते हैं, तत्व प्रकार TestClass1 स्पष्ट रूप से कहीं भी प्रकट नहीं होता है। कभी-कभी यह सुविधाजनक होता है, और कभी-कभी यह पता लगाना मुश्किल होता है कि हम किस प्रकार का व्यवहार कर रहे हैं।

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

 auto data1 = testData1(); auto data2 = testData2(); auto src1 = Linq::from(data1); auto src2 = Linq::from(data2); auto result = src1 .join( src2, [](decltype(src1.const_reference()) a){ return a.iVal; }, [](decltype(src2.const_reference()) b){ return b.iVal2; }, [] (decltype(src1.const_reference()) a, decltype(src2.const_reference()) b) { return std::make_pair(b.dVal, a.sVal); } ) .toVector(); }

यहां, पहले और दूसरे लैम्ब्डा उन कुंजियों को वापस करते हैं जिनके द्वारा अनुक्रमों को संयोजित किया जाएगा, और तीसरा लैम्ब्डा दोनों अनुक्रमों के मिलान तत्वों से निर्मित परिणाम देता है। फिर सभी प्राप्त तत्वों को std :: वेक्टर में संग्रहीत किया जाता है।

PS gcc 4.7 ओवरराइड कीवर्ड को पचा नहीं पाता है, इसलिए आप इसके लिए #define ओवरराइड निर्दिष्ट कर सकते हैं

C ++ के लिए एक और Linq

परिचय

लड़ाई में

यह कैसे काम करता है?

More articles: