C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++常用函数

C++常用函数总结(algorithm 头文件)

作者：CX__CS

本文给大家详细介绍了algorithm 头文件中最常用的函数及其使用方法,当然这只是其中的一部分,algorithm 头文件中还有很多其他的函数,感兴趣的朋友一起看看吧

std::sort

std::sort 函数用于对数组或容器进行排序，可以按照默认的升序排序或指定比较函数进行排序。

语法如下：

template <class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

示例代码如下：

#include <iostream>
#include <algorithm>
int main() {
    int arr[] = {4, 1, 8, 3, 2, 5};
    int n = sizeof(arr) / sizeof(int);
    std::sort(arr, arr + n); // 对数组进行升序排序
    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

输出结果为：

1 2 3 4 5 8

std::max 和 std::min

std::max 和 std::min 函数用于获取两个值中的最大值或最小值。

语法如下：

template <class T>
const T& max(const T& a, const T& b);
template <class T, class Compare>
const T& max(const T& a, const T& b, Compare comp);
template <class T>
const T& min(const T& a, const T& b);
template <class T, class Compare>
const T& min(const T& a, const T& b, Compare comp);

示例代码如下：

#include <iostream>
#include <algorithm>
int main() {
    int a = 3, b = 5;
    int max_val = std::max(a, b); // 获取 a 和 b 中的最大值
    int min_val = std::min(a, b); // 获取 a 和 b 中的最小值
    std::cout << "max_val = " << max_val << std::endl;
    std::cout << "min_val = " << min_val << std::endl;
    return 0;
}

输出结果为：

max_val = 5
min_val = 3

std::binary_search

std::binary_search 函数用于在已排序的数组或容器中搜索元素，返回值为布尔类型。

语法如下：

template <class ForwardIterator, class T>
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class T, class Compare>
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

示例代码如下：

#include <iostream>
#include <algorithm>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(int);
    bool found = std::binary_search(arr, arr + n, 3); // 在数组中搜索值为 3 的元素
    if (found) {
        std::cout << "Found" << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }
    return 0;
}

输出结果为：

Found

std::count

std::count 函数用于统计容器或数组中指定值的个数。

语法如下：

template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type count(InputIterator first, InputIterator last, const T& value);

示例代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
int main() {
    std::vector<int> vec = {1, 2, 3, 3, 3, 4, 5};
    int cnt = std::count(vec.begin(), vec.end(), 3); // 统计容器中值为 3 的元素个数
    std::cout << "count = " << cnt << std::endl;
    return 0;
}

输出结果为：

count = 3

std::accumulate

std::accumulate 函数用于计算容器或数组中所有元素的和，也可以指定一个初始值。

语法如下：

template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init);
template <class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);

示例代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int sum = std::accumulate(vec.begin(), vec.end(), 0); // 求和
    std::cout << "sum = " << sum << std::endl;
    return 0;
}

输出结果为：

sum = 15

std::for_each

std::for_each 函数用于对容器或数组中的每个元素执行指定的操作，可以使用函数指针或函数对象来指定操作。

语法如下：

template <class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function fn);

示例代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
void print(int x) {
    std::cout << x << " ";
}
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::for_each(vec.begin(), vec.end(), print); // 对容器中的每个元素执行 print 操作
    std::cout << std::endl;
    return 0;
}

输出结果为：

1 2 3 4 5

std::unique

std::unique 函数用于去除容器或数组中的重复元素，仅保留第一个出现的元素。

语法如下：

template <class ForwardIterator>
ForwardIterator unique(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);

示例代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
int main() {
    std::vector<int> vec = {1, 2, 3, 3, 4, 4, 5};
    auto last = std::unique(vec.begin(), vec.end()); // 去除容器中的重复元素
    vec.erase(last, vec.end()); // 删除重复的元素
    for (auto x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    return 0;
}

输出结果为：

1 2 3 4 5

std::reverse

std::reverse 函数用于将容器或数组中的元素进行反转。

语法如下：

template <class BidirectionalIterator>
void reverse(BidirectionalIterator first, BidirectionalIterator last);

示例代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::reverse(vec.begin(), vec.end()); // 反转容器中的元素
    for (auto x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    return 0;
}

输出结果为：

5 4 3 2 1

std::fill

std::fill 函数用于将指定区间的元素赋值为指定的值。

语法如下：

template <class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value);

示例代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
int main() {
    std::vector<int> vec(10); // 创建一个包含 10 个元素的向量
    std::fill(vec.begin(), vec.end(), 3); // 将向量中的所有元素都赋值为 3
    for (auto x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    return 0;
}

输出结果为：

3 3 3 3 3 3 3 3 3 3

另外需要注意的是，如果使用 fill 函数填充的元素是自定义类型，需要自行定义该类型的赋值运算符重载函数。

std::next_permutation

std::next_permutation 函数用于求出容器或数组中元素的下一个排列组合。

std::next_permutation 是`cpp 标准库中的一个函数，用于返回一组元素的下一个排列。下面是该函数的定义：

template<class BidirIt>
bool next_permutation(BidirIt first, BidirIt last);

该函数接受两个迭代器作为参数，表示需要进行排列的元素范围。

函数会尝试将这些元素重新排列为下一个字典序更大的排列，如果成功，则返回 true，否则返回 false。

下面是一个示例：

#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
    std::vector<int> vec{1, 2, 3};
    do {
        for (auto i : vec) {
            std::cout << i << ' ';
        }
        std::cout << '\n';
    } while (std::next_permutation(vec.begin(), vec.end()));
    return 0;
}

输出为：

1 2 3 
1 3 2 
2 1 3 
2 3 1 
3 1 2 
3 2 1 

在这个示例中，我们使用了 std::next_permutation 函数对 vec 进行了排列，并使用了一个 do-while 循环来重复输出排列结果，直到排列到了最后一个排列为止。

std::partition

std::partition 函数用于将容器或数组中的元素按照指定的条件进行分区，使得满足条件的元素排在不满足条件的元素之前。

std::partition是一个标准库函数，可以将一组元素重新排序，使得满足某个特定条件的元素在序列的前面，而不满足条件的元素在后面。该函数接受三个参数：

template <typename ForwardIt, typename UnaryPredicate>
ForwardIt partition(ForwardIt first, ForwardIt last, UnaryPredicate p);

第一个参数是指向第一个元素的迭代器，第二个参数是指向最后一个元素后面的迭代器（即last不在范围内），第三个参数是一个一元谓词（即只接受一个参数的函数对象）。

使用该函数时，需要提供一个一元谓词，该谓词定义了一个条件，使得满足该条件的元素在序列的前面，而不满足条件的元素在后面。函数返回一个迭代器，该迭代器指向最后一个满足条件的元素后面的位置。在返回的迭代器之前的元素都满足条件，而在迭代器之后的元素都不满足条件。

下面是一个使用std::partition函数的示例代码：

#include <algorithm>
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9};
    auto is_odd = [](int x) { return x % 2 == 1; };
    auto it = std::partition(v.begin(), v.end(), is_odd);
    std::cout << "Odd numbers: ";
    std::copy(v.begin(), it, std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\nEven numbers: ";
    std::copy(it, v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}

该代码使用了lambda表达式is_odd作为一元谓词，该谓词返回true表示元素是奇数，返回false表示元素是偶数。函数将一个包含1到9的整数序列重新排序，使得奇数在前面，偶数在后面，并打印出结果

输出结果为：

Odd numbers: 1 3 5 7 9
Even numbers: 2 4 6 8

可以看到，std::partition函数将奇数放在了序列的前面，偶数放在了后面。返回的迭代器it指向序列中最后一个奇数的后面一个位置。函数std::copy将奇数和偶数分别打印出来。

注：lambda表达式`cpp11中新增的特性：

`cpp11中，可以使用lambda表达式来定义一个匿名函数，语法格式如下：

[capture list] (parameters) -> return-type { function body }

其中，capture list 用于捕获外部变量，parameters 是函数的参数列表，return-type 是函数的返回类型（可以省略，由编译器自动推断），function body 是函数体

以下是一个简单的示例，演示如何使用lambda表达式来计算两个整数的和：

#include <iostream>
int main() {
    int a = 5, b = 3;
    auto sum = [](int x, int y) -> int { return x + y; };
    std::cout << "The sum of " << a << " and " << b << " is " << sum(a, b) << std::endl;
    return 0;
}

在上面的示例中，我们使用lambda表达式定义了一个函数sum，它接受两个int类型的参数并返回它们的和。我们将该lambda表达式赋值给变量sum，并通过调用该变量来调用该函数。

capture list是lambda表达式中的一个可选项，它允许我们在函数体中捕获外部变量。

外部变量：在函数体外部定义的变量，可以是全局变量，也可以是局部变量。（捕获外部变量的主要原因是 lambda 表达式是一个匿名函数，它没有自己的名称和作用域，因此无法像常规函数那样直接访问外部作用域中的变量。通过捕获外部变量，lambda 表达式可以获得对这些变量的访问权，使其能够在函数体中使用这些变量。）

捕获可以按值或按引用进行，这决定了 lambda 表达式如何访问外部变量。按值捕获将外部变量的值复制到 lambda 表达式的闭包中，这意味着 lambda 表达式不会影响外部变量的值。按引用捕获将外部变量的引用传递给 lambda 表达式，这意味着 lambda 表达式可以更改外部变量的值。

例如，我们可以使用以下lambda表达式来将一个整数加上一个固定的值：

#include <iostream>
int main() {
    int a = 5, b = 3;
    int offset = 10;
    auto add_offset = [offset](int x) -> int { return x + offset; };
    std::cout << "The result of adding " << offset << " to " << a << " is " << add_offset(a) << std::endl;
    std::cout << "The result of adding " << offset << " to " << b << " is " << add_offset(b) << std::endl;
    return 0;
}

在上面的示例中，我们使用capture list来捕获变量offset，并在lambda表达式中使用该变量。这样，我们就可以使用该lambda表达式来将任何整数加上偏移量offset。

当然，你可以将变量作为参数直接传递给 lambda 表达式，但这种方式通常适用于较简单的场景。在某些情况下，捕获外部变量可以更方便地访问外部作用域中的变量，并允许 lambda 表达式使用外部变量的状态来执行更复杂的操作。

以上是 algorithm 头文件中最常用的函数及其使用方法，当然这只是其中的一部分，algorithm 头文件中还有很多其他的函数，读者可以通过查看 algorithm 头文件的文档来了解更多。

到此这篇关于C++常用函数的文章就介绍到这了,更多相关C++常用函数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文