วิธีที่ทันสมัยในการกรอง STL container?

กลับมาที่ C ++ หลังจากหลายปีของ C # ฉันสงสัยว่าสิ่งที่ทันสมัย ​​- อ่าน: C ++ 11 - วิธีการกรองอาร์เรย์จะเป็นอย่างไรเช่นเราจะบรรลุสิ่งที่คล้ายกับแบบสอบถาม Linq นี้ได้อย่างไร:

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

เพื่อกรองเวกเตอร์ขององค์ประกอบ ( stringsสำหรับคำถามนี้)?

ฉันหวังเป็นอย่างยิ่งว่าอัลกอริทึมสไตล์ STL แบบเก่า (หรือแม้กระทั่งส่วนขยายเช่นboost::filter_iterator) ที่ต้องการกำหนดวิธีการที่ชัดเจนจะถูกแทนที่ด้วยในตอนนี้?

ดูตัวอย่างจาก 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_ifประเมินการแสดงออกแลมบ์ดาสำหรับทุกองค์ประกอบในfooที่นี่และถ้ามันกลับชุดมันคุ้มค่าที่จะtruebar

std::back_inserterช่วยให้เราสามารถจริงใส่องค์ประกอบใหม่ในตอนท้ายของbar(ใช้push_back()) กับ iterator โดยไม่ต้องปรับขนาดให้ได้ขนาดที่ต้องการแรก

วิธีการที่มีประสิทธิภาพมากขึ้นหากคุณไม่ต้องการสำเนารายการใหม่ก็คือ remove_ifการนำองค์ประกอบออกจากคอนเทนเนอร์เดิม

ใน 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] )

GCC 10 รองรับอยู่แล้ว ( การสาธิตสด ) สำหรับ Clang และ GCC เวอร์ชันเก่าคุณสามารถใช้ไลบรารี range-v3 ดั้งเดิมได้เช่นกันโดยใช้#include <range/v3/view/filter.hpp>(หรือ#include <range/v3/all.hpp>) และranges::viewsเนมสเปซแทนstd::ranges::views( การสาธิตสด )

ฉันคิดว่า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; });

ข้อเสียเพียงอย่างเดียวคือต้องประกาศประเภทพารามิเตอร์ของแลมบ์ดาอย่างชัดเจน ฉันใช้ Decltype (องค์ประกอบ) :: value_type เพราะหลีกเลี่ยงการสะกดประเภทที่แน่นอนและยังเพิ่มเกรนทั่วไป หรืออีกวิธีหนึ่งด้วยแลมด้าโพลีมอร์ฟิคของ C ++ 14 ประเภทนี้สามารถระบุได้ว่าเป็นอัตโนมัติ:

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

filteredElements จะเป็นช่วงที่เหมาะสำหรับการส่งผ่าน แต่โดยทั่วไปแล้วจะเป็นมุมมองของคอนเทนเนอร์ดั้งเดิม หากสิ่งที่คุณต้องการคือคอนเทนเนอร์อื่นที่เต็มไปด้วยสำเนาขององค์ประกอบที่ตรงตามเกณฑ์ (เพื่อให้เป็นอิสระจากอายุการใช้งานของคอนเทนเนอร์เดิม) อาจมีลักษณะดังนี้:

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));

คำแนะนำของฉันสำหรับ 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); });

ปรับปรุงรหัสpjmตามคำแนะนำขีดล่าง -d :

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; });