每日新知识

iota

示例 1：填充 std::vector 从 0 到 n-1

int main() {
    int n = 10; // 设置 n 的值
    std::vector<int> vec(n); // 创建一个大小为 n 的 vector
    // 使用 std::iota 填充 vector
    std::iota(vec.begin(), vec.end(), 0); // 从 0 开始填充// 输出结果
    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
	return 0;
}

accumulate

示例 1：计算整数的总和

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 使用 std::accumulate 计算总和
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    std::cout << "Total sum: " << sum << std::endl; // 输出：Total sum: 15return 0;
}

示例 2：计算乘积

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 使用 std::accumulate 计算乘积
    int product = std::accumulate(numbers.begin(), numbers.end(), 1, std::multiplies<int>());
    std::cout << "Total product: " << product << std::endl; // 输出：Total product: 120return 0;
}

示例 3：使用自定义操作
您还可以提供自定义的操作，例如计算字符串的连接：

int main() {
    std::vector<std::string> words = {"Hello", " ", "World", "!"};
    // 使用 std::accumulate 连接字符串
    std::string result = std::accumulate(words.begin(), words.end(), std::string());
    std::cout << "Concatenated string: " << result << std::endl; // 输出：Concatenated string: Hello World!return 0;
}

static

写在函数中：静态局部变量。作用域为单次函数执行
写在函数外类内，静态成员变量。所有类的实例共享一个静态成员变量。它在类的所有对象之间是共享的
写在函数外类外的文件中：静态全局变量，作用域仅限于定义它的文件，其他文件无法访问。如果写在了头文件中，相当于包含这个头文件的文件中自定义了一个静态全局变量作用于本文件，即每个文件各得到了变量的副本，各文件中对这个变量的操作不影响原始头文件中的这个变量。
静态成员函数：静态成员函数是属于类而不是属于某个特定对象的函数。静态成员函数只能访问静态成员变量和静态成员函数。

for_each

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

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

    // 输出原始 vector 的内容
    std::cout << "Original vector: ";
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 使用 lambda 表达式将每个值改为 0
    std::for_each(numbers.begin(), numbers.end(), [](int& n) { n = 0; });

    // 输出修改后的 vector 的内容
    std::cout << "Modified vector: ";
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Lambda

#include <iostream>

int main() {
    int x = 10;
    int y = 20;

    // 定义一个 lambda 表达式，按引用捕获外部变量 x 和 y
    auto modify = [&x, &y](int a) {
        x += a; // 修改 x
        y += a; // 修改 y
        std::cout << "x: " << x << ", y: " << y << std::endl;
    };

    modify(5); // 调用 lambda 表达式
    return 0;
}