STL कंटेनर को छानने का आधुनिक तरीका?

Question 1

C # के वर्षों के बाद C ++ में वापस आना मैं सोच रहा था कि आधुनिक क्या है - पढ़ें: C ++ 11 - एक सरणी फ़िल्टर करने का तरीका होगा, अर्थात हम इस Linq क्वेरी के समान कुछ कैसे प्राप्त कर सकते हैं:

var filteredElements = elements.Where(elm => elm.filterProperty == true);

तत्वों के एक वेक्टर को फ़िल्टर करने के लिए ( stringsइस प्रश्न के लिए)?

मुझे पूरी उम्मीद है कि पुराने एसटीएल शैली के एल्गोरिदम (या यहां तक कि एक्सटेंशन जैसे boost::filter_iterator) स्पष्ट तरीकों को परिभाषित करने की आवश्यकता है जो अब तक डूब गए हैं?

Question 2

इसके लिए cplusplus.com से उदाहरण देखें std::copy_if:

std::vector<int> foo = {25,15,5,-5,-15};
std::vector<int> bar;

// copy only positive numbers:
std::copy_if (foo.begin(), foo.end(), std::back_inserter(bar), [](int i){return i>=0;} );

std::copy_iffooयहाँ पर हर तत्व के लिए लैम्ब्डा एक्सप्रेशन का मूल्यांकन करता है और अगर यह रिटर्न trueकरता है तो वैल्यू को कॉपी करता है bar।

std::back_inserterहमें वास्तव में आवश्यक आकार में इसे आकार देने के बिना एक पुनरावृत्ति के साथ bar(उपयोग push_back()) के अंत में नए तत्वों को सम्मिलित करने की अनुमति देता है ।

Question 3

एक अधिक कुशल दृष्टिकोण, यदि आपको वास्तव में सूची की एक नई प्रतिलिपि की आवश्यकता नहीं है, तो यह वास्तव remove_ifमें मूल कंटेनर से तत्वों को निकालता है।

Question 4

C ++ 20 में, रेंज लाइब्रेरी से फ़िल्टर व्यू का उपयोग करें: (आवश्यकता है #include <ranges>)

// namespace views = std::ranges::views;
vec | views::filter([](int a){ return a % 2 == 0; })

आलसी भी तत्वों में लौटता है vec।

(देखें [range.adaptor.object] / 4 और [range.filter] )

यह पहले से ही जीसीसी 10 ( लाइव डेमो ) द्वारा समर्थित है । बजना और जीसीसी के पुराने संस्करणों के लिए, मूल सीमा-v3 पुस्तकालय भी इस्तेमाल किया जा सकता है, के साथ #include <range/v3/view/filter.hpp>(या #include <range/v3/all.hpp>) और ranges::viewsके बजाय नाम स्थान std::ranges::views( लाइव डेमो )।

Question 5

मुझे लगता है कि Boost.Range एक उल्लेख के भी हकदार हैं। परिणामी कोड मूल के बहुत करीब है:

#include <boost/range/adaptors.hpp>

// ...

using boost::adaptors::filtered;
auto filteredElements = elements | filtered([](decltype(elements)::value_type const& elm)
    { return elm.filterProperty == true; });

केवल नकारात्मक पहलू में लैम्बडा के पैरामीटर प्रकार को स्पष्ट रूप से घोषित करना है। मैंने घोषणापत्र (तत्वों) का उपयोग किया :: value_type क्योंकि यह सटीक प्रकार को बाहर करने से बचता है, और सामान्यता का एक दाना भी जोड़ता है। वैकल्पिक रूप से, C ++ 14 के बहुरूपी लंबोदर के साथ, प्रकार को केवल ऑटो के रूप में निर्दिष्ट किया जा सकता है:

auto filteredElements = elements | filtered([](auto const& elm)
    { return elm.filterProperty == true; });

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

using std::back_inserter; using boost::copy; using boost::adaptors::filtered;
decltype(elements) filteredElements;
copy(elements | filtered([](decltype(elements)::value_type const& elm)
    { return elm.filterProperty == true; }), back_inserter(filteredElements));

Question 6

C # के लिए मेरा सुझाव C # के बराबर है

var filteredElements = elements.Where(elm => elm.filterProperty == true);

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

template<typename T>
vector<T> select_T(const vector<T>& inVec, function<bool(const T&)> predicate)
{
  vector<T> result;
  copy_if(inVec.begin(), inVec.end(), back_inserter(result), predicate);
  return result;
}

उपयोग करने के लिए - एक तुच्छ उदाहरण देते हुए:

std::vector<int> mVec = {1,4,7,8,9,0};

// filter out values > 5
auto gtFive = select_T<int>(mVec, [](auto a) {return (a > 5); });

// or > target
int target = 5;
auto gt = select_T<int>(mVec, [target](auto a) {return (a > target); });

Question 7

अंडरस्कोर-डी सुझावों के बाद बेहतर pjm कोड :

template <typename Cont, typename Pred>
Cont filter(const Cont &container, Pred predicate) {
    Cont result;
    std::copy_if(container.begin(), container.end(), std::back_inserter(result), predicate);
    return result;
}

उपयोग:

std::vector<int> myVec = {1,4,7,8,9,0};

auto filteredVec = filter(myVec, [](int a) { return a > 5; });