C++ "select" algorithm

Question

Wśród funkcjonalności znalezionych w std::algorithm nie mogę znaleźć jednego z najbardziej podstawowych, jakie mogę wymyślić: wybrałem podzbiór kolekcji (na przykład, zwróć wszystkie liczby nieparzyste, wszyscy pracownicy które mają status == "zatrudniony", wszystkie przedmioty, które kosztują mniej niż 20 dolarów).

więc, biorąc pod uwagę listę wskazówki jak

vector<int> ints {1, 9, 3, 27, 5, 19, 3, 8, 2, 12}; 

vector<int> evens = ? 
vector<int> greaterThan7 = ? 

jak znaleźć te, które są nawet i te, które są większe niż 7?

Answer 1

Na przykład

vector<int> ints {1, 9, 3, 27, 5, 19, 3, 8, 2, 12}; 
vector<int> evens; 

std::copy_if(ints.begin(), ints.end(), std::back_inserter(evens), 
       [](int x) { return x % 2 == 0; }); 

Oto poglądowe programowi

#include <iostream> 
#include <algorithm> 
#include <iterator> 
#include <vector> 

int main() 
{ 
    std::vector<int> ints { 1, 9, 3, 27, 5, 19, 3, 8, 2, 12 }; 
    std::vector<int> evens; 

    std::copy_if(ints.begin(), ints.end(), std::back_inserter(evens), 
        [](int x) { return x % 2 == 0; }); 

    for (int x : evens) std::cout << x << ' '; 
    std::cout << std::endl; 
}   

Jego wyjście jest

8 2 12 

Answer 2

Jeśli chcesz coś bardziej funkcjonalny, można sprawdzić biblioteki zakresu doładowania . Konkretnie filtered:

for (int i : ints | filtered([](int i){return i > 7;})) 
{ 
    ... 
} 

To daje leniwe widoku, bez budowy nowego pojemnika.

---

można uzyskać takie same od Eric Niebler na range-v3:

for (int i : view::filter(ints, [](int i){return i > 7;}) 
{ 
    ... 
} 

z korzyści, które można po prostu przypisać do wektora też (dzięki czemu można wybrać, czy jest leniwy lub chętny, który doładowania .Ranges nie pozwala).

std::vector<int> greaterThan7 = view::filter(ints, [](int i){return i > 7;}); 
std::vector<int> sameThing = ints | view::filter([](int i){return i > 7;}); 

Answer 3

zależności od dokładnej wymagania, należy rozważyć std::stable_partition (lub std::partition). Zmienia elementy w zakresie tak, aby wszystkie, które spełniają predykat były pierwsze. Możesz myśleć o tym, dzieląc zakres na część "podzbiór" i "nie podzbiór". Oto przykład:

#include <algorithm> 
#include <vector> 
#include <iostream> 

int main() 
{ 
    using std::begin; 
    using std::end; 
    using std::cbegin; 
    using std::cend; 

    std::vector<int> ints { 1, 9, 3, 27, 5, 19, 3, 8, 2, 12 }; 

    auto const greater_than_7 = [](int number) { return number > 7; }; 

    auto const iter_first_not_greater_than_7 = std::stable_partition(begin(ints), end(ints), greater_than_7); 

    for (auto const_iter = cbegin(ints); const_iter != iter_first_not_greater_than_7; ++const_iter) 
    { 
     std::cout << *const_iter << "\n"; 
    } 
} 

Jeśli jednak jesteś w porządku z kopiując każdy element pasujący do nowej kolekcji, na przykład dlatego, że zakres źródłowy nie musi być modyfikowana, a następnie użyć std::copy_if.

---

Być może to, czego naprawdę szukasz jest widok o niemodyfikowalne zakresie. W tym przypadku zbliżasz się do problemu z niewłaściwego kierunku. Nie potrzebujesz konkretnego algorytmu; bardziej naturalnym rozwiązaniem problemu byłoby filtrowanie iteratora, jak na przykład Boost's Filter Iterator. Możesz użyć tego w Boost lub przestudiować jego implementację, aby dowiedzieć się, jak sam możesz napisać iteratory filtrujące.