LINQ C ++ में ऑब्जेक्ट्स के लिए

यह सब तब शुरू हुआ जब मैं संस्थान में था और स्नातक होने के बाद मैंने C ++ में कोड लिखा और परेशानियों को नहीं जानता था। लेकिन फिर एक दिन मुझे C # में .NET के लिए कोड लिखना पड़ा। सबसे पहले, वह थोड़ा थूकता है, लेकिन फिर कुछ भी नहीं - वह शामिल हो गया। मैंने सी ++ से लाभकारी अंतर देखा: सुरक्षा, कठोरता, आदि। मैं भी संग्रह के साथ काम करते समय LINQ को नजरअंदाज नहीं कर सकता ...

मुद्दे का परिचय

लेकिन मैंने लिनक्यू के सभी आकर्षण की सराहना की जब यह सी ++ पर लौटने का समय था। छह महीने के ब्रेक के बाद सी ++ में लिखना थोड़ा असामान्य था। बीमार कुछ भी नहीं हुआ, जब अचानक मुझे वेक्टर में तत्वों की राशि की गणना करनी पड़ी, तो विशेष रूप से वेक्टर के तत्वों के क्षेत्रों का योग। C # में, इसे इस तरह हल किया जाएगा:

int sum = candles.Sum(c => c.ClosePrice); 

लेकिन C ++ में यह सामने आया:

 int sum = 0; for(int i = 0; i < candles.size(); i++) sum += candles[i].ClosePrice; 

और यदि आप पुनरावृत्तियों को फिर से लिखते हैं:

 int sum = 0; for(auto it = candles.begin(); it != candles.end(); ++it) sum += it->ClosePrice; 

Qt चीजों को थोड़ा आसान बनाता है, लेकिन बहुत अधिक नहीं:

 int sum = 0; foreach(Candle candle, candles) sum += candle.ClosePrice; 

इसके अलावा, नया C ++ 11 भाषा मानक हमें सरलीकरण का वादा करता है,
लेकिन विज़ुअल स्टूडियो 2010 अलास इस सुविधा का समर्थन नहीं करता है , लेकिन कैसे ... (धन्यवाद डमास्कस ):

 int sum = 0; for (Candle candle : vector) sum += candle.ClosePrice; 

आप जल्दी से अच्छे की आदत डाल लें। यह पूरी गड़बड़ थी। ये सभी विकल्प मुझे पसंद नहीं आए। हमें एक-लाइन समाधान की आवश्यकता थी। फिर मैंने गूगल करना शुरू किया और पहले लिंक पर पाया: http://stackoverflow.com/questions/3221812/sum-of-elements-in-a-stdvector

प्रस्तावित समाधानों में सबसे छोटा:

 int sum = std::accumulate(vector.begin(), vector.end(), 0); 

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

क्या करें?

अगले 20-30 मिनट के गोग्लिंग से पता चला कि बूस्ट रेंज और कुछ अन्य पुस्तकालय हैं, लेकिन वे सभी ऐसे दिखते हैं जो LINQ की तरह दिखते हैं। उसी क्षण, मैंने अपने आप में ताकत महसूस की - अपने कार्यान्वयन को लिखने और परीक्षणों के साथ इसे कवर करने के लिए।

मेरे लिए मुख्य कार्य थे:

• LINQ को लाइब्रेरी को जितना हो सके उतना अच्छा बनाएं
• सभी कार्यक्षमता "स्थगित" (आलसी) करें

यह कैसे बूलिंक परियोजना के बारे में आया (नाम बूल और लिनक शब्द को जोड़ता है)। इसे Google कोड पर पोस्ट करें: http://code.google.com/p/boolinq/ और यहाँ है जो मुझे मिला:

 int sum = boolinq::from(cnadles).sum([](Candle c){return c.ClosePrice;}); 

बेशक, यह LINQ की तुलना में थोड़ा अधिक जटिल है। लेकिन, यह केवल C ++ में लैम्ब्डा एक्सप्रेशंस के सिंटैक्स के कारण है। कोड की बहुत संरचना समान रहती है। वर्तमान में निम्नलिखित कार्य कार्यान्वित किए गए हैं:

अनुक्रम रूपांतरण:

• लेना (int)
• छोड़ें (int)
• समतल (सीमा)
• जहां (लंबोदर)
• चयन करें (लंबोदर)
• उल्टा ()
• ऑर्डरबी ()
• ऑर्डरबी (लंबोदर)
• ग्रुपबी (लैम्ब्डा)
• अलग ()
• अलग (लंबोदर)
• for_each (लैम्ब्डा)

अनुक्रम एग्रीगेटर्स:

• सभी ()
• सभी (लंबोदर)
• कोई भी ()
• कोई भी (लंबोदर)
• योग ()
• योग (लंबोदर)
• अवग ()
• एवीजी (लंबा)
• मिनट ()
• मिनट (लंबोदर)
• अधिकतम ()
• अधिकतम (लंबोदर)
• गिनती ()
• गिनती (लंबोदर)
• सम्‍मिलित (मान)
• एलिमेंट (इंट)

निर्यात अनुक्रम:

• सेट ()
• सूची ()
• .Deque ()
• .वेक्टर ()
• toContainer <T> ()

और कुछ असामान्य भी:

• बाइट्स ()
• बाइट्स <बाइटऑर्डर> ()
• अनबाइट्स <T> ()
• अनबाइट्स <टी, बाइटऑर्डर> ()
• बिट्स ()
• बिट्स <BitOrder> ()
• बिट्स <बिटऑर्डर, बाइटऑर्डर> ()
• अनबिट्स ()
• कड़ियाँ <BitOrder> ()
• <t> ()
• <टी, बिटऑर्डर> ()
• बिट्स <, बिटऑर्डर, बाइटऑर्डर> ()

उदाहरण का उपयोग करें

यहाँ एक उदाहरण अभिव्यक्ति है:

 int src[] = {1,2,3,4,5,6,7,8}; auto dst = from(src).where( [](int a){return a%2 == 1;}) // 1,3,5,7 .select([](int a){return a*2;}) // 2,6,10,14 .where( [](int a){return a>2 && a<12;}) // 6,10 .toVector(); 

कई कार्यों को मूल संग्रह में कदम से कदम लागू किया जाता है:
1. केवल विषम मान वाले तत्वों को छोड़ दें।
2. प्रत्येक तत्व का मान 2 से गुणा करें।
3. रेंज (2,12) में केवल मान वाले आइटम छोड़ें।
4. परिणाम को std::vector में रखा गया है।

या अधिक जटिल अभिव्यक्ति:

 struct Man { std::string name; int age; }; Man src[] = { {"Kevin",14}, {"Anton",18}, {"Agata",17}, {"Terra",20}, {"Layer",15}, }; auto dst = from(src).where( [](const Man & man){return man.age < 18;}) .orderBy([](const Man & man){return man.age;}) .select( [](const Man & man){return man.name;}) .toVector(); 

dst वेरिएबल का प्रकार std::vector<std::string> । परिणामी वेक्टर में निम्नलिखित मूल्य होंगे: "केविन", "परत", "अगता"। स्रोत सरणी पर लागू होने वाले कार्य:

1. केवल 18 वर्ष से कम आयु के लोगों को सरणी में छोड़ दें।
2. बढ़ती उम्र में सरणी में तत्वों को व्यवस्थित करें।
3. सरणी से केवल नाम चुनें।
4. परिणाम को std::vector में रखा गया है।

निष्कर्ष

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

लाइब्रेरी को एक ही हेडर फाइल के रूप में वितरित किया जाता है। मुझे खुशी होगी अगर किसी को पुस्तकालय उपयोगी लगे। यदि सुधार के लिए सुझाव हैं, तो एक फ़ंक्शन जोड़ना - कृपया बोलें। यदि आपके पास घूमने-फिरने का समय और इच्छा है - जुड़ें। हर कोई Google कोड पर कोड पर टिप्पणी छोड़ सकता है। Google समूहों पर एक चर्चा समूह भी बनाया गया है: https://groups.google.com/forum/?fromgroups#-forum/boolgq!