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 ) 번의 해당 predicate comp 및 projection proj 적용이 수행됩니다.

참고 사항

알고리즘은 안정적입니다. 즉, 복사된 요소들의 상대적 순서를 유지합니다.

기능 테스트 매크로	값	표준	기능
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	알고리즘을 위한 목록 초기화 ( 1,2 )

가능한 구현

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)
기술 사양
기호 색인
외부 라이브러리

ko.cppreference.net

Namespaces

Variants

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

목차

매개변수

반환값

복잡도

참고 사항

가능한 구현

예제

참고 항목