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

定义在头文件 `<algorithm>` 中
调用签名
	(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 remove_copy_result<I, O> remove_copy( I first, S last, O result, const T& value, Proj proj = {} );			(自 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 = {} );			(自 C++26 起)
		(2)
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 = {} );				(自 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 = {} );				(自 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。

[编辑] 备注

该算法是稳定的，即保留了复制元素的相对顺序。

功能测试宏	值	Std	功能
`__cpp_lib_algorithm_default_value_type`	202403	(C++26)	算法的列表初始化 (1,2)

[编辑] 可能的实现

remove_copy

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

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()
{
    // 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(); }
    );
 
    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 gets deduced to 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::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	复制元素范围，省略满足特定条件的元素 (函数模板) [编辑]

编译器支持
独立和托管
语言
标准库
标准库头文件
命名要求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作