View source for cpp/algorithm/ranges/remove copy

You do not have permission to edit this page, for the following reason:

Due to recent vandalism, editing of this page is temporarily disabled for new users.If you want to suggest a change, please leave a message on the suggestions page for new users instead (don't be surprised if that page appears vandalized!).

You can view and copy the source of this page:

{{cpp/ranges/title|remove_copy|remove_copy_if|remove_copy_result|remove_copy_if_result}}
{{cpp/algorithm/ranges/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl h | Call signature}}
{{dcl | num=1 | since=c++20 |1=
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>
      ranges::remove_copy( I first, S last, O result, const T& value, Proj proj = {} );
}}
{{dcl | num=2 | since=c++20 |1=
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>
      ranges::remove_copy( R&& r, O result, const T& value, Proj proj = {} );
}}
{{dcl | num=3 | since=c++20 |1=
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>
      ranges::remove_copy_if( I first, S last, O result, Pred pred, Proj proj = {} );
}}
{{dcl | num=4 | since=c++20 |1=
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>
      ranges::remove_copy_if( R&& r, O result, Pred pred, Proj proj = {} );
}}
{{dcl h | Helper types}}
{{dcl | num=5 | since=c++20 |1=
template<class I, class O>
  using remove_copy_result = ranges::in_out_result<I, O>;
}}
{{dcl | num=6 | since=c++20 |1=
template<class I, class O>
  using remove_copy_if_result = ranges::in_out_result<I, O>;
}}
{{dcl end}}

Copies elements from the source range {{tt|[first, last)}}, to the destination range beginning at {{tt|result}}, omitting the elements which (after being projected by {{tt|proj}}) satisfy specific criteria. ''Precondition:'' the source and destination ranges do not overlap.

@1@ Ignores all elements that are equal to {{tt|value}}.

@3@ Ignores all elements for which predicate {{tt|pred}} returns {{c|true}}.

@2,4@ Same as {{v|1,3}}, but uses {{tt|r}} as the soruce range, as if using {{c|ranges::begin(r)}} as {{tt|first}}, and {{c|ranges::end(r)}} as {{tt|last}}.

{{cpp/ranges/niebloid}}

===Parameters===
{{par begin}}
{{par | first, last | the source range of elements}}
{{par | r | the source range of elements}}
{{par | result | the beginning of the destination range}}
{{par | value | the value of the elements ''not'' to copy}}
{{par | comp | the binary predicate to compare the projected elements}}
{{par | proj | the projection to apply to the elements.}}
{{par end}}

===Return value===
Returns an object {{tt|{last, result + N},}} where {{tt|N}} is the number of elements copied.

===Complexity===
Exactly {{c|ranges::distance(first, last)}} applications of the corresponding predicate {{tt|comp}} and any projection {{tt|proj}}.

===Notes===
The algorithm is ''stable'', i.e. preserves the relative order of the copied elements.

===Possible implementation===
{{eq fun| 1=
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{};
| 2=
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_{};
}}

===Example===
{{example|code=
#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);
}
|output=
before: "#Small #Buffer #Optimization"
after:  "Small Buffer Optimization"
source: (1,0) (0,1) (2,-1) (3,2) (4,-3)
target: (0,1) (3,2)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/ranges/dsc remove}}
{{dsc inc | cpp/algorithm/ranges/dsc copy}}
{{dsc inc | cpp/algorithm/ranges/dsc copy_n}}
{{dsc inc | cpp/algorithm/ranges/dsc copy_backward}}
{{dsc inc | cpp/algorithm/ranges/dsc replace_copy}}
{{dsc inc | cpp/algorithm/ranges/dsc reverse_copy}}
{{dsc inc | cpp/algorithm/ranges/dsc rotate_copy}}
{{dsc inc | cpp/algorithm/ranges/dsc unique_copy}}
{{dsc inc | cpp/algorithm/dsc remove_copy}}
{{dsc end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Templates used on this page:

Template:! (view source) (protected)
Template:!- (edit)
Template:= (edit)
Template:anchor (edit)
Template:box/core (edit)
Template:c (view source) (protected)
Template:c/core (view source) (protected)
Template:cpp/algorithm/dsc remove copy (edit)
Template:cpp/algorithm/navbar content (edit)
Template:cpp/algorithm/navbar heading (edit)
Template:cpp/algorithm/ranges/dsc copy (edit)
Template:cpp/algorithm/ranges/dsc copy backward (edit)
Template:cpp/algorithm/ranges/dsc copy n (edit)
Template:cpp/algorithm/ranges/dsc remove (edit)
Template:cpp/algorithm/ranges/dsc replace copy (edit)
Template:cpp/algorithm/ranges/dsc reverse copy (edit)
Template:cpp/algorithm/ranges/dsc rotate copy (edit)
Template:cpp/algorithm/ranges/dsc unique copy (edit)
Template:cpp/algorithm/ranges/navbar (edit)
Template:cpp/algorithm/ranges/navbar content (edit)
Template:cpp/algorithm/ranges/navbar heading (edit)
Template:cpp/navbar content (edit)
Template:cpp/navbar heading (edit)
Template:cpp/ranges/niebloid (edit)
Template:cpp/ranges/title (edit)
Template:cpp/title (view source) (protected)
Template:ctitle (view source) (protected)
Template:dcl (view source) (protected)
Template:dcl begin (view source) (protected)
Template:dcl end (view source) (protected)
Template:dcl h (view source) (protected)
Template:dcl header (view source) (protected)
Template:dcl list header/link (edit)
Template:dcl rev begin (edit)
Template:dcl rev end (edit)
Template:dcl sep (view source) (protected)
Template:dcl/std (view source) (semi-protected)
Template:dcla (edit)
Template:dsc (view source) (protected)
Template:dsc begin (view source) (protected)
Template:dsc editlink (edit)
Template:dsc end (view source) (protected)
Template:dsc guard (view source) (protected)
Template:dsc header/link (edit)
Template:dsc inc (view source) (protected)
Template:dsc member (view source) (protected)
Template:dsc niebloid (edit)
Template:dsc tfun (view source) (protected)
Template:eq impl (edit)
Template:example (view source) (protected)
Template:feature test macro (edit)
Template:ftm link (edit)
Template:get lang (view source) (protected)
Template:l2tt (view source) (protected)
Template:l2tt/core (view source) (protected)
Template:langlinks (view source) (protected)
Template:langlinks/one (view source) (protected)
Template:lines (view source) (protected)
Template:ls (edit)
Template:lt (edit)
Template:ltt/core (view source) (protected)
Template:mark (view source) (protected)
Template:mark c++11 (view source) (protected)
Template:mark c++17 (view source) (protected)
Template:mark c++20 (edit)
Template:mark c++23 (view source) (protected)
Template:mark c++26 (edit)
Template:mark niebloid (edit)
Template:mark rev (view source) (protected)
Template:mark since c++20 (edit)
Template:mark since c++26 (edit)
Template:mark tfun (view source) (protected)
Template:mark until c++17 (edit)
Template:mark until c++26 (edit)
Template:navbar (edit)
Template:navbar editlink (view source) (protected)

cppreference.com

Namespaces

Variants

Views

Actions

View source for cpp/algorithm/ranges/remove copy