STL алгоритм, который принимает испытание и мутировать Функция

Question

Я хочу это поведение: void change_if(ForwardIterator first, ForwardIterator last, UnaryPredicate test, UnaryOperation op)

Это лучший способ добиться того, чтобы просто с циклом? Или есть какая-то магия STL, которую я еще не знаю?

Answer 1

Решение Vlad from Moscow - это рекомендуемый подход для его простоты.

«казалось бы, obious» использование стандартного алгоритма std::transform с лямбдой:

std::transform(first, last, first, [](auto elem) { 
    return test(elem) ? op(elem) : elem; 
}); 

фактически приводит к снижению производительности, поскольку все элементов будут присвоенным, а не только удовлетворяющим предикат. Чтобы изменить только предицированные элементы, потребуется также что-то вроде boost::filter_iterator, как указано в ответе киви.

Обратите внимание, что я использовал синтаксис C++ 14 с auto внутри лямбда. Для C++ 11 вам понадобится что-то вроде decltype(*first) или iterator_traits<ForwardIterator>::value_type. А в C++ 98/03 вы бы и это, и ручной объект функции.

Answer 2

std::for_each(first, last, [](T &x) { if (test(x)) op(x); }); 

или используя подталкивание лямбда:

#include <boost/lambda/lambda.hpp> 
#include <boost/lambda/bind.hpp> 
#include <boost/lambda/if.hpp> 

std::for_each(v.begin(), v.end(), 
        if_(test())[ op() ] 
       ); 

альтернативно:

std::vector<int>::iterator it = v.begin(); 
while (it != v.end()) { 
    if (test(*it)) op(*it); 
    ++it; 
} 

Answer 3

Это может быть сделано без использования подталкивания, но применяя стандартный алгоритм std::for_each Я не советую использовать импульс для таких простые задачи. Просто глупо включать в свой проект boost, чтобы выполнить такую ​​простую задачу. Вы можете использовать boost для таких задач, если он уже включен в ваш проект.

std::for_each(first, last, [](const T &x) { if (test(x)) op(x); }); 

Или вы можете удалить Классификатор сопзЬ, если вы собираетесь изменить элементы последовательности

std::for_each(first, last, [](T &x) { if (test(x)) op(x); }); 

Иногда, когда весь диапазон последовательности используется проще использовать диапазон, основанный на утверждение вместо алгоритма becuase с использованием алгоритмов с лямбда-выражений иногда делает код менее читаемым

for (auto &x : sequence) 
{ 
    if (test(x)) op(x); 
} 

Или

for (auto &x : sequence) 
{ 
    if (test(x)) x = op(x); 
} 

Answer 4

Еще один толчок решение:

http://www.boost.org/doc/libs/1_55_0/libs/iterator/doc/filter_iterator.html

Просто позвоните станд :: преобразование вашего фильтрованной итератора.

Answer 5

Вы хотите change_if как простой цикл?

template<typename ForwardIterator, typename UnaryPredicate> 
void change_if(ForwardIterator first, ForwardIterator last, UnaryPredicate test, UnaryOperation op) { 
    for(; first!=last; ++first) 
    if (test(*first)) *first=op(std::move(*first)); 
} 

или просто напишите вышеуказанный цикл. Я бы посоветовал на самом деле написать change_if и назвать его, потому что, хотя приведенный выше код короток, я бы нашел, что вызов change_if будет больше, не менее, ясным, чем просто отбрасывать приведенный выше код.

Я также люблю писать контейнер на основе перегрузок:

template<typename Container, typename UnaryPredicate> 
void change_if(Container&& c, UnaryPredicate test, UnaryOperation op) { 
    for(auto& v : std::forward<Container>(c)) 
    if (test(v)) v=op(std::move(v)); 
} 

, но у меня есть это:

template<typename Iterator> 
struct range { 
    Iterator b, e; 
    Iterator begin() const { return b; } 
    Iterator end() const { return e; } 
}; 
template<typename Iterator0, typename Iterator1> 
range<typename std::decay<Iterator0>::type> make_range(Iterator0&& b, Iterator1&& e) { 
    static_assert(
    std::is_convertible< Iterator1, typename std::decay<Iterator0>::type >::value, 
    "end must be compatible with begin iterator type" 
); 
    return { std::forward<Iterator0>(b), std::forward<Iterator1>(e) }; 
} 

, который позволяет мне использовать такие алгоритмы на базе контейнеров с итераторами.

Вы увидите, что у меня есть Container на основе change_if? Это действительно диапазон change_if.

Это называется как:

change_if(myVect, [](int x){return (x%2)==0;}, [](int x){return x/2;}); 

на контейнере, а не пара итераторов. Однако, если вы хотите изменить первую половину контейнера, это не сработает: на первый взгляд, алгоритмы на основе контейнеров (ну, на основе диапазона) менее полезны.

Но make_range превращает итераторы в ряд. Таким образом, вы можете:

make_range заполняет неспособность непосредственно передать 2 итераторы диапазона на основе алгоритмов, связывая два итератора в один range<> объект. Этот угловой корпус более подробный, но типичный случай (обработки всего контейнера) становится менее подробным.

Плюс, общий вид ошибки (именование другого контейнера для begin и end) производится гораздо реже.

Все это заканчивается тем, что является эффективным, или более того, чем версия, основанная на итераторе. И, если вы замените ваши диапазоны с итерируемыми (диапазонами, которые имеют неодинаковые begin и end типов итераторов), мой change_if просто работает