Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说
c++ stl详解_C++ STL,希望能够帮助你!!!。

这个只是我个人学习Stl过程中的一些随手笔记，内容不是很全，以后会为大家更新一份详细的STL讲解，

有STL基础的人请跳过这篇文章

Deque容器是一个动态数组 顺序容器**

Deque可以在数组的开头和末尾插入或者删除数据

Deque<int>a;

a.push_back()在容器尾部添加数据

a.push_front()在容器头部添加数据

a.pop_front()删除容器头部数据

a.pop_back()删除容器尾部数据

对vector的所有操作 在deque上也可以进行

**List 顺序容器 是一个双向链表 不能够使用下标访问里面的数据 只能使用迭代器访问数据**

List<int> a ;

a.push_front();在容器前端增加数据

a.push_back();在容器的后端增加数据

std::list<int>::iterator iter; 迭代器

a.insert(a.begin(),10); 在容器中间插入数据 需要传入一个迭代器和 传入的数值 迭代器指向你需要插入的位置 这个代表在容器的开头插入一个10

a.insert(a.end(),4,20);这个代表在容器的尾部（a.end()迭代器是容器的尾部）插入4个20

list<int> b

a.insert(iter, ++b.begin(), --b.end());这个代表在a容器的iter迭代器指向的位置 插入b容器 ++begin() 到 --end()位置的所有数据

a.insert()返回一个迭代器

a.erase(iter)用来删除迭代器指向位置的数据

a.erase(a.begin(), a.end()) 删除a.begn 到 a.end 位置的数据 a.end位置的数据不会被删除

a.reverse()对a容器进行反转

a.sort()对a容器进行排序

**stack （堆）栈 LIFO后进先出 自适应容器（容器适配器）**

stack<int, deque<int>> a 默认使用deque来做堆栈

stack<int, vector<int>> a

stack<int, list<int>> a

a.empty()检查堆栈是否为空

a.size()检查堆栈里面面有多少个数据

a.pop()从堆栈里面弹出一个数据

a.top()查看栈顶的数据

a.push(item)把一个数据压入堆栈里面

**queue 队列：FIFO先进先出 自适应容器（容器适配器）**

个人理解：因为队列可以双向操作 vector只支持单向操作 所以不能用vector

queue<int, deuqe<int>> a;

queue<int, list<int>> a

a.empty()检查队列是否为空

a.size()检查队列里面数据的个数

a.front()查看队列的开头数据

a.back()查看队列的尾部数据

a.pop()删除队列的头部数据

a.push(item)在队列尾部添加数据

**priority_queue 自适应容器（容器适配器）**

不能使用list 因为list的迭代器不是任意存取iterator，而pop中用到堆排序时是要求randomaccess iterator 的

数据放在优先级队列里面 队列根据优先级 将数据放在队首

最大值优先级队列：始终将最大值放在队首

最小值优先级队列：始终将最小值放在队首

priority_queue<int, deque<int>> a

priority_queue<int, vector<int>> a 最大值优先队列 默认方式是vector 默认是最大值放在前面

a.empty()检查队列是否为空

a.size()检查队列里面数据的个数

a,top()查看队列的开头数据

a.pop()删除队列的头部数据

a.push(item)在队列尾部添加数据

priority_queue<int, vector<int>， greater<int>>最小值优先队列

顺序容器的定义

顺序容器：vector list deque，

容器适配器：stack，queue，priority_queue

vector<string> a

vector<string> b(a); 用a向量的参数 来初始化b向量的参数（这种初始化方式 要求a和b的类型必须一致）

list<string> c(a.begin(), a.end()); 可以使用迭代器来初始化两个不同类型的数据

list<string> d(64，"hello") d容器里面有64个hello字符串

顺序容器的操作

迭代器和迭代器范围

每一个容器都有自己的迭代器 但是每个迭代器的接口是一样的

常用的迭代器操作

*iter ++iter --iter iter1==iter2 iter!=iter2

vector和deque容器的迭代器的额外操作

iter+n iter-n > >= < <=

迭代器范围

begin/end first/last end是最后一个的下一个

某些对容器的操作 会使迭代器失效

顺序容器的操作

容器定义的类型别名

begin和end成员

vector<int>::size_type a1

vector<int>::iterator a2 迭代器

vector<int>::const_iterator a3 常迭代器

vector<int>::reverse_iterator a4逆序迭代器

vector<int>::const_reverse_iterator a5 常逆序迭代器

vector<int>::difference_type a6用来保存容器中两个迭代器之间的距离

《主要用在泛型程序设计时候使用》

vector<int>::value_type a7

vector<int>::reference a8 引用

vector<int>::const_reference a9

顺序容器的操作

在顺序容器中添加数据

a.push_back(t)在容器的尾部添加数据

a.push_front(t)在容器的头部添加数据（vector不可以进行这个操作）

c.insert(p,t)在p迭代器位置插入t元素

c.insert(p,n,t)在p迭代器位置插入n个t元素

c.insert(p,b,e)在p迭代器位置插入 另一个容器b迭代器到e迭代器的所有数据（不包括e迭代器所指向位置的元素）

容器元素都是副本 把原本数据拷贝一份

添加元素可能会使迭代器失效

避免存储end操作返回的迭代器

顺序容器的操作

关系运算符

所有容器类型都可以使用

比较的容器必须具有相同的容器类型

容器的比较是基于容器内元素的比较

容器内元素必须具有相应的关系运算符

两个容器比较 假如两个容器元素个数和元素都相等 则这两个容器相等

顺序容器的操作

容器大小的操作

a.size() 用来计算容器数据的个数 返回结果是size_type类型

a.max_size() 容器能够容纳数据的最大数量 返回结果是size_type类型

a.empty() 检查容器是否为空

a.resize(n) 调整容器大小为n

a.resize(n, t) 调整容器大小为n 新增加的数据为t

resize操作可能会使迭代器失效

顺序容器的操作

访问元素

a.back()返回最后一个数据

a.front()返回第一个数据

a[n]

a.at[n]

注意：a[n]和a.at[n]只适合vector和deque容器

vector<int>::reference a = a.back()/a.front(

顺序容器的操作

删除元素

c.erase(p) 删除p迭代器所指向的数据

c.erase(b, e) 删除b迭代器 到e 迭代器 所有数据

c.clean() 全部删除

c.pop_back() 删除最后一个

c.pop_front() 删除最前面的一个

注意：c.pop_front()只适用list和deque

顺序容器的操作

赋值与交换

c1 = c2 赋值

c1.swap(c2) 交换两个容器的值

c.assign(b,e)

c.assgin(n,t)

使用assign：类型兼容就可以了

使用swap：类型必须相同

vector容器的自增长

vector是用数组做出来的

数组的优点和缺点

capacity和reserve成员

capacity 可以显示容器的容量

reserve 可以设置容器容量

顺序容器的选用

顺序容器

vector的优点和缺点：

list优点和缺点

deque的优点和缺点

插入操作如何影响容器的选择

元素的访问如何影响容器的选择

选择容器的提示

构造string对象的方法

string s 定义一个s的空串

String s(s2) 用s2来定义s s2中的字符全部拷贝到s中 两者没有任何关系

string s("value") 定义一个字符串 用value 来初始化

string s(n, 'c') 用n个c来定义一个字符串

string s(b, e) 把迭代器b 到迭代器e之间的数值赋值给s

string s(cp, n) cp指针开始 后面的n个数 给字符串s

string s(s2, pos2) 从字符串s2的pos2位置开始赋值给s

string s(s2,pos2,len2) 从字符串s2的pos2位置开始 赋值len2个字符给s

修改string对象的方法

《-----------迭代器操作---------------》

s.insert(p, t)

s.insert(p, n, t)

s.insert(p, b, e)

s.assign(b, e)

s.assign(n, t)

s.erase(p)

s.erase(b, e)

《---------string方法---------------》

s.insert(pos, n, c)

s.insert(pos, s2)

s.insert(pos, s2, pos2, len)

s.insert(pos, cp, len)

s.insert(pos, cp)

s.assign(s2)

s.assign(s2,pos2,len)

s.assign(cp, len)

s.assign(cp)

s.erase(pos, len)

map（映射）、multimap（多映射）前者键不可以重复 后者可以

用来保存键值对数据

红黑树（数据结构）

基本操作

insert ：4种方法

count和find

erase：3种方法

注意不可以通过find进行修改

map<int, string> a;

a.insert(map<int,string>::value_type(1,"one")) 插入数据 1：one

a.insert(make_pair(-1,"minus one"));插入数据

a.insert(pair<int,string>(1000,"one thousand")) 插入数据

a[] = "one million" 插入数据

a.count(1000) 查找键为1000的个数

find(45) 查找键为45的元素 返回一个迭代器

erase(-1) 删除键为-1的元素 成功返回的数大于0

erase(p) p是要删除元素的迭代器位置 先用find查找要删除数据位置的迭代器 ，最后删除

a.erase(a.lower_bound(1000), a.upper_bound(1000)) 删除所有键为1000的元素

set（集）、multiset（多集）前者不可以重复 后者可以

用来保存键值对数据

红黑树（数据结构）

基本操作

insert

count和find

erase

注意不可以通过find进行修改

函数对象：有自己的类型 比普通函数要快 有自己的状态

STL算法------元素计数

count

count(b, e, t) 计算b迭代器 到 e迭代器之间t元素的个数

count_if

count_if(b, e, 函数或者函数对象) 计算b迭代器 到 e迭代器之间符合 函数或者函数对象 要求的元素的个数

关联容器的等效成员函数

set.count

multiset.count

map.count

multimap.count

STL算法------最大值和最小值

min_element(b, e) 查找b迭代器到e迭代器之间元素的最小值 返回值是一个迭代器 需要对迭代器解引用才会出现值

min_element(b,e,op) 查找b迭代器到e迭代器之间元素满足op函数条件的最小值 返回值是一个迭代器 需要对迭代器解引用才会出现值

max_element(b, e) 查找b迭代器到e迭代器之间元素的最大值 返回值是一个迭代器 需要对迭代器解引用才会出现值

max_element(b, e, op) 查找b迭代器到e迭代器之间元素满足op函数条件的最大值 返回值是一个迭代器 需要对迭代器解引用才会出现值

STL算法------查找算法

find()

find(b, e , t) 在容器中查找b迭代器到e迭代器中t元素的位置 返回类型是迭代器 返回是找到的第一个t元素位置

find_if()

find_if(b, e, 谓词) 在容器中查找b迭代器到e迭代器中查找符合谓词要求元素的位置 返回类型是迭代器 返回是找到的第一个t元素位置

如果是已序区间，可以使用已序区间查找算法

binary_search() 二分查找

includes()

lower_bound()

upper_bound()

关联式容器有等效的成员函数find()

string有等效的成员函数find()

string a("aaaaaaaaaaaaaaa")

string::size_type pos = s.find("a")

STL算法------查找算法

search_n() 用来查找连续的n个匹配的词 例如：连续的8等等 返回一个迭代器

search_n(b, e, c, v) 在b迭代器到e迭代器中 查找连续c个v的元素位置

search_n(b, e, c, v, p) 在b迭代器到e迭代器中 查找符合谓词p规定的连续c个的位置

STL算法------查找算法 视频stl查找算法3

search() 结果返回迭代器 可以使用这个函数查找连续的偶数或者特定序列的数列

search(b1, e1, b2, e2)在b1迭代器到e1迭代器范围里面找b2迭代器到e2迭代器的数据

find_end()从容器尾部开始查找

STL算法------查找算法

find_first_of(b, e, sb, se) 在b迭代器到e迭代器范围里面查找sb迭代器到se迭代器里面的任意一个数据

find_first_of(b, e, sb, se, bp) 在b迭代器到e迭代器范围里面查找符合谓词的的任意一个数据

使用逆向迭代器

STL算法------查找算法

adjacent_find(b, e) 在b迭代器到e迭代器范围里面查找连续两个相等的树

adjacent_find(b, e, p) 在b迭代器到e迭代器范围里面查找连续两个符合谓词规则的树

STL算法------查找算法

已序区间查找算法 查找的容器元素 和被查找的容器里面的数据 都需要排序

binary_search() 二分查找 返回true 或者 false 不返回目标元素位置

binary_search(b, e, v) 在b迭代器到e迭代器范围里面查找v元素的位置

binary_search(b, e, v, p)

includes() 包含查找 查找范围元素的位置 元素不一定连续 只要被查找容器里面有这些元素就可以了

includes(b, e, sb, se)

includes(b, e, sb, se, bp)

STL算法------查找算法

已序区间查找算法

lower_bound(b, e, v) 查找第一个可能的位置 返回一个迭代器

upper_bound() 查找最后一个可能的位置

equal_range() 同时查找第一个 和最后一个可能的位置

关联式容器有等效的成员函数，性能更佳

STL算法-for_each

for_each(b, e, p)

使用for_each()算法遍历数据

使用for_each()和函数对象修改数据

使用for_each()的返回值

STL算法-区间的比较

equal(b, e, b2) 比较两个容器区间的数据是否相等

equal(b, e ,b2, p) b迭代器到e迭代器之间的元素 和 b2迭代器之后的数据 经过谓词p比较之后是否相等

mismatch(b , e, b2) 查找两个容器中的不相等数据 返回值是一个pair<>a pair里面是两个迭代器 第一个迭代器指向第一个容器里面不相等的数据， 第二个迭代器指向第二个容器里面不相等的数据

mismatch(b, e, b2, p) 查找 第一个容器里面的数据 与第二个容器里面的数据符合p关系的数据

lexicographical_compare(b, e, b2, e2) 比较第一个区间是不是比第二个区间小

lexicographical_compare(b, e, b2, e2, p)

STL算法-复制元素

copy(b, e, b2)

copy_backward(b, e, e2)

注意：

没有copy_if()，可以使用remove_copy_if()算法

复制过程中要逆转元素次序，使用reverse_copy()算法

把容器内所有元素赋值给另一个容器，要使用赋值操作符或者容器的assign()成员函数

复制过程中删除某些元素，使用remove_copy()和remove_copy_if()

复制中改变元素，使用transform()或replace_copy()算法

back_inserter(容器) 插入型迭代器 专门用于容器容量不够时候

ostream_iterator<int>(cout, “ ”)输出流适配器 把数据拷贝到cout

STL算法-transform()

transform(b1, e1, b2, op) 把b1迭代器里面到e1迭代器里面的数据经过op之后 放到b2迭代器里面

transform(b1, e1, b2, ,b3 op)

如果目标与源相同， transform()就和for_each()一样

如果想以某值替换符合规则的元素，应该使用replace()算法

STL算法-交换算法

swap_ranges(b, e, b2) 交换数据的多少受到第一个迭代器容器的限制 返回一个迭代器 指向第二个容器没有交换的位置

注意：下列两种也是交换算法

容器的swap()成员函数

赋值函数

STL算法-填充新值

fill(b, e, v)

fill_n(b, n, v) 可以指定填充的个数

generate(b, e, p) 插入 经过p函数 得到的值

generate_n(b, n, p)

STL算法-替换算法

replace(b, e, ov, nv) 把b迭代器里面到e迭代器里面的 所有的ov 换成nv

replace_if(b, e, p, v) 把b迭代器里面到e迭代器里面的 所有的满足函数对象p的数据 换成v

replace_copy(b1, e1, b2, ov, nv) 边复制边替换 把b1迭代器里面到e1迭代器里面的数据 复制到b2迭代器里面 并且把所有的ov 换成nv

replace_copy_if(b1, e1, b2, p, v) 把b1迭代器里面到e1迭代器里面的数据 复制到b2迭代器里面 并且把所有的满足函数对象p的数据 换成v

STL算法-删除算法

remove(b, e, n) 返回最后一个的下一个迭代器

remove_if(b, e, p) 符合函数p规则的都会被删除

并不是真正的删除，而是把后面的元素向前移动，覆盖被删除的元素

返回新的逻辑终点

STL算法-删除算法

remove_copy(b, e, b2, n) 把b迭代器里面到e迭代器里面的拷贝到b2 并且把n删除掉

remove_copy_if(b, e, b2, op) 把b迭代器里面到e迭代器里面的拷贝到b2 把符合函数op规则的数据删除掉

STL算法-删除算法

unique(b,e) 删除连续的重复的数据

unique(b,e,p) 比较两个元素的大小 符合p函数规则的删除

unique_copy(b1,e1, b2) 拷贝到b2并且 删除连续的重复的数据

unique_copy(b1,e1, b2, p) 拷贝到b2并且 比较两个元素的大小 符合p函数规则的删除

STL算法-逆序和旋转

reverse(b ,e) 逆序

reverse_copy(b, e, b2) 拷贝到b2 并且逆序

rotate(b , b+n, e)旋转 旋转之后以b+n开头 将b 到 b+n 放在后面

rotate_copy(b, b+n, e, b2)复制到b2并且旋转 旋转之后以b+n开头 将b 到 b+n 放在后面

STL算法-排列组合

next_permutation(b, e) 返回值为true（没有排列完成）或者false（排列结束）

prev_permutation()

STL算法-重列算法、分区算法

random_shuffle() 随机排序 打乱排序

partition(b, e, p) 分区算法

stable_partition() 稳定的

STL算法-对所有元素排序

sort(b, e)

sort(b, e, p)

stable_sort(b, e)

stable_sort(b, e, p)

不适用于list容器，list有成员函数sort()

STL算法-局部排序

partial_sort(b, se, e)

partial_sort(b, se, e, p)

partial_sort_copy(sb, se, db de)

partial_sort_copy(sb, se, db de, p)

STL算法-根据第n个元素排序

nth_element(b, n, e)

nth_element(b, n, e, p)

STL算法-Heap算法

堆排序算法（heapsort）

make_heap(b, e) 把容器中的数据按堆方式排序

push_heap() 把新加入数据加入堆里面 对容器所有数据重新进行堆排序

pop_heap() 把最大的数字 放在容器后面

pop_back()把最后的删除

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。