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

Определено в заголовке `<algorithm>`
Сигнатура вызова
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)	(начиная с C++20) (до C++26)
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > 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)		(начиная с C++26)
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)	(начиная с C++20) (до C++26)
template< ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > 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)		(начиная с C++26)
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)	(начиная с 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)	(начиная с C++20)
Вспомогательные типы
template< class I, class O > using remove_copy_result = ranges::in_out_result<I, O>;	(5)	(начиная с C++20)
template< class I, class O > using remove_copy_if_result = ranges::in_out_result<I, O>;	(6)	(начиная с 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 .

Примечания

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

Feature-test macro	Value	Std	Feature
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	List-initialization for algorithms ( 1,2 )

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

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений в соответствии с инструкциями, так как содержит технические термины и синтаксис языка программирования, которые не подлежат переводу. HTML-разметка и атрибуты также сохранены в оригинальном виде.

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений в соответствии с инструкциями, так как содержит технические термины C++, которые не должны переводиться. HTML-разметка и атрибуты также сохранены в оригинальном виде.

remove_copy (1,2)

struct remove_copy_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             std::weakly_incrementable O, class Proj = std::identity,
             class T = std::projected_value_t<I, Proj>>
    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 Proj = std::identity,
             class T = std::projected_value_t<ranges::iterator_t<R>, Proj>>
    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 (3,4)

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 println(const auto rem, const auto& v)
{
    std::cout << rem << ' ';
    for (const auto& e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{
    // Отфильтровать символ решетки из заданной строки.
    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";
    // Копировать только комплексные числа с положительной мнимой частью.
    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(); }
    );
    println("source:", source);
    println("target:", target);
    std::vector<std::complex<float>> nums{{2, 2}, {1, 3}, {4, 8}, {1, 3}};
    std::vector<std::complex<double>> outs;
    #ifdef __cpp_lib_algorithm_default_value_type
        std::remove_copy(nums.cbegin(), nums.cend(), std::back_inserter(outs),
                         {1, 3}); // T выводится как std::complex<float>
    #else
        std::remove_copy(nums.cbegin(), nums.cend(), std::back_inserter(outs),
                         std::complex<float>{1, 3});
    #endif
    println("nums:  ", nums);
    println("outs:  ", outs);
}

Вывод:

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

Смотрите также

ranges::remove ranges::remove_if (C++20) (C++20)	удаляет элементы, удовлетворяющие определенным критериям (объект-функция алгоритма)
ranges::copy ranges::copy_if (C++20) (C++20)	копирует диапазон элементов в новое местоположение (объект-функция алгоритма)
ranges::copy_n (C++20)	копирует указанное количество элементов в новое местоположение (объект-функция алгоритма)
ranges::copy_backward (C++20)	копирует диапазон элементов в обратном порядке (объект-функция алгоритма)
ranges::replace_copy ranges::replace_copy_if (C++20) (C++20)	копирует диапазон, заменяя элементы, удовлетворяющие определенным критериям, другим значением (объект-функция алгоритма)
ranges::reverse_copy (C++20)	создает копию диапазона в обратном порядке (объект-функция алгоритма)
ranges::rotate_copy (C++20)	копирует и вращает диапазон элементов (объект-функция алгоритма)
ranges::unique_copy (C++20)	создает копию диапазона элементов без последовательных дубликатов (объект-функция алгоритма)
remove_copy remove_copy_if	копирует диапазон элементов, пропуская те, которые удовлетворяют определенным критериям (шаблон функции)

Поддержка компиляторами
Автономные и хостинговые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Именованные требования
Макросы тестирования возможностей (C++20)
Библиотека поддержки языка
Библиотека концепций (C++20)
Библиотека диагностики
Библиотека управления памятью
Библиотека метапрограммирования (C++11)
Библиотека общих утилит
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека строк
Библиотека обработки текста
Библиотека численных операций
Библиотека даты и времени
Библиотека ввода/вывода
Библиотека файловой системы (C++17)
Библиотека поддержки конкурентности (C++11)
Библиотека управления выполнением (C++26)
Технические спецификации
Индекс символов
Внешние библиотеки

ru.cppreference.net

Namespaces

Variants