std::ranges::remove_copy, std::ranges::remove_copy_if, std::ranges::remove_copy_result, std::ranges::remove_copy_if_result

Defined in header `<algorithm>`
Call signature
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class T, class Proj = std::identity > requires std::indirectly_copyable<I, O> && std::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>, const T*> constexpr remove_copy_result<I, O> remove_copy( I first, S last, O result, const T& value, Proj proj = {} );	(1)	(since C++20)
template< ranges::input_range R, std::weakly_incrementable O, class T, class Proj = std::identity > requires std::indirectly_copyable<ranges::iterator_t<R>, O> && std::indirect_binary_predicate<ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr remove_copy_result<ranges::borrowed_iterator_t<R>, O> remove_copy( R&& r, O result, const T& value, Proj proj = {} );	(2)	(since C++20)
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > requires std::indirectly_copyable<I, O> constexpr remove_copy_if_result<I, O> remove_copy_if( I first, S last, O result, Pred pred, Proj proj = {} );	(3)	(since C++20)
template< ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred > requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr remove_copy_if_result<ranges::borrowed_iterator_t<R>, O> remove_copy_if( R&& r, O result, Pred pred, Proj proj = {} );	(4)	(since C++20)
Helper types
template< class I, class O > using remove_copy_result = ranges::in_out_result<I, O>;	(5)	(since C++20)
template< class I, class O > using remove_copy_if_result = ranges::in_out_result<I, O>;	(6)	(since C++20)

Копирует элементы из исходного диапазона [first, last), в целевой диапазон, начиная с result, опуская элементы, которые (после применения проекции proj) удовлетворяют определённым критериям. Поведение не определено, если исходный и целевой диапазоны перекрываются.

1) Игнорирует все элементы, равные value.

3) Игнорирует все элементы, для которых предикат pred возвращает значение true.

2,4) Аналогично (1,3), но использует r в качестве исходного диапазона, как если бы ranges::begin(r) использовалось как first, и ranges::end(r) как last.

Функциональные сущности, описанные на этой странице, являются niebloids, то есть:

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

На практике они могут быть реализованы как объекты функций или с помощью специальных расширений компилятора.

Параметры

first, last	-	исходный диапазон элементов
r	-	исходный диапазон элементов
result	-	начало целевого диапазона
value	-	значение элементов, которые не нужно копировать
comp	-	бинарный предикат для сравнения спроецированных элементов
proj	-	проекция, применяемая к элементам

Возвращаемое значение

{last, result + N}, где N — количество скопированных элементов.

Сложность

Точно ranges::distance(first, last) применений соответствующего предиката comp и любой проекции proj.

Примечания

Алгоритм стабильный, т.е. сохраняет относительный порядок копируемых элементов.

Возможная реализация

remove_copy
struct remove_copy_fn { template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class T, class Proj = std::identity> requires std::indirectly_copyable<I, O> && std::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>, const T> constexpr ranges::remove_copy_result<I, O> operator()(I first, S last, O result, const T& value, Proj proj = {}) const { for (; !(first == last); ++first) if (value != std::invoke(proj, first)) { result = first; ++result; } return {std::move(first), std::move(result)}; } template<ranges::input_range R, std::weakly_incrementable O, class T, class Proj = std::identity> requires std::indirectly_copyable<ranges::iterator_t<R>, O> && std::indirect_binary_predicate<ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T> constexpr ranges::remove_copy_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result, const T& value, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::end(r), std::move(result), value, std::move(proj)); } }; inline constexpr remove_copy_fn remove_copy {};
remove_copy_if
struct remove_copy_if_fn { template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> requires std::indirectly_copyable<I, O> constexpr ranges::remove_copy_if_result<I, O> operator()(I first, S last, O result, Pred pred, Proj proj = {}) const { for (; first != last; ++first) if (false == std::invoke(pred, std::invoke(proj, first))) { result = first; ++result; } return {std::move(first), std::move(result)}; } template<ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred> requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr ranges::remove_copy_if_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result, Pred pred, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::end(r), std::move(result), std::move(pred), std::move(proj)); } }; inline constexpr remove_copy_if_fn remove_copy_if {};

remove_copy

struct remove_copy_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             class T, class Proj = std::identity>
    requires std::indirectly_copyable<I, O> &&
             std::indirect_binary_predicate<ranges::equal_to,
                                            std::projected<I, Proj>, const T*>
    constexpr ranges::remove_copy_result<I, O>
        operator()(I first, S last, O result, const T& value, Proj proj = {}) const
    {
        for (; !(first == last); ++first)
            if (value != std::invoke(proj, *first))
            {
                *result = *first;
                ++result;
            }
        return {std::move(first), std::move(result)};
    }
 
    template<ranges::input_range R, std::weakly_incrementable O, class T,
             class Proj = std::identity>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
             std::indirect_binary_predicate<ranges::equal_to,
             std::projected<ranges::iterator_t<R>, Proj>, const T*>
    constexpr ranges::remove_copy_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, const T& value, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result), value,
                       std::move(proj));
    }
};
 
inline constexpr remove_copy_fn remove_copy {};

remove_copy_if

struct remove_copy_if_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::remove_copy_if_result<I, O>
        operator()(I first, S last, O result, Pred pred, Proj proj = {}) const
    {
        for (; first != last; ++first)
            if (false == std::invoke(pred, std::invoke(proj, *first)))
            {
                *result = *first;
                ++result;
            }
        return {std::move(first), std::move(result)};
    }
 
    template<ranges::input_range R, std::weakly_incrementable O,
             class Proj = std::identity,
             std::indirect_unary_predicate<
                 std::projected<ranges::iterator_t<R>, Proj>> Pred>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::remove_copy_if_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                       std::move(pred), std::move(proj));
    }
};
 
inline constexpr remove_copy_if_fn remove_copy_if {};

Пример

#include <algorithm>
#include <array>
#include <complex>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string_view>
#include <vector>
 
void print(const auto rem, const auto& v)
{
    std::cout << rem << ' ';
    for (const auto& e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
 
int main()
{
    // Filter out the hash symbol from the given string.
    const std::string_view str{"#Small #Buffer #Optimization"};
    std::cout << "before: " << std::quoted(str) << '\n';
 
    std::cout << "after:  \"";
    std::ranges::remove_copy(str.begin(), str.end(),
                             std::ostream_iterator<char>(std::cout), '#');
    std::cout << "\"\n";
 
    // Copy only the complex numbers with positive imaginary part.
    using Ci = std::complex<int>;
    constexpr std::array<Ci, 5> source
    {
        Ci{1, 0}, Ci{0, 1}, Ci{2, -1}, Ci{3, 2}, Ci{4, -3}
    };
    std::vector<std::complex<int>> target;
 
    std::ranges::remove_copy_if(
        source,
        std::back_inserter(target),
        [](int imag) { return imag <= 0; },
        [](Ci z) { return z.imag(); }
    );
 
    print("source:", source);
    print("target:", target);
}

Вывод:

before: "#Small #Buffer #Optimization"
after:  "Small Buffer Optimization"
source: (1,0) (0,1) (2,-1) (3,2) (4,-3)
target: (0,1) (3,2)

См. также

ranges::removeranges::remove_if (C++20)(C++20)	удаляет элементы, удовлетворяющие определённым критериям (niebloid)
ranges::copyranges::copy_if (C++20)(C++20)	копирует диапазон элементов в новое местоположение (niebloid)
ranges::copy_n (C++20)	копирует определённое количество элементов в новое местоположение (niebloid)
ranges::copy_backward (C++20)	копирует диапазон элементов в обратном порядке (niebloid)
ranges::replace_copyranges::replace_copy_if (C++20)(C++20)	копирует диапазон, заменяя элементы, удовлетворяющие определённым критериям, другим значением (niebloid)
ranges::reverse_copy (C++20)	создаёт копию диапазона, которая перевернута (niebloid)
ranges::rotate_copy (C++20)	копирует и вращает диапазон элементов (niebloid)
ranges::unique_copy (C++20)	создаёт копию диапазона элементов, не содержащую последовательных дубликатов (niebloid)
remove_copyremove_copy_if	копирует диапазон элементов, опуская те, которые удовлетворяют определённым критериям (функция-шаблон)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/ranges/remove_copy