【C++之泛型算法】012元素替换

replace()

在 C++ 中，替换容器（如 std::vector、std::list、std::string 等）中的元素，你可以使用标准库提供的泛型算法 std::replace。这个算法会遍历指定的元素范围，并将等于给定旧值的元素替换为新值。

下面是一个使用 std::replace 的例子，该例子将 std::vector 中所有的旧值 old_value 替换为新值 new_value：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个包含整数的向量
    std::vector<int> numbers = {1, 2, 3, 2, 4, 2, 5};

    // 定义要替换的旧值和新值
    int old_value = 2;
    int new_value = 99;

    // 使用 std::replace 算法替换所有旧值为新值
    std::replace(numbers.begin(), numbers.end(), old_value, new_value);

    // 打印替换后的向量内容
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出将会是：

1 99 3 99 4 99 5

在这个例子中，所有的 2 都被替换成了 99。

std::replace 的函数签名如下：

template< class ForwardIt, class T >
ForwardIt replace( ForwardIt first, ForwardIt last, const T& old_value, const T& new_value );

• first 和 last 是迭代器，定义了要操作的范围。
• old_value 是要被替换的旧值。
• new_value 是要替换成的新值。

std::replace 返回一个迭代器，指向替换操作后范围的最后一个元素之后的位置。

如果你需要替换的元素满足特定的条件，而不是简单地等于某个值，你可以使用 std::replace_if 算法，它允许你提供一个谓词（即一个返回 bool 的函数或函数对象）来确定哪些元素应该被替换。

replace_if()

在 C++ 中，std::replace_if 是一个泛型算法，它用于替换容器中满足特定条件的元素。这个算法接受一个范围（由开始和结束迭代器指定），一个断言（一个返回布尔值的函数或函数对象），以及一个值，用于替换满足断言的元素。

下面是一个使用 std::replace_if 的例子，这个例子将替换向量中所有偶数元素为 -1：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个包含整数的向量
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 使用 std::replace_if 替换所有偶数为 -1
    std::replace_if(numbers.begin(), numbers.end(), [](int n) { return n % 2 == 0; }, -1);

    // 打印替换后的向量内容
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们使用了 lambda 表达式 [](int n) { return n % 2 == 0; } 作为断言。这个 lambda 表达式检查一个数是否是偶数。对于向量中的每个元素，如果这个断言为真（即元素是偶数），那么该元素就会被替换为 -1。

std::replace_if 的函数签名如下：

template< class ForwardIt, class UnaryPredicate, class T >
ForwardIt replace_if( ForwardIt first, ForwardIt last, UnaryPredicate p, const T& new_value );

• first 和 last 是迭代器，定义了要操作的范围。
• p 是一个一元谓词（Unary Predicate），它是一个返回布尔值的函数或函数对象，用于测试元素是否应该被替换。
• new_value 是用来替换满足谓词的元素的新值。

std::replace_if 返回一个迭代器，指向替换操作后范围的最后一个元素之后的位置。

replace_copy()

在C++标准库中，std::replace_copy是一个泛型算法，它用于复制一个范围内的元素到另一个范围，同时替换满足特定条件的元素。这个算法接受源范围的开始和结束迭代器、目标范围的开始迭代器，以及一个断言（一个返回布尔值的函数或函数对象）和一个用于替换的值。

下面是一个使用std::replace_copy的例子，该例子从一个std::vector复制元素到另一个std::vector，同时将所有偶数替换为-1：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个包含整数的源向量
    std::vector<int> source = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 创建一个足够大的目标向量来存储复制和替换后的元素
    std::vector<int> destination(source.size());

    // 使用std::replace_copy复制元素并替换偶数
    auto it = std::replace_copy(source.begin(), source.end(), destination.begin(), [](int n) { return n % 2 == 0; }, -1);

    // 调整目标向量的大小以移除尾部的未使用空间
    destination.resize(it - destination.begin());

    // 打印替换和复制后的目标向量内容
    for (int num : destination) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们定义了一个lambda表达式[](int n) { return n % 2 == 0; }来检查一个数是否是偶数。对于源向量中的每个元素，如果这个断言为真（即元素是偶数），那么该元素就会被替换为-1，并且在复制过程中放到目标向量的相应位置。

std::replace_copy的函数签名如下：

template< class InputIt, class OutputIt, class UnaryPredicate, class T >
OutputIt replace_copy( InputIt first1, InputIt last1, OutputIt d_first, UnaryPredicate p, const T& new_value );

• first1和last1定义了源范围的开始和结束迭代器。
• d_first是目标范围的开始迭代器，std::replace_copy将把复制和（可能）替换后的元素放到这里。
• p是一个一元谓词，用于确定哪些元素应该被替换。
• new_value是用来替换满足谓词的元素的新值。

std::replace_copy返回一个迭代器，指向目标范围中最后一个插入元素之后的位置。在这个例子中，我们用这个迭代器来调整目标向量的大小，以移除任何未使用的尾部空间。

replace_copy_if()

在C++标准库中，std::replace_copy_if是一个泛型算法，它用于复制一个范围内的元素到另一个范围，同时仅替换满足特定条件的元素。这个算法类似于std::replace_if，但它不修改原始范围，而是将结果复制到另一个容器中。

std::replace_copy_if接受源范围的开始和结束迭代器、目标范围的开始迭代器、一个断言（一个返回布尔值的函数或函数对象）以及一个用于替换的值。算法会遍历源范围中的每个元素，如果元素满足断言的条件，则将其替换为新值，并复制到目标范围。

下面是一个使用std::replace_copy_if的例子，该例子从一个std::vector复制元素到另一个std::vector，但仅替换源向量中所有偶数为-1：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个包含整数的源向量
    std::vector<int> source = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 创建一个足够大的目标向量来存储复制和替换后的元素
    std::vector<int> destination(source.size());

    // 使用std::replace_copy_if复制元素并替换满足条件的元素
    auto it = std::replace_copy_if(source.begin(), source.end(), destination.begin(), [](int n) {
        return n % 2 == 0; // 断言：元素是偶数
    }, -1); // 替换值为-1

    // 调整目标向量的大小以移除尾部的未使用空间
    destination.resize(it - destination.begin());

    // 打印替换和复制后的目标向量内容
    for (int num : destination) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们定义了一个lambda表达式[](int n) { return n % 2 == 0; }来检查一个数是否是偶数。对于源向量中的每个元素，如果这个断言为真（即元素是偶数），那么该元素就会被替换为-1，并且在复制过程中放到目标向量的相应位置。

std::replace_copy_if的函数签名如下：

template< class InputIt, class OutputIt, class UnaryPredicate, class T >
OutputIt replace_copy_if( InputIt first1, InputIt last1, OutputIt d_first, UnaryPredicate p, const T& new_value );

• first1和last1定义了源范围的开始和结束迭代器。
• d_first是目标范围的开始迭代器，std::replace_copy_if将把复制和（可能）替换后的元素放到这里。
• p是一个一元谓词，用于确定哪些元素应该被替换。
• new_value是用来替换满足谓词的元素的新值。

std::replace_copy_if返回一个迭代器，指向目标范围中最后一个插入元素之后的位置。在这个例子中，我们用这个迭代器来调整目标向量的大小，以移除任何未使用的尾部空间。