C++STL速查手册

春风LiuK
已于 2024-02-11 20:50:16 修改
阅读量591
点赞数 10
分类专栏： C++学习算法文章标签： c++ 开发语言
于 2024-02-11 20:43:05 首次发布
本文链接：https://blog.csdn.net/liukuande/article/details/136094256
版权
C++学习同时被 2 个专栏收录
9 篇文章 0 订阅
订阅专栏
算法
7 篇文章 0 订阅
订阅专栏
本文参考cppreference，整理了一些常用的STL容器及其内置函数与算法，方便查用。
C++STL速查手册

什么是STL？
STL模板
什么是STL？

在这里插入图片描述
在C++中，STL 是指标准模板库（Standard Template Library）。STL 是 C++ 标准库的一部分，提供了一组通用的模板类和函数，用于实现多种常见的数据结构和算法。STL 的设计目标是提供高效、灵活、可复用的组件，使得程序员能够更加方便地编写高质量的代码。
STL 由以下几个主要部分组成：
容器（Containers）： 容器是用于存储数据的数据结构，STL 提供了多种容器，包括向量（vector）、链表（list）、双端队列（deque）、队列（queue）、栈（stack）、集合（set）、映射（map）等。这些容器提供了不同的特性和适用场景。
迭代器（Iterators）： 迭代器是用于访问容器元素的抽象概念，它类似于指针，提供了一种统一的方式来遍历容器中的元素。STL 容器通常可以使用迭代器来进行遍历和操作。
算法（Algorithms）： STL 提供了大量的通用算法，包括排序、查找、变换、合并等。这些算法能够在各种容器上工作，使得开发人员无需自己实现这些基本的算法，从而提高了代码的可重用性和可读性。
函数对象（Functors）： 函数对象是可以像函数一样调用的对象。STL 中的函数对象通常用于实现算法的比较和操作。
配接器（Adapters）： 配接器是一种用于修改或适应容器、迭代器或函数对象的组件。STL 提供了各种配接器，例如栈和队列的适配器，以及迭代器的适配器等。
STL模板

#include <vector>

vector容器的构造函数
vector<T> v; //采用模板类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

vector容器的赋值操作
assign(const_iterator start, const_iterator end); //将[start, end)区间中的数据拷贝赋值给本身。
assign(int n, const T& elem); //将n个elem拷贝赋值给本身。
vector& operator=(const vector  &vec); //重载等号操作符

vector容器的大小操作
v.empty(); //判断容器是否为空
v.size(); //返回容器中元素的个数
v.resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
v.resize(int num, const T& elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

vector容器的插入和删除操作
v.push_back(elem); //在容器尾部加入一个元素
v.pop_back(); //删除容器中最后一个元素
v.insert(const_iterator pos, const T& elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
v.insert(const_iterator pos, int count, const T& elem); //在pos位置插入count个elem数据，无返回值。
v.erase(const_iterator pos); //删除pos位置的数据，返回下一个数据的位置。
v.erase(const_iterator start, const_iterator end); //删除[start, end)区间的数据，返回下一个数据的位置。
v.clear(); //移除容器的所有数据



vector容器的数据存取
v.at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。
v[idx]; //返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
v.front(); //返回容器中第一个数据元素
v.back(); //返回容器中最后一个数据元素

vector互换
v.swap(v1); // 将v与v1的元素互换

vector的预留空间
v.reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问。

vector的反转操作
reverse(iterator start, iterator end); //将[start, end)区间中的数据反转

vector的排序
sort(iterator start, iterator end); //对[start, end)区间中的数据进行排序
sort(iterator start, iterator end, _Pred); //对[start, end)区间中的数据进行排序，指定排序规则,_Pred是自定义的谓词，可以是函数指针，函数对象，函数，Lambda表达式等。
sort()成员函数使用的是快速排序算法。

vector的迭代器
v.begin(); //返回容器中第一个数据的迭代器。
v.end(); //返回容器中最后一个数据之后的迭代器。
v.rbegin(); //返回容器中倒数第一个元素的迭代器。
v.rend(); //返回容器中倒数最后一个元素的后面的迭代器。
v.cbegin(); //返回容器中第一个数据的const迭代器。
v.cend(); //返回容器中最后一个数据之后的const迭代器。
v.crbegin(); //返回容器中倒数第一个元素的const迭代器。
v.crend(); //返回容器中倒数最后一个元素的后面的const迭代器。



#include <deque>

deque容器的构造函数
deque() deq; //默认构造函数
deque(int n, value); //构造函数将n个value拷贝给本身。
deque(const deque &deq); //拷贝构造函数

deque容器的赋值操作
deq.assign(const_iterator start, const_iterator end); //将[start, end)区间中的数据拷贝赋值给本身。
deq.assign(int n, const T& val); //将n个val拷贝赋值给本身。
deq.deque& operator=(const deque &deq); //重载等号操作符

deque容器的大小操作
deq.empty(); //判断容器是否为空
deq.size(); //返回容器中元素的个数
deq.resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
deq.resize(int num, const T& val); //重新指定容器的长度为num，若容器变长，则以val值填充新位置。
deq.shrink_to_fit(); //请求移除deque中未使用的容量

deque容器的插入和删除操作
deq.push_back(elem); //在容器尾部添加一个数据
deq.push_front(elem); //在容器头部插入一个数据
deq.pop_back(); //删除容器最后一个数据
deq.pop_front(); //删除容器第一个数据
deq.insert(const_iterator it, const T& val); //在it位置插入一个val的拷贝，返回新数据的位置。
deq.insert(const_iterator it, int count, const T& val); //在it位置插入count个val数据，无返回值。
deq.insert(const_iterator it, const_iterator first, const_iterator last); //在it位置插入[first, last)区间的数据，无返回值。
deq.erase(const_iterator it); //删除it位置的数据，返回下一个数据的位置。
deq.erase(const_iterator first, const_iterator last); //删除[first, last)区间的数据，返回下一个数据的位置。
deq.clear(); //清空容器的所有数据


deque容器的数据存取
deq.at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。
deq[idx]; //返回索引idx所指的数据，如果idx越界，直接出错。
deq.front(); //返回第一个数据。
deq.back(); //返回最后一个数据 



deque容器的迭代器
deq.begin(); //返回指向第一个数据的迭代器。
deq.end(); //返回指向最后一个数据的下一个迭代器。
deq.rbegin(); //返回指向最后一个数据的迭代器。
deq.rend(); //返回指向第一个数据的前一个迭代器。
deq.cbegin(); //返回指向第一个数据的const迭代器。
deq.cend(); //返回指向最后一个数据的下一个const迭代器。
deq.crbegin(); //返回指向最后一个数据的const迭代器。
deq.crend(); //返回指向第一个数据的前一个const迭代器。



deque容器的互换
deq.swap(deque& other); // 将deq与other的元素互换

deque容器的排序
std::sort(iterator start, iterator end); //对[start, end)区间中的数据进行排序
std::sort(iterator start, iterator end, _Pred); //对[start, end)区间中的数据进行排序，指定排序规则,_Pred是自定义的谓词，可以是函数指针，函数对象，函数，Lambda表达式等。

list容器的构造函数
list<T> lst; //默认构造函数
list(int n, const T& val = T()); //构造函数将n个val拷贝给本身。
list(InputIterator first, InputIterator last); //构造函数将区间[first, last)中的数据拷贝给本身。
list(const list &lst); //拷贝构造函数

list容器的赋值操作
assign(InputIterator first, InputIterator last); //将区间[first, last)中的数据拷贝赋值给本身。
list& operator=(const list &lst); //重载等号操作符
lst.swap(list &lst); // 将lst与lst的元素互换


list容器的大小操作
lst.empty(); //判断容器是否为空
lst.size(); //返回容器中元素的个数
lst.resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
lst.resize(int num, const T& val); //重新指定容器的长度为num，若容器变长，则以val值填充新位置。
lst.clear(); //清空所有数据

list容器的数据存取
lst.front(); //返回第一个数据。
lst.back(); //返回最后一个数据

list容器的插入和删除操作
lst.push_back(); //在容器尾部加入一个数据
lst.pop_back(); //删除容器中最后一个数据
lst.push_front(); //在容器开头插入一个数据
lst.pop_front(); //从容器开头移除第一个数据
lst.insert(iterator position, int n, const T& val); //在position位置插入n个val数据，返回指向第一个插入数据的迭代器。
lst.insert(iterator position, const T& val); //在position位置插入val数据，返回指向插入数据的迭代器。
lst.insert(iterator position, InputIterator first, InputIterator last); //在position位置插入区间[first, last)中的数据，返回指向第一个插入数据的迭代器。
lst.erase(iterator position); //删除position位置的数据，返回下一个数据的迭代器。
lst.erase(iterator first, iterator last); //删除区间[first, last)中的数据，返回指向被删除数据之后的迭代器。
lst.remove(val); //删除容器中所有与val值匹配的元素。
lst.remove_if(_Pred); //删除容器中满足条件_Pred的元素。
lst.unique(); //删除容器中相邻的重复元素。

list容器的反转和排序
lst.reverse(); //反转链表
lst.sort(); //链表排序



#include <set>

set容器的构造函数
set<T> st; //默认构造函数
set(const set &st); //拷贝构造函数

multiset容器的构造函数
multiset<T> mst; //默认构造函数
multiset(const multiset &mst); //拷贝构造函数

set容器的赋值操作
set& operator=(const set &st); //重载等号操作符

multiset容器的赋值操作
multiset& operator=(const multiset &mst); //重载等号操作符

set容器的大小操作
st.empty(); //判断容器是否为空
st.size(); //返回容器中元素的个数
st.max_size(); //返回容器能容纳元素的最大个数

multiset容器的大小操作
mst.empty(); //判断容器是否为空
mst.size(); //返回容器中元素的个数
mst.max_size(); //返回容器能容纳元素的最大个数

set容器的插入和删除操作
st.insert(const value_type& val); //在容器中插入元素
st.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
st.erase(const_iterator position); //删除position迭代器所指的元素
st.erase(const value_type& val); //删除容器中值为val的元素
st.erase(first, last); //删除区间[first, last)中的所有元素
st.clear(); //清空所有元素

multiset容器的插入和删除操作
mst.insert(const value_type& val); //在容器中插入元素
mst.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
mst.erase(const_iterator position); //删除position迭代器所指的元素
mst.erase(const value_type& val); //删除容器中值为val的元素
mst.erase(first, last); //删除区间[first, last)中的所有元素
mst.clear(); //清空所有元素

set容器的查找操作
st.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
st.count(const value_type& val); //返回容器中值为val的元素个数
st.lower_bound(const value_type& val); //返回第一个>=val元素的迭代器
st.upper_bound(const value_type& val); //返回第一个>val元素的迭代器
st.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

multiset容器的查找操作
mst.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
mst.count(const value_type& val); //返回容器中值为val的元素个数
mst.lower_bound(const value_type& val); //返回第一个>=val元素的迭代器
mst.upper_bound(const value_type& val); //返回第一个>val元素的迭代器
mst.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

set容器的迭代器
st.begin(); //返回指向第一个元素的迭代器
st.end(); //返回末尾的迭代器
st.rbegin(); //返回指向最后一个元素的迭代器
st.rend(); //返回指向第一个元素的迭代器
st.cbegin(); //返回指向第一个元素的const迭代器
st.cend(); //返回末尾的const迭代器
st.crbegin(); //返回指向最后一个元素的const迭代器
st.crend(); //返回指向第一个元素的const迭代器

multiset容器的迭代器
mst.begin(); //返回指向第一个元素的迭代器
mst.end(); //返回末尾的迭代器
mst.rbegin(); //返回指向最后一个元素的迭代器
mst.rend(); //返回指向第一个元素的迭代器
mst.cbegin(); //返回指向第一个元素的const迭代器
mst.cend(); //返回末尾的const迭代器
mst.crbegin(); //返回指向最后一个元素的const迭代器
mst.crend(); //返回指向第一个元素的const迭代器

set容器的互换
st.swap(set &st); // 将st与st的元素互换

multiset容器的互换
mst.swap(multiset &mst); // 将mst与mst的元素互换


#include <unordered_set>

unordered_set容器的构造函数
unordered_set<T> ust; //默认构造函数
unordered_set(const unordered_set &ust); //拷贝构造函数

unordered_multiset容器的构造函数
unordered_multiset<T> umst; //默认构造函数
unordered_multiset(const unordered_multiset &umst); //拷贝构造函数


unordered_set容器的赋值操作
unordered_set& operator=(const unordered_set &ust); //重载等号操作符

unordered_multiset容器的赋值操作
unordered_multiset& operator=(const unordered_multiset &umst); //重载等号操作符

unordered_set容器的大小操作
ust.empty(); //判断容器是否为空
ust.size(); //返回容器中元素的个数
ust.max_size(); //返回容器能容纳元素的最大个数

unordered_multiset容器的大小操作
umst.empty(); //判断容器是否为空
umst.size(); //返回容器中元素的个数
umst.max_size(); //返回容器能容纳元素的最大个数

unordered_set容器的插入和删除操作
ust.insert(const value_type& val); //在容器中插入元素
ust.erase(const value_type& val); //删除容器中值为val的元素
ust.erase(const_iterator position); //删除position迭代器所指的元素
ust.erase(const_iterator first, const_iterator last); //删除区间[first, last)中的所有元素
ust.clear(); //清空所有元素

unordered_multiset容器的插入和删除操作
umst.insert(const value_type& val); //在容器中插入元素
umst.erase(const value_type& val); //删除容器中值为val的元素
umst.erase(const_iterator position); //删除position迭代器所指的元素
umst.erase(const_iterator first, const_iterator last); //删除区间[first, last)中的所有元素
umst.clear(); //清空所有元素

unordered_set容器的查找操作
ust.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
ust.count(const value_type& val); //返回容器中值为val的元素个数
ust.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

unordered_multiset容器的查找操作
umst.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
umst.count(const value_type& val); //返回容器中值为val的元素个数
umst.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

unordered_set容器的迭代器
ust.begin(); //返回指向第一个元素的迭代器
ust.end(); //返回末尾的迭代器
ust.cbegin(); //返回指向第一个元素的const迭代器
ust.cend(); //返回末尾的const迭代器

unordered_multiset容器的迭代器
umst.begin(); //返回指向第一个元素的迭代器
umst.end(); //返回末尾的迭代器
umst.cbegin(); //返回指向第一个元素的const迭代器


umst.cend(); //返回末尾的const迭代器
unordered_set容器的互换
ust.swap(unordered_set &ust); // 将ust与ust的元素互换

unordered_multiset容器的互换
umst.swap(unordered_multiset &umst); // 将umst与umst的元素互换



#include <map>
map容器的构造函数
map<T1, T2> mp; //默认构造函数
map(const map &mp); //拷贝构造函数

multimap容器的构造函数
multimap<T1, T2> mmp; //默认构造函数
multimap(const multimap &mmp); //拷贝构造函数

map容器的赋值操作
map& operator=(const map &mp); //重载等号操作符

multimap容器的赋值操作
multimap& operator=(const multimap &mmp); //重载等号操作符

map容器的大小操作
mp.empty(); //判断容器是否为空
mp.size(); //返回容器中元素的个数
mp.max_size(); //返回容器能容纳元素的最大个数

multimap容器的大小操作
mmp.empty(); //判断容器是否为空
mmp.size(); //返回容器中元素的个数
mmp.max_size(); //返回容器能容纳元素的最大个数

map容器的插入和删除操作
mp.insert(const value_type& val); //在容器中插入元素
mp.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
mp.erase(const_iterator position); //删除position迭代器所指的元素
mp.erase(const value_type& val); //删除容器中值为val的元素
mp.erase(first, last); //删除区间[first, last)中的所有元素
mp.clear(); //清空所有元素

multimap容器的插入和删除操作
mmp.insert(const value_type& val); //在容器中插入元素
mmp.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
mmp.erase(const_iterator position); //删除position迭代器所指的元素
mmp.erase(const value_type& val); //删除容器中值为val的元素
mmp.erase(first, last); //删除区间[first, last)中的所有元素
mmp.clear(); //清空所有元素

map容器的查找操作
mp.find( const key_type& key); //查找键为key的元素，找到返回该元素的迭代器，找不到返回end迭代器
mp.count(const key_type& key); //返回容器中键为key的元素个数
mp.lower_bound(const key_type& key); //返回第一个>=key元素的迭代器
mp.upper_bound(const key_type& key); //返回第一个>key元素的迭代器
mp.equal_range(const key_type& key); //返回容器中与key相等的上下限的两个迭代器

multimap容器的查找操作
mmp.find( const key_type& key); //查找键为key的元素，找到返回该元素的迭代器，找不到返回end迭代器
mmp.count(const key_type& key); //返回容器中键为key的元素个数
mmp.lower_bound(const key_type& key); //返回第一个>=key元素的迭代器
mmp.upper_bound(const key_type& key); //返回第一个>key元素的迭代器
mmp.equal_range(const key_type& key); //返回容器中与key相等的上下限的两个迭代器

map容器的迭代器
mp.begin(); //返回指向第一个元素的迭代器
mp.end(); //返回末尾的迭代器

multimap容器的迭代器
mmp.begin(); //返回指向第一个元素的迭代器
mmp.end(); //返回末尾的迭代器

map容器的互换
mp.swap(map &mp); // 将mp与mp的元素互换

#include <unordered_map>
unordered_map容器的构造函数
unordered_map<T1, T2> ump; //默认构造函数
unordered_map(const unordered_map &ump); //拷贝构造函数

unordered_multimap容器的构造函数
unordered_multimap<T1, T2> ummp; //默认构造函数
unordered_multimap(const unordered_multimap &ummp); //拷贝构造函数
	
unordered_map容器的赋值操作
unordered_map& operator=(const unordered_map &ump); //重载等号操作符

unordered_multimap容器的赋值操作
unordered_multimap& operator=(const unordered_multimap &ummp); //重载等号操作符

unordered_map容器的大小操作
ump.empty(); //判断容器是否为空
ump.size(); //返回容器中元素的个数
ump.max_size(); //返回容器能容纳元素的最大个数

unordered_multimap容器的大小操作
ummp.empty(); //判断容器是否为空
ummp.size(); //返回容器中元素的个数
ummp.max_size(); //返回容器能容纳元素的最大个数

unordered_map容器的插入和删除操作
ump.insert(const value_type& val); //在容器中插入元素
ump.erase(const key_type& key); //删除容器中键为key的元素
ump.erase(const_iterator position); //删除position迭代器所指的元素
ump.erase(const_iterator first, const_iterator last); //删除区间[first, last)中的所有元素
ump.clear(); //清空所有元素


#include <stack>
stack容器的构造函数
stack<T> stk; //默认构造函数
stack(const stack &stk); //拷贝构造函数

stack容器的赋值操作
stack& operator=(const stack &stk); //重载等号操作符

stack容器的大小操作
stk.empty(); //判断堆栈是否为空
stk.size(); //返回堆栈中元素的个数

stack容器的数据存取
stk.top(); //返回栈顶元素
stk.push(); //向栈顶添加元素
stk.pop(); //从栈顶移除元素

stack容器的互换
stk.swap(stack &stk); // 将stk与stk的元素互换




#include <queue>
queue容器的构造函数
queue<T> que; //默认构造函数
queue(const queue &que); //拷贝构造函数

queue容器的赋值操作
queue& operator=(const queue &que); //重载等号操作符

queue容器的大小操作
que.empty(); //判断队列是否为空
que.size(); //返回队列中元素的个数

queue容器的数据存取
que.front(); //返回队列第一个元素
que.back(); //返回队列最后一个元素
que.push(); //向队列尾部添加元素
que.pop(); //从队列头部移除元素

queue容器的互换
que.swap(queue &que); // 将que与que的元素互换

priority_queue容器的构造函数
priority_queue<T> pque; //默认构造函数

priority_queue容器的赋值操作
priority_queue& operator=(const priority_queue &pque); //重载等号操作符
	
priority_queue容器的大小操作
pque.empty(); //判断队列是否为空
pque.size(); //返回队列中元素的个数

priority_queue容器的数据存取
pque.top(); //返回队列中优先级最高的元素
pque.push(); //向队列中添加元素
pque.pop(); //从队列中移除优先级最高的元素

priority_queue容器的互换
pque.swap(priority_queue &pque); // 将pque与pque的元素互换

#include <algorithm>
仿函数
less<T> //升序排列
greater<T> //降序排列
plus<T> //加法仿函数
minus<T> //减法仿函数
multiplies<T> //乘法仿函数
divides<T> //除法仿函数
modulus<T> //取模仿函数
negate<T> //取反仿函数

普通仿函数使用格式：
仿函数名字对象(参数)
例如：
plus<int> intAdd;
intAdd(10, 20); //等价于10+20


函数对象
函数对象是一个类，类中重载了()操作符的对象
函数对象的好处是可以像普通函数那样调用，可以有自己的状态
函数对象的调用可以有参数，也可以有返回值
函数对象可以作为参数传递给函数
函数对象可以作为函数的返回值
例如：
class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

MyAdd myAdd;
myAdd(10, 20); //等价于10+20


查找算法：适用于所有容器
find(iterator start, iterator end, value); //查找指定范围内的指定元素，找到返回指向该元素的迭代器，找不到返回end迭代器
find_if(iterator start, iterator end, _Pred); //查找指定范围内满足条件_Pred的元素，找到返回指向该元素的迭代器，找不到返回end迭代器
adjacent_find(iterator start, iterator end); //查找指定范围内相邻重复元素的第一个元素，找到返回指向该元素的迭代器，找不到返回end迭代器
binary_search(iterator start, iterator end, value); //查找指定范围内是否存在指定元素，找到返回true，找不到返回false
count(iterator start, iterator end, value); //统计指定范围内指定元素的个数
count_if(iterator start, iterator end, _Pred); //统计指定范围内满足条件_Pred的元素的个数


排序算法：适用于所有容器
random_shuffle(iterator start, iterator end); //对指定范围内的元素进行随机调整
sort(iterator start, iterator end); //对指定范围内的元素进行排序
sort(iterator start, iterator end, _Pred); //对指定范围内的元素进行排序，指定排序规则
stable_sort(iterator start, iterator end); //对指定范围内的元素进行稳定排序
stable_sort(iterator start, iterator end, _Pred); //对指定范围内的元素进行稳定排序，指定排序规则

拷贝和替换算法：适用于所有容器
copy(iterator start, iterator end, iterator dest); //将指定范围内的元素拷贝到另一容器中
replace(iterator start, iterator end, old_value, new_value); //将指定范围内的旧元素替换为新元素
replace_if(iterator start, iterator end, _Pred, new_value); //将指定范围内满足条件_Pred的元素替换为新元素


遍历算法：适用于所有容器
for_each(iterator start, iterator end, _Func); //对指定范围内的元素进行遍历，_Func可以是函数指针，函数对象，函数，Lambda表达式等
transform(iterator start, iterator end, dest, _Func); //对指定范围内的元素进行转换，_Func可以是函数指针，函数对象，函数，Lambda表达式等


#include <numeric>
算数生成算法：适用于所有容器
accumulate(iterator start, iterator end, init); //计算指定范围内的元素累计总和
fill(iterator start, iterator end, value); //将指定范围内的元素填充为指定值