【C++之泛型算法】011赋值

fill()

std::fill 是 C++ 标准库中的一个泛型算法，用于将指定范围内的所有元素设置为给定的值。这个算法接受一对迭代器（表示范围的开始和结束），以及一个值，然后它将该值复制到范围内的所有元素中。

下面是一个使用 std::fill 的简单示例，该示例将一个 std::vector 中的所有元素设置为同一个值：

#include <iostream>
#include <vector>
#include <algorithm> // for std::fill

int main() {
    // 创建一个包含一些整数的向量
    std::vector<int> numbers(5); // 默认构造，元素未初始化

    // 使用std::fill将向量中的所有元素设置为同一个值，比如10
    std::fill(std::begin(numbers), std::end(numbers), 10);

    // 输出向量中的元素，以验证它们是否都被设置为10
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，std::fill 算法将 numbers 向量中的所有元素都设置为了 10。输出结果应该是：

10 10 10 10 10

std::fill 是一个非常有用的算法，尤其是当你需要初始化一个容器为特定值，或者需要快速将一个范围内的所有元素设置为同一个值时。

你也可以使用 std::fill_n 算法，它允许你指定要填充的元素数量，而不是使用整个范围。这在你知道需要填充的确切数量时非常有用，而不需要知道整个容器的大小。

#include <iostream>
#include <vector>
#include <algorithm> // for std::fill_n

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

    // 使用std::fill_n将向量中的前3个元素设置为同一个值，比如42
    std::fill_n(std::begin(numbers), 3, 42);

    // 输出向量中的元素，以验证前3个元素是否都被设置为42
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

这个例子的输出将是：

42 42 42 4 5

这里，std::fill_n 只将 numbers 向量中的前三个元素设置为了 42。

fill_n()

fill_n() 是一个泛型算法，这意味着它可以用于任何类型的序列容器，如数组、向量、列表等，只要这些容器提供了迭代器。这个算法用于将指定范围内的前 n 个元素设置为给定的值。

下面是 fill_n() 的详细用法：
函数签名

template <class ForwardIt, class T>
ForwardIt fill_n(ForwardIt first, size_t n, const T& value);

• ForwardIt first：指向要填充的第一个元素的迭代器。
• size_t n：要填充的元素数量。
• const T& value：要设置的值。

返回值

fill_n() 返回一个迭代器，它指向填充操作之后的那个位置的下一个元素。

填充 std::vector

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 填充向量的前 4 个元素为 20
    std::fill_n(vec.begin(), 4, 20);

    // 打印向量内容
    for (int num : vec) {
        std::cout << num << ' ';
    }
    std::cout << std::endl;

    return 0;
}

输出：

20 20 20 20 5

generate()

generate() 是 C++ 标准库中的一个泛型算法，用于生成一个序列中的元素。这个算法定义在 头文件中。generate() 接受一个输出迭代器（表示序列的开始位置），一个表示元素数量的迭代器（通常是一个表示结束位置的迭代器），以及一个生成器函数（或可调用对象），该函数或对象用于生成每个元素的值。

生成器函数是一个接受单个参数（通常是当前元素的索引）的可调用对象，它返回要插入到序列中的值。

下面是一个使用 generate() 的简单示例：

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

// 生成器函数，返回一个随机数
int random_number() {
    return rand() % 100; // 生成 0 到 99 之间的随机数
}

int main() {
    // 创建一个包含 10 个整数的向量
    std::vector<int> numbers(10);

    // 使用当前时间作为随机数生成器的种子
    std::srand(std::time(nullptr));

    // 使用 generate() 生成 10 个随机数并存储在向量中
    std::generate(numbers.begin(), numbers.end(), random_number);

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

    return 0;
}

在这个示例中，generate() 算法使用 random_number() 函数生成的随机数来填充 numbers 向量。random_number() 函数简单地返回一个 0 到 99 之间的随机数。

输出将是一系列随机数，如下所示：

45 89 23 67 12 98 34 56 78 19

每次运行程序时，由于使用了当前时间作为随机数生成器的种子，生成的随机数序列都会不同。

需要注意的是，generate() 算法不会检查提供的迭代器是否有效或是否越界。因此，在使用它时，你应该确保迭代器指向有效的内存位置，并且提供的迭代器范围是有效的。此外，生成器函数也应该正确地处理任何可能的输入参数。

generate_n()

generate_n() 是 C++ 标准库中的一个泛型算法，用于生成指定范围内的元素。与 fill_n() 不同，generate_n() 使用一个生成器函数（或可调用对象）来产生每个元素的值，而不是填充一个固定的值。

下面是 generate_n() 的函数签名：

template <class OutputIt, class Size, class Generator>
OutputIt generate_n(OutputIt first, Size count, Generator g);

OutputIt first：指向要生成元素的范围的第一个位置的输出迭代器。
Size count：要生成的元素数量。
Generator g：一个可调用对象，用于生成每个元素的值。它接受一个参数（通常是元素的索引），并返回一个新值。

generate_n() 返回一个迭代器，它指向生成的最后一个元素之后的位置。

下面是一个使用 generate_n() 的示例：

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

// 生成器函数，根据索引生成一个随机数
int random_number_generator(int index) {
    return rand() % 100 + index; // 生成一个基于索引的随机数
}

int main() {
    // 创建一个包含 5 个整数的向量
    std::vector<int> numbers(5);

    // 使用当前时间作为随机数生成器的种子
    std::srand(std::time(nullptr));

    // 使用 generate_n() 生成 5 个随机数并存储在向量中
    std::generate_n(numbers.begin(), numbers.size(), random_number_generator);

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

    return 0;
}

在这个示例中，generate_n() 使用 random_number_generator 函数来生成 5 个随机数，并将这些数存储在 numbers 向量中。random_number_generator 函数接受一个索引参数，但在这个例子中我们没有使用它；我们只是简单地生成了一个随机数。

输出将是一系列随机数，如下所示：

45 18 67 29 83

每次运行程序时，由于使用了当前时间作为随机数生成器的种子，生成的随机数序列都会不同。

需要注意的是，和 fill_n() 一样，generate_n() 不会检查提供的迭代器是否有效或越界，也不会检查生成器函数是否正确定义。这些都是编程者的责任。

iota()

C++标准库中的iota算法是一个范型算法，用于按顺序填充一个指定范围的数值。它有两个重载版本：

• iota(first, last, value)：用连续递增的值填充[first, last)范围内的元素。起始值为value，之后每个元素的值依次递增。
• iota(first, last, generator)：用生成器(generator)函数生成的值填充[first, last)范围内的元素。生成器函数接受一个整型参数，生成并返回相应位置的值。

以下是使用iota算法的示例代码：

#include <iostream>
#include <vector>
#include <numeric> // 包含iota算法的头文件

int main() {
    std::vector<int> vec(5); // 创建一个大小为5的向量

    // 使用iota算法填充向量，起始值为1，递增1
    std::iota(vec.begin(), vec.end(), 1);

    // 输出向量中的元素
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

输出结果为：1 2 3 4 5

这个示例代码使用iota算法填充了一个大小为5的向量，起始值为1，递增1。然后循环输出了向量中的元素。你可以根据需要修改起始值、递增值或生成器函数来填充不同的数据范围。