STL kabını filtrelemenin modern yolu?

Yıllarca C #'dan sonra C ++ 'ya geri dönersek, modern olanın - okuyun: C ++ 11 - bir diziyi filtreleme yolunun ne olacağını merak ediyordum, yani bu Linq sorgusuna benzer bir şeyi nasıl başarabiliriz:

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

Bir element vektörünü filtrelemek stringsiçin (bu soru uğruna)?

Açık yöntemlerin tanımlanmasını boost::filter_iteratorgerektiren eski STL tarzı algoritmaların (veya hatta benzeri uzantıların ) artık yerini alacağını içtenlikle umuyorum.

Cplusplus.com'daki örneğe bakın 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_iffooburadaki her eleman için lambda ifadesini değerlendirir ve geri dönerse truedeğeri 'e kopyalar bar.

Bu std::back_inserter, ilk önce gerekli boyuta yeniden boyutlandırmak zorunda kalmadan bir yineleyici ile bar(kullanma push_back()) sonunda yeni öğeler eklememizi sağlar.

Listenin yeni bir kopyasına gerçekten ihtiyacınız yoksa, daha verimli bir yaklaşım, remove_iföğeleri orijinal kaptan kaldıran yöntemdir.

C ++ 20'de, aralık kitaplığından filtre görünümünü kullanın: (gerektirir #include <ranges>)

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

eşit öğeleri tembel olarak geri döndürür vec.

(Bkz. [Range.adaptor.object] / 4 ve [range.filter] )

Bu zaten GCC 10 ( canlı demo ) tarafından desteklenmektedir . GCC'nin Clang ve daha eski sürümleri için, orijinal range-v3 kitaplığı da #include <range/v3/view/filter.hpp>(veya #include <range/v3/all.hpp>) ve ( canlı demo ) ranges::viewsyerine ad alanı ile kullanılabilir .std::ranges::views

Bence Boost.Range de bir sözü hak ediyor. Ortaya çıkan kod, orijinaline oldukça yakındır:

#include <boost/range/adaptors.hpp>

// ...

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

Tek dezavantajı, lambda'nın parametre türünü açıkça bildirmek zorunda olmasıdır. Ben decltype (elements) :: value_type kullandım, çünkü tam türü hecelemek zorunda kalmaz ve aynı zamanda bir genellik zarı ekler. Alternatif olarak, C ++ 14'ün polimorfik lambdalarıyla, tür basitçe auto olarak belirtilebilir:

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

filteredElements, geçiş için uygun bir aralık olabilir, ancak temelde orijinal kabın bir görünümüdür. İhtiyacınız olan şey, kriterleri karşılayan öğelerin kopyalarıyla dolu başka bir kapsa (böylece orijinal kabın ömründen bağımsızdır), şöyle görünebilir:

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 ++ eşdeğeri C # için önerim

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

Filtrelemeyi yapmak için bir lambda yüklemini ilettiğiniz bir şablon işlevi tanımlayın. Şablon işlevi filtrelenmiş sonucu döndürür. Örneğin:

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

kullanmak - önemsiz örnekler vermek:

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

Alt çizgi-d önerilerinin ardından geliştirilmiş pjm kodu :

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

Kullanım:

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

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