C++标准库算法整理

news2025/7/17 23:59:37

目录

1、数值操作

1.1、std::accumulate

1.2、std::inner_product

1.3、std::partial_sum

1.4、std::exclusive_scan

1.5、std::inclusive_scan

1.6、std::reduce

2、相邻元素

2.1、std::adjacent_difference

2.2、std::adjacent_find

 2.3、std::unique

2.4、std::unique_copy

3、是否满足条件

3.1、std::all_of

3.2、std::any_of

3.3、std::none_of

4、二分查找

4.1、std::binary_search

4.2、std::bsearch

4.3、std::lower_bound

4.4、std::upper_bound

4.5、std::equal_range

5、限制范围

5.1、std::clamp

6、复制

6.1、std::copy

6.2、std::copy_if

6.3、std::copy_backward

6.4、std::copy_n

7、计数

7.1、std::count

7.2、std::count_if

8、比较

8.1、std::equal

8.2、std::lexicographical_compare

8.3、std::lexicographical_compare_three_way

9、填充元素

9.1、std::fill

9.2、std::fill_n

9.3、std::generate

9.4、std::generate_n

9.5、std::iota

10、查找、搜索

10.1、std::find

10.2、std::find_if

10.3、std::find_if_not

10.4、std::find_end

10.5、std::find_first_of

10.6、std::search

10.7、std::search_n

10.8、std::mismatch

11、集合操作

11.1、std::includes

11.2、std::set_difference

11.3、std::set_intersection

11.4、std::set_symmetric_difference

11.5、std::set_union

12、合并

12.1、std::inplace_merge

12.2、std::merge

13、堆

13.1、std::make_heap

13.2、std::is_heap

13.3、std::push_heap

13.4、std::pop_heap

13.5、std::sort_heap

13.6、std::is_heap_until

14、排列

14.1、std::is_permutation

14.2、std::next_permutation

14.3、std::prev_permutation

15、最值

15.1、std::max 、std::min

15.2、std::max_element、std::min_element

15.3、std::minmax

15.4、std::minmax_element

16、移动元素

16.1、std::move

16.2、std::move_backward

17、排序

17.1、不完全排序

17.1.1、std::nth_element

17.2、部分排序

17.2.1、std::partial_sort

17.2.2、std::partial_sort_copy

17.3、快速排序

17.3.1、std::qsort

17.3.2、std::sort

17.4、稳定排序

17.4.1、std::stable_sort

17.5、判断是否有序

17.5.1、std::is_sorted

17.6、最长有序子序列

17.6.1、std::is_sorted_until

18、按条件划分

18.1、std::stable_partition

18.2、std::partition

18.3、std::partition_copy

18.4、std::partition_point

18.5、std::is_partitioned

19、移除

19.1、std::remove

63.2、std::remove_if

63.3、std::remove_copy

63.4、std::remove_copy_if

20、替换

20.1、std::replace

20.2、std::replace_if

20.3、std::replace_copy

20.4、std::replace_copy_if

21、反转元素

21.1、std::reverse

21.2、std::reverse_copy

22、循环右移

22.1、std::rotate

22.2、std::rotate_copy

23、随机操作

23、随机采样

23.1.1、std::sample

23.2、随机重排

23.2.1、std::shuffle

24、交换

24.1、std::swap

24.2、std::swap_ranges

24.3、std::iter_swap

25、对每个元素应用指定操作

25.1、for_each

25.1.1、std::for_each

25.1.2、std::for_each_n

25.2、transform

25.2.1、std::transform

25.2.2、std::transform_exclusive_scan

25.2.3、std::transform_inclusive_scan

25.2.4、std::transform_reduce

26、算法执行策略

27、策略控制器

1、数值操作

1.1、std::accumulate

元素累加。

1.2、std::inner_product

计算两个范围的内积。

1.3、std::partial_sum

累加求和。

1.4、std::exclusive_scan

序列的累计运算。此函数接受一个范围的输入序列，并将计算结果存储到另一个容器中。它通过对每个元素应用一个二元操作符，将当前元素与其前面的所有元素进行计算，并将计算结果累计到输出容器中。

int main(int argc, char *argv[])
{
    QVector<int> vec = {2,3,4,5,6};
    QVector<int> result(vec.size());

    //第一个元素就是初始值1， 从第二个开始依次乘以前面的数，最后一个元素不进行计算;前一次的结果会做为后一次的第一个参数
    std::exclusive_scan(vec.begin(), vec.end(), result.begin(), 1, [](int a,int b){return a * b;});

    qDebug() << result;//1 1*2 1*2*3 1*2*3*4 1*2*3*4*5
}

1.5、std::inclusive_scan

对一个序列中的元素进行累积操作。结果是计算出一个新的序列，新序列中的每个元素都是原序列中当前位置以及之前位置的元素的累积和。

#include <QVector>
#include <QtDebug>
#include <numeric>

int main(int argc, char *argv[])
{
    QVector<int> numbers = {1, 2, 3, 4, 5};

    QVector<int> result(numbers.size());
    std::inclusive_scan(numbers.begin(), numbers.end(), result.begin());

    // 使用 qDebug 输出每个元素的累积和
    qDebug() << "累积和：";
    for (const auto& num : result) {
        qDebug() << num;
    }
}

/*
累积和：
1
3
6
10
15
*/

1.6、std::reduce

在范围内进行归约操作，并返回结果。（将一系列的输入元素通过重复应用某个操作符将它们合并成一个简单的结果）它可以用于对一个范围内的元素进行求和、求积、最大值、最小值等操作。

//例1：求和

    QVector<int> numbers = {1, 2, 3, 4, 5};
    int sum = std::reduce(numbers.begin(), numbers.end(), 0);
    qDebug() << "Sum:" << sum;

//例2：找到 QStringList 中最长的字符串
    QString longest = std::reduce(words.begin(), words.end(), QString(),[](const QString &current, const QString &next) 
                                                                        {
                                                                            return current.length() > next.length() ? current : next;
                                                                        });

//例3：将 QMap 的值相加
    int totalScore = std::reduce(scores.begin(), scores.end(), 0,[](int current, const QString &, int score) 
                                                                {
                                                                    return current + score;
                                                                });

2、相邻元素

2.1、std::adjacent_difference

计算指定范围内的相邻元素的差值，并将结果存储到另一个范围中。

2.2、std::adjacent_find

在指定范围内查找相邻的重复元素，并返回第一个匹配的元素的迭代器。

 2.3、std::unique

移除指定范围内的连续重复元素，返回一个新的范围。

2.4、std::unique_copy

类似于 std::unique，但是它将移除的重复元素复制到另一个容器。

3、是否满足条件

3.1、std::all_of

判断指定范围内的所有元素是否都满足指定条件。

3.2、std::any_of

判断指定范围内的任意一个元素是否满足指定条件。

3.3、std::none_of

判断指定范围内的所有元素是否都不满足指定条件。

4、二分查找

在已排序范围内进行二分查找，判断指定的值是否存在。

4.2、std::bsearch

与 std::binary_search 功能相似，用于在 C 风格数组中进行二分查找。

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int main(int argc, char *argv[])
{
    int arr[] = {2, 5, 8, 12, 18, 23, 28, 32};
    int key = 18;
    int size = sizeof(arr) / sizeof(arr[0]);

    int* found = (int*)std::bsearch(&key, arr, size, sizeof(int), compare);

    if(found != nullptr) {
        qDebug() << "在数组中找到元素！"<<*found;
    } else {
        qDebug() << "在数组中未找到元素！";
    }

    return 0;
}

//在数组中找到元素！ 18

4.3、std::lower_bound

获取序列中大于等于某元素的第一个元素。

4.4、std::upper_bound

与std::lower_bound类似。获取序列中大于某元素的第一个元素。

4.5、std::equal_range

在已排序范围内查找某个值的等值区间。

5、限制范围

5.1、std::clamp

将指定的值限制在给定的范围内，返回最接近的边界值。c++17以上才支持。

#include <algorithm>

int main(int argc, char *argv[])
{
    int value = 20;
    int minValue = 5;
    int maxValue = 15;

    int clampedValue = std::clamp(value, minValue, maxValue);

    qDebug() << "范围限制后的值：" << clampedValue;

    return 0;
}

6、复制

6.1、std::copy

将指定范围内的元素复制到另一个范围中。

6.2、std::copy_if

将满足指定条件的元素从指定范围中复制到另一个范围中。

6.3、std::copy_backward

将指定范围内的元素逆向复制到另一个范围中。

6.4、std::copy_n

将指定数量的元素从指定范围复制到另一个范围中。

7、计数

7.1、std::count

计算指定范围内等于给定值的元素的个数。

7.2、std::count_if

计算指定范围内满足给定条件的元素的个数。

8、比较

8.1、std::equal

判断两个范围内的元素是否相等。

8.2、std::lexicographical_compare

按字典顺序比较两个范围。

8.3、std::lexicographical_compare_three_way

与std::lexicographical_compare类似，二者区别：

  • std::lexicographical_compare 比较两个范围的元素，并确定它们在字典序上的相对顺序。它返回一个布尔值，指示第一个范围是否在字典序上小于第二个范围。
  • std::lexicographical_compare_three_way 进行三路比较，比较两个范围的元素在字典序上的关系。它返回一个三路比较的结果，表示两个范围在字典序上的关系：小于、等于或大于。

9、填充元素

9.1、std::fill

用指定的值填充给定范围内的元素。

9.2、std::fill_n

用指定的值填充给定范围内的前 n 个元素。

9.3、std::generate

用生成器函数生成给定范围内的元素。

#include <QVector>
#include <algorithm>
#include <random>
#include <iostream>

int main(int argc, char *argv[])
{
    QVector<int> numbers(10);  // 定义一个包含10个元素的向量

    std::random_device rd;  // 随机设备，用于生成随机数种子
    std::mt19937 gen(rd()); // 随机数引擎，用于生成随机数

    std::generate(numbers.begin(), numbers.end(), [&gen]() {
        return gen() % 100;  // 生成0-99的随机数
    });

    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

9.4、std::generate_n

用生成器函数生成给定范围内的前 n 个元素。

9.5、std::iota

用依次递增的值填充给定范围。

10、查找、搜索

10.1、std::find

查找指定值的元素。

10.2、std::find_if

查找满足特定条件的元素。

10.3、std::find_if_not

查找不满足特定条件的元素。

10.4、std::find_end

查找最后一次出现另一个范围的位置。

10.5、std::find_first_of

查找第一个与指定范围中的任何一个元素匹配的元素。

10.6、std::search

搜索一个子序列，并返回指向第一个匹配子序列的迭代器。

10.7、std::search_n

搜索连续出现指定数量的某个值，并返回指向这段连续值的迭代器。

10.8、std::mismatch

在两个范围中查找第一个不匹配的元素，并返回一个包含指向两个范围中不匹配元素的迭代器的 std::pair 对象。

int main(int argc, char *argv[])
{
    QVector<int> vec1 = {1, 2, 3, 4};
    QVector<int> vec2 = {1, 2, 5, 4, 6};

    auto result = std::mismatch(vec1.begin(), vec1.end(), vec2.begin());

    if (result.first != vec1.end() && result.second != vec2.end()) {
        qDebug() << "第一个不匹配的元素:";
        qDebug() << "vec1: " << *(result.first);
        qDebug() << "vec2: " << *(result.second);
    } else {
        qDebug() << "范围没有不匹配的元素";
    }
}

11、集合操作

11.1、std::includes

是否包含。

11.2、std::set_difference

差集。

11.3、std::set_intersection

交集。

11.4、std::set_symmetric_difference

对称差集。

11.5、std::set_union

并集。

12、合并

12.1、std::inplace_merge

将一个序列中两个有序的子序列合并成一个有序的子序列。

12.2、std::merge

将两个已排序的范围合并为一个已排序的范围。

13、堆

堆是一个完全二叉树：堆中的所有层级都是完全填满的，最后一层可以部分填满，而且所有节点都尽可能靠左排列。

堆中每个节点的值都满足堆特性：即每个节点的值都大于或小于它的子节点（取决于堆是最大堆还是最小堆）。

根据堆特性的不同，堆可以分为两种类型：

  • 最大堆（Max Heap）：在最大堆中，每个节点的值都大于或等于其子节点的值。因此，根节点是堆中的最大值。
  • 最小堆（Min Heap）：在最小堆中，每个节点的值都小于或等于其子节点的值。因此，根节点是堆中的最小值。

13.1、std::make_heap

将一个范围转换为堆结构。

13.2、std::is_heap

判断给定范围内的元素是否满足堆的特性。

#include <QDebug>
#include <algorithm>
#include <QVector>

int main(int argc, char *argv[])
{
    QVector<int> vec = {4, 7, 9, 10, 5, 8};

    // 检查整个容器是否满足堆的特性（默认为最大堆）
    bool isHeap = std::is_heap(vec.begin(), vec.end());

    qDebug() << "Is heap:" << (isHeap ? "true" : "false");

    std::make_heap(vec.begin(), vec.end()); // 将容器转换为堆

    // 再次检查整个容器是否满足堆的特性
    isHeap = std::is_heap(vec.begin(), vec.end());

    qDebug() << "Is heap:" << (isHeap ? "true" : "false");
    qDebug() << vec;
}

13.3、std::push_heap

将指定范围内的元素插入到容器中，并调整剩余元素的顺序，使其符合堆的规则。

13.4、std::pop_heap

将容器中的最大元素移动到末尾，并调整剩余元素的顺序，使其符合堆的规则。

#include <QDebug>
#include <algorithm>
#include <QVector>

int main(int argc, char *argv[])
{
    QVector<int> numbers = {4, 2, 8, 5, 1, 7};

    // 将容器转换为堆
    std::make_heap(numbers.begin(), numbers.end());

    // 插入新元素并调整堆结构
    numbers.push_back(3);
    std::push_heap(numbers.begin(), numbers.end());

    qDebug() << "堆排序前: " << numbers;

    // 弹出堆顶元素（最大值）
    std::pop_heap(numbers.begin(), numbers.end());
    int max = numbers.back();
    numbers.pop_back();

    qDebug() << "弹出的最大值: " << max;
    qDebug() << "堆排序后: " << numbers;
}

13.5、std::sort_heap

将堆范围转换为有序范围。

    QVector<int> vec = {9, 4, 6, 2, 1, 8, 5};

    std::make_heap(vec.begin(), vec.end()); // 创建一个最大堆
    qDebug() << "最大堆初始状态："<<vec;

    std::sort_heap(vec.begin(), vec.end()); // 使用 sort_heap 进行堆排序
    qDebug() << "堆排序后的数组："<<vec;

13.6、std::is_heap_until

确定范围内的元素是否构成堆，并返回指向不满足堆属性的第一个元素的迭代器。

    QVector<int> vec = {9, 4, 6, 2, 1, 8, 5};

    auto iter = std::is_heap_until(vec.begin(), vec.end());

    if (iter != vec.end()) {
        int index = std::distance(vec.begin(), iter);
        qDebug() << "不满足堆属性的元素位置：" << index;
    } else {
        qDebug() << "整个范围满足堆属性";
    }

第5个元素8不满足小于其父节点6的要求。

14、排列

14.1、std::is_permutation

检查序列是否是另一序列的排列。

14.2、std::next_permutation

重新排列范围内的元素，返回按照字典序排列的下一个值较大的组合。

14.3、std::prev_permutation

和std::next_permutation类似不过每次返回按字典序排序的相对当前序列较小的值。

15、最值

15.1、std::max 、std::min

返回两个值中较大、较小者。

15.2、std::max_element、std::min_element

查找最大值、最小值的位置。

15.3、std::minmax

查找最小和最大元素，返回一个包含最小和最大元素的 std::pair 对象。

15.4、std::minmax_element

同时找到给定范围内的最小和最大元素，返回一个包含指向最小和最大元素的迭代器的 std::pair 对象。

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

    auto result = std::minmax_element(vec.begin(), vec.end());

    auto minIter = result.first;
    auto maxIter = result.second;

    std::cout << "最小元素: " << *minIter << std::endl;
    std::cout << "最大元素: " << *maxIter << std::endl;

16、移动元素

16.1、std::move

将指定范围内的元素转移到另一个位置。

#define debug qDebug()<<
int main(int argc, char *argv[])
{
    QVector<QString> vec;

    for (int i = 0; i < 5; ++i)
    {
        vec.append(QString("xx%1").arg(i));  // 向 QVector 中添加元素
    }
    vec.resize(10);  // 调整 QVector 的大小为 10

    debug  "vec:" << vec;  // 输出 QVector 初始状态

    std::move(vec.begin(), vec.begin() + 2, vec.end() - 2);  // 使用 std::move 移动元素

    debug "vec:" << vec;  // 输出移动后的 QVector
}

16.2、std::move_backward

与 std::move 类似，但是它以反向顺序进行移动。用于将元素的值从一个范围内的位置移动到另一个范围内的位置，并保持原始顺序的逆序。

#define debug qDebug()<<
int main(int argc, char *argv[])
{
    QList<int> sourceVec = {1, 2, 3, 4, 5};
    QList<int> destVec;
    destVec.reserve(5); // 预分配内存空间

    for (int i = 0; i < 5; ++i)
    {
        destVec.append(0); // 在列表末尾添加元素
    }
    debug destVec;

    std::move_backward(sourceVec.begin(), sourceVec.end()-1, destVec.end());

    debug sourceVec;
    debug destVec;

    return 0;
}

17、排序

17.1、不完全排序

17.1.1、std::nth_element

不完全排序。

17.2、部分排序

17.2.1、std::partial_sort

部分排序，使得排序后的前一部分元素符合特定的顺序。

17.2.2、std::partial_sort_copy

部分排序，并将排序结果复制到另一个容器中。

17.3、快速排序

17.3.1、std::qsort

对给定范围内的元素进行快速排序。参数为数组。

17.3.2、std::sort

对指定范围内的元素进行排序。

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

bool compare(int a, int b) {
    return a > b;  // 降序排序
}

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

    // 对容器中的元素进行降序排序
    std::sort(nums.begin(), nums.end(), compare);

    // 输出结果
    for (const auto& num : nums) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

17.4、稳定排序

17.4.1、std::stable_sort

对指定范围内的元素进行稳定排序。

17.5、判断是否有序

17.5.1、std::is_sorted

判断序列是否有序。

17.6、最长有序子序列

17.6.1、std::is_sorted_until

查找初始最长有序子序列。

18、按条件划分

18.1、std::stable_partition

将满足条件的元素放到前面，不满足条件的元素放到后面。

18.2、std::partition

和stable_partition类似，但不会保证结果序列在原来序列的相对顺序，并返回一个指向满足条件的最后一个元素的迭代器。

18.3、std::partition_copy

类似于 std::partition，但是将满足条件和不满足条件的元素分别复制到两个不同的容器中。

18.4、std::partition_point

在已划分的有序区间中查找第一个不满足某个条件的元素。

18.5、std::is_partitioned

检查一个范围是否被划分为满足指定条件的元素和不满足指定条件的元素两个部分。

19、移除

19.1、std::remove

移除指定范围内的元素，返回一个新的范围，其中被移除的元素被放置在范围的末尾。但此函数并不是真正地删除元素，而是将元素移动到范围尾部并返回新的范围。

63.2、std::remove_if

与 std::remove 类似，但是它可以使用一个谓词来决定是否要移除元素。

63.3、std::remove_copy

类似于 std::remove，但是它将移除的元素复制到另一个容器。

63.4、std::remove_copy_if

类似于 std::remove_if，它将移除元素的副本复制到另一个容器。

20、替换

20.1、std::replace

用指定的新值替换给定范围内的所有旧值。

20.2、std::replace_if

类似于 std::replace，但是它可以使用一个谓词来决定是否要替换值。

20.3、std::replace_copy

类似于 std::replace，但是它将替换的副本复制到另一个容器。

20.4、std::replace_copy_if

类似于 std::replace_if，它将替换元素的副本复制到另一个容器。

21、反转元素

21.1、std::reverse

反转给定范围内的元素顺序。

21.2、std::reverse_copy

类似于 std::reverse，但是它将反转的副本复制到另一个容器。

22、循环右移

22.1、std::rotate

将给定范围内的元素循环右移。

22.2、std::rotate_copy

类似于 std::rotate，但是它将循环右移的副本复制到另一个容器。

23、随机操作

23、随机采样

23.1.1、std::sample

从指定的范围中随机选择一定数量的元素，并将选中的元素存储到另一个容器中。

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

int main(int argc, char *argv[])
{
    QVector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    QVector<int> sampledNumbers(5); // 存储抽样结果的容器

    // 随机数引擎和分布器
    std::random_device rd;
    std::mt19937 gen(rd());

    // 执行抽样
    std::sample(numbers.begin(), numbers.end(), sampledNumbers.begin(), 5, gen);

    // 输出抽样结果
    qDebug() << "Sampled numbers:"<<sampledNumbers;
}

23.2、随机重排

23.2.1、std::shuffle

随机重新排列给定范围内的元素，可以指定自定义的随机数引擎。

24、交换

24.1、std::swap

std::swap 函数是一个通用的交换函数，可以用于交换绝大多数类型的对象。它的实现会通过移动语义或拷贝语义来保证高效的值交换。类的交换函数。

24.2、std::swap_ranges

交换两个范围内的元素。

24.3、std::iter_swap

交换两个迭代器指向的元素。

25、对每个元素应用指定操作

25.1、for_each

25.1.1、std::for_each

对给定范围内的每个元素应用指定的操作。

25.1.2、std::for_each_n

对给定范围内的前 n 个元素应用指定的操作。

#include <iostream>
#include <algorithm>

int main()
{
    int numbers[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int count = 5;

    std::for_each_n(numbers, count, [](int number) {
        std::cout << number << std::endl;
    });

    return 0;
}

25.2、transform

25.2.1、std::transform

对指定范围内的元素应用一个函数进行处理，并将结果存储到另一个容器中。

25.2.2、std::transform_exclusive_scan

这个各种资料的解释让人越看越糊涂，直接看代码：

int main(int argc, char *argv[])
{
    QVector<int> input = {1, 2, 3, 4, 5};
    QVector<int> output(input.size());

    // 定义一个二元操作函数，用于将相邻元素相加
    auto binary_op = [](int a, int b) {
        return a + b;
    };

    // 定义一个一元操作函数，用于将元素加倍
    auto unary_op = [](int a) {
        return a * 2;
    };

    std::transform_exclusive_scan(input.begin(), input.end(), output.begin(),
                                  0, binary_op, unary_op);

    // 使用 qDebug 输出结果
    qDebug() << "转换和前缀扫描的结果："<<output;
}

即进行了两步：

1、unary_op作用于每个元素后，

2、用binary_op累积（什么是累积可查看上面std::inclusive_scan的说明）操作新元素（不含当前值）。

即：{1, 2, 3, 4, 5}    ->    {2, 4, 6, 8, 10}    ->    {0, 2, 6（即2+4）, 12（2+4+6）,20（即2+4+6+8）}

参数4是初始值：

25.2.3、std::transform_inclusive_scan

与std::transform_exclusive_scan类似的，不同之处在于不能设置初始值和累积时包括当前值。

25.2.4、std::transform_reduce

可以对指定范围内的元素进行变换，并将结果归约为单个值。

“归约”是指将一个序列中的元素经过某种操作（例如相加、相乘等），最后得到一个单独的结果。

int main(int argc, char *argv[])
{
    // 创建一个包含整数的 Qt 容器
    QVector<int> nums = {1, 2, 3, 4, 5};

    // 定义一个变换函数对象，将元素的平方返回
    auto square = [](int num) { return num * num; };
    auto plus = [](int a, int b) { return a + b; };

    // 使用自定义的归约函数对象对容器中的元素进行变换和归约操作
    int sumOfSquares = std::transform_reduce(nums.begin(), 
                                             nums.end(), 
                                             0,
                                             plus,
                                             square); 
    
    // 输出结果
    qDebug() << "容器元素的平方和：" << sumOfSquares; //55
}

此代码首先对{1, 2, 3, 4, 5}的每个元素执行square即平方操作，得到{1, 4, 9, 16, 25}，再对此序列中的元素执行plus即相加的操作。

26、算法执行策略

  • std::execution::seq：顺序执行，即算法按照顺序运行，不进行并行化。
  • std::execution::par：并行执行，即算法可以并行化运行，以提高性能。
  • std::execution::par_unseq：并行且无序执行，即算法可以并行化运行，并且运行结果无序。
  • std::execution::unseq：无序执行，即算法可以进行优化，包括并行化和指令重排。

用法示例：

#include <execution>

int main(int argc, char *argv[])
{
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用并行执行策略对向量中的每个元素进行平方操作
    std::for_each(std::execution::par, vec.begin(), vec.end(),
                  [](int& num) { num = num * num; });

    // 输出结果
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

27、策略控制器

  • std::execution::sequenced_policy：算法应该以顺序的方式执行，即算法在一个线程中按照顺序依次执行，不会并行化或无序化操作。这种策略保证了算法的结果与输入的迭代器顺序保持一致。
  • std::execution::parallel_policy：算法应该以并行的方式执行，即算法会尽可能地在多个线程中并行执行，以提高执行效率。并行执行策略充分利用多核处理器的能力，并允许多个线程同时处理不相关的任务。

用法示例：

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

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

    // 使用并行执行策略对向量中的每个元素进行输出
    std::for_each(std::execution::parallel_policy, vec.begin(), vec.end(),
                  [](int num) {
                      std::cout << num << " ";
                  });

    std::cout << std::endl;

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1102907.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

阿里云2023年双十一优惠活动整理

阿里云2023年双十一优惠活动整理

随着双十一的临近&#xff0c;阿里云也为大家准备了一系列优惠活动。作为国内知名的云服务提供商&#xff0c;阿里云在双十一期间推出了多种优惠政策和福利&#xff0c;让用户在享受优质云服务的同时&#xff0c;也能节省一些费用。本文将对阿里云双十一优惠活动进行详细整理&a…
阅读更多...
合伙企业的执行事务合伙人委派代表是什么样的存在

合伙企业的执行事务合伙人委派代表是什么样的存在

当合伙企业的执行事务合伙人为法人或非法人组织时&#xff0c;通常会委派自然人代表其执行合伙事务&#xff0c;特别是各类投资基金、信托、资产证券化等合伙企业类型的SPV中&#xff0c;由法人执行事务合伙人委派代表执行合伙企业事务比较常见&#xff0c;由此可能出现合伙企业…
阅读更多...
AFL安全漏洞挖掘

AFL安全漏洞挖掘

安全之安全(security)博客目录导读 ATF(TF-A)/OPTEE之FUZZ安全漏洞挖掘汇总 目录 一、AFL简介 二、AFL的安装 三、代码示例及种子语料库 四、AFL插桩编译 五、AFL运行及测试 六、AFL结果分析 一、AFL简介 模糊测试&#xff08;Fuzzing&#xff09;技术作为漏洞挖掘最有…
阅读更多...
Compose 实战之为下拉刷新添加自定义指示器

Compose 实战之为下拉刷新添加自定义指示器

前言 在安卓开发中&#xff0c;下拉刷新是一个非常常用的功能&#xff0c;几乎只要是涉及到列表展示数据的界面都会用到它。 而 Compose 却直到 2022年10月份才在 compose.material:1.3.0 中添加了对下拉刷新的支持&#xff1a;Modifier.pullRefresh 。 在此之前&#xff0c…
阅读更多...
SpringBoot整合Activiti

SpringBoot整合Activiti

SpringBoot集成Activiti7 SpringBoot版本使用2.7.16 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.7.16</version><relativePath/> <!-- lookup…
阅读更多...
高并发场景下常见的限流算法及方案介绍

高并发场景下常见的限流算法及方案介绍

应用场景 现代互联网很多业务场景&#xff0c;比如秒杀、下单、查询商品详情&#xff0c;最大特点就是高并发&#xff0c;而往往我们的系统不能承受这么大的流量&#xff0c;继而产生了很多的应对措施&#xff1a;CDN、消息队列、多级缓存、异地多活。 但是无论如何优化&…
阅读更多...
element ui 中 el-button重新渲染后disabled属性失效

element ui 中 el-button重新渲染后disabled属性失效

调试发现:disabled绑定的值和显示没有保持一致&#xff0c;发现是disabled属性失效 解决方式&#xff1a; 给标签添加key 比如&#xff1a;key“isOldVersion” <el-form-item><el-button type"primary" style"margin-left: 100px;" click"…
阅读更多...
TX Text Control .NET Server for ASP.NET 32.0 Crack

TX Text Control .NET Server for ASP.NET 32.0 Crack

TX Text Control .NET Server for ASP.NET 是VISUAL STUDIO 2022、ASP.NET CORE .NET 6 和 .NET 7 支持&#xff0c;将文档处理集成到 Web 应用程序中&#xff0c;为您的 ASP.NET Core、ASP.NET 和 Angular 应用程序添加强大的文档处理功能。 客户端用户界面 文档编辑器 将功能…
阅读更多...
手撕 视觉slam14讲 ch7 / pose_estimation_3d2d.cpp （2）

手撕 视觉slam14讲 ch7 / pose_estimation_3d2d.cpp （2）

上一篇文章中: 手撕ch7/pose_estimation_3d2d&#xff08;1&#xff09;&#xff0c;我们调用了epnp的方法进行位姿估计&#xff0c;这里我们使用非线性优化的方法来求解位姿&#xff0c;使用g2o进行BA优化 首先介绍g2o&#xff1a;可参考&#xff1a;g2o详细介绍 1.构建g2o图…
阅读更多...
解决 MyBatis 一对多查询中，出现每组元素只有一个，总组数与元素数总数相等的问题

解决 MyBatis 一对多查询中，出现每组元素只有一个，总组数与元素数总数相等的问题

文章目录 问题简述场景描述问题描述问题原因解决办法 问题简述 笔者在使用 MyBatis 进行一对多查询的时候遇到一个奇怪的问题。对于笔者的一对多的查询结果&#xff0c;出现了这样的一个现象&#xff1a;原来每个组里有多个元素&#xff0c;查询目标是查询所查的组&#xff0c;…
阅读更多...
【数据结构】线性表（一）线性表的定义及其基本操作（顺序表插入、删除、查找、修改）

【数据结构】线性表（一）线性表的定义及其基本操作（顺序表插入、删除、查找、修改）

目录 一、线性表 1. 线性表的定义 2. 线性表的要素 二、线性表的基本操作 三、线性表的顺序存储结构 1. 定义 2. 顺序表的操作 a. 插入操作 b. 删除操作 c. 查找操作 d. 修改操作 e. 代码实例 一、线性表 1. 线性表的定义 一个线性表是由零个或多个具有相同…
阅读更多...
TCP/IP网络分层模型

TCP/IP网络分层模型

TCP/IP当初的设计者真的是非常聪明&#xff0c;创造性地提出了“分层”的概念&#xff0c;把复杂的网络通信划分出多个层次&#xff0c;再给每一个层次分配不同的职责&#xff0c;层次内只专心做自己的事情就好&#xff0c;用“分而治之”的思想把一个“大麻烦”拆分成了数个“…
阅读更多...
行业追踪，2023-10-17

行业追踪，2023-10-17

自动复盘 2023-10-17 凡所有相&#xff0c;皆是虚妄。若见诸相非相&#xff0c;即见如来。 k 线图是最好的老师&#xff0c;每天持续发布板块的rps排名&#xff0c;追踪板块&#xff0c;板块来开仓&#xff0c;板块去清仓&#xff0c;丢弃自以为是的想法&#xff0c;板块去留让…
阅读更多...
华为云云耀云服务器L实例评测｜使用sysbench对云耀云服务器mysql的性能测试

华为云云耀云服务器L实例评测｜使用sysbench对云耀云服务器mysql的性能测试

目录 引言 1 在centos上安装mysql 1.1 在云服务器上安装 Docker 1.2 在 Docker 中运行 MySQL 容器 2 安装sysbench并进行性能测试 2.1 安装和配置 sysbench 2.2 运行 sysbench 性能测试 3 分析测试结果 3.1 运行结果 3.2 对运行结果进行翻译 3.3 性能分析 4 清理…
阅读更多...
AIGC - 入门向量空间模型

AIGC - 入门向量空间模型

文章目录 向量和向量空间向量的运算什么是向量空间&#xff1f;向量空间的几个重要概念向量之间的距离曼哈顿距离&#xff08;Manhattan Distance&#xff09;欧氏距离&#xff08;Euclidean Distance&#xff09;切比雪夫距离&#xff08;Chebyshev Distance&#xff09; 向量…
阅读更多...
qml加载ttf字体库

qml加载ttf字体库

1,下载获取ttf文件 iconfont-阿里巴巴矢量图标库 字体图标下载 - FontAwesome 字体图标中文Icon 2,添加到项目文件 3,项目添加字体库 #include <QGuiApplication> #include <QQmlApplicationEngine> #include <QFontDatabase> #include <QDebug>in…
阅读更多...
Error: GlobalConfigUtils setMetaData Fail Cause:java.lang.NullPointerException

Error: GlobalConfigUtils setMetaData Fail Cause:java.lang.NullPointerException

文章目录 1、在开发中会出现这样的错误。2、其次&#xff0c;再看其他错误&#xff1a; 1、在开发中会出现这样的错误。 完整错误&#xff1a;Caused by: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: Error: GlobalConfigUtils setMetaData Fail ! Cause…
阅读更多...
白银现货K线走势图分析

白银现货K线走势图分析

K线图又称蜡烛图、阴阳烛&#xff0c;这一理论起源于日本&#xff0c;是最古老的技术分析方法。在众多的现货白银技术分析方法中&#xff0c;K线分析是核心和根本&#xff0c;因为很多的技术分析方法的分析要素和计算方式&#xff0c;都是来自K线中的四个价格。 面对同样一张的…
阅读更多...
C++进阶篇1---继承

C++进阶篇1---继承

一、继承的概念和定义 1.1概念 继承机制是面向对象程序设计使代码可以复用的最重要的手段&#xff0c;它允许程序员在保持原有类特性的基础上进行扩展&#xff0c;增加功能&#xff0c;这样产生新的类&#xff0c;称为派生类。继承呈现了面向对象程序设计的层次结构&#xff…
阅读更多...
Leetcode刷题详解——长度最小的子数组

Leetcode刷题详解——长度最小的子数组

1. 题目链接&#xff1a;209. 长度最小的子数组 2. 题目描述&#xff1a; 给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl1, ..., numsr-1, numsr] &#xff0c;并返回其长度**。**如果不…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023