C++常用函数

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);

• first：待排序元素的起始地址。
• last：待排序元素的终止地址，不包含在排序范围内。
• comp：可选参数，比较函数对象。

示例代码如下：

#include 
#include 

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);

• a：待比较的第一个值。
• b：待比较的第二个值。
• comp：可选参数，比较函数对象。

示例代码如下：

#include 
#include 

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);

• first：待搜索区间的起始地址。
• last：待搜索区间的终止地址，不包含在搜索范围内。
• value：待搜索的值。
• comp：可选参数，比较函数对象。

示例代码如下：

#include 
#include 

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);

• first：待统计区间的起始地址。
• last：待统计区间的终止地址，不包含在统计范围内。
• value：待统计的值。

示例代码如下：

#include 
#include 
#include 

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);

• first：待求和区间的起始地址。
• last：待求和区间的终止地址，不包含在求和范围内。
• init：可选参数，求和的初始值。
• binary_op：可选参数，二元运算函数对象。

示例代码如下：

#include 
#include 
#include 

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);

• first：待遍历区间的起始地址。
• last：待遍历区间的终止地址，不包含在遍历范围内。
• fn：函数指针或函数对象。

示例代码如下：

#include 
#include 
#include 

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);

• first：待去重区间的起始地址。
• last：待去重区间的终止地址，不包含在去重范围内。
• pred：可选参数，二元谓词函数对象。

示例代码如下：

#include 
#include 
#include 

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);

• first：待反转区间的起始地址。
• last：待反转区间的终止地址，不包含在反转范围内。

示例代码如下：

#include 
#include 
#include 

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);

• first：要填充的第一个元素的迭代器。
• last：要填充的最后一个元素的迭代器，不包括在范围内。
• value：要填充的值。

示例代码如下：

#include 
#include 
#include 

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 
#include 
#include 

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 
#include 
#include 

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 

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 

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 头文件的文档来了解更多。