目录
1 vector
1.1 初始化
如果没有指定元素的初始化式，那么标准库将自行提供一个元素初始值进行，具体值为何，取决于存储在vector 中元素的数据类型；
如果为int型数据，那么标准库将用 0 值创建元素初始化式；如果 vector 保存的是含有构造函数的类类型（如 string）的元素，标准库将用该类型的默认构造函数创建元素初始化式；元素类型可能是没有定义任何构造函数的类类型（自定义，此时emplace_back()会报错）。这种情况下，标准库仍产生一个带初始值的对象，这个对象的每个成员进行了值初始化。
vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
vector<int> a(b); //用b向量来创建a向量，整体复制性赋值
vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7); //从数组中获得初值1.2 操作
a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2个元素构成的向量赋给a
a.assign(4,2); //是a只含4个元素，且每个元素为2
a.back(); //返回a的最后一个元素
a.front(); //返回a的第一个元素
a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
a.clear(); //清空a中的元素
a.empty(); //判断a是否为空，空则返回ture,不空则返回false
a.pop_back(); //删除a向量的最后一个元素
a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+ 3（不包括它）
a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8 ，插入元素后为1,4,5,9,2,3,4,5,9,8
a.size(); //返回a中元素的个数；
a.capacity(); //返回a在内存中总共可以容纳的元素个数
a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，其值随机
a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，其值为2
a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才 显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）
a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<1.3 相关函数
sort(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开 始复制，覆盖掉原有元素
find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置2 string
2.1 构造
string s1(); //s1为空
string s2("hello");
string s3(4,'w'); //s3="wwww";
string s4("12345",1,3); //s4="234";2.2 常见用法
a) =,assign() //赋以新值
b) swap() //交换两个字符串的内容
c) +=,append(),push_back() //在尾部添加字符
d) insert() //插入字符
e) erase() //删除字符
f) clear() //删除全部字符
g) replace() //替换字符
h) + //串联字符串
i) ==,!=,<,<=,>,>=,compare() //比较字符串
j) size(),length() //返回字符数量
k) max_size() //返回字符的可能最大个数
l) empty() //判断字符串是否为空
m) capacity() //返回重新分配之前的字符容量
n) reserve() //保留一定量内存以容纳一定数量的字符
o) [ ], at() //存取单一字符
p) >>,getline() //从stream读取某值
q) << //将谋值写入stream
r) copy() //将某值赋值为一个C_string
s) c_str() //将内容以C_string返回
t) data() //将内容以字符数组形式返回
u) substr() //返回某个子字符串
v)查找函数
w)begin() end() //提供类似STL的迭代器支持
x) rbegin() rend() //逆向迭代器
y) get_allocator() //返回配置器2.3 substr巧用
（s+s).substr(n,s.size());
/* string s="abcdefg";
将前n个字符移动到尾部
例如 移动前2个字符
ss="cdefgab";
*/2.4 replace
被替代和替代子串长度可以不一样
//用str替换指定字符串从起始位置pos开始长度为len的字符
string& replace (size_t pos, size_t len, const string& str);
string s="12345";
s=s.replace(2,3,"aa"); //s="12aa";
//用str替换 迭代器起始位置 和 结束位置 的字符
string& replace (const_iterator i1, const_iterator i2, const string& str);
string s="12345";
s=s.replace(s.begin(),s.begin()+3,"aaa"); //s="aaa45";
string s1("Real Steel");
s1.replace(1, 3, "123456", 2, 4); //用 "123456" 的子串(2,4) 替换 s1 的子串(1,3)
cout << s1 << endl; //输出 R3456 Steel
string s2("Harry Potter");
s2.replace(2, 3, 5, '0'); //用 5 个 '0' 替换子串(2,3)
cout << s2 << endl; //输出 HaOOOOO Potter
int n = s2.find("OOOOO"); //查找子串 "00000" 的位置，n=2
s2.replace(n, 5, "XXX"); //将子串(n,5)替换为"XXX"
cout << s2 < < endl; //输出 HaXXX Potter3 map
map 是键－值对的集合(有序)，使用红黑树实现。map 类型通常可理解为关联数组：可使用键作为下标来获取一个值，正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联，而并非通过元素在数组中的位置来获取。
3.1 初始化
#include<map>
map<int,int> numCountMap;
3.2 操作
// 添加
numCountMap.insert({numName,thisAddTime});
numCountMap.insert(make_pair(numName,thisAddTime));
numCountMap.insert(pair<int,int>(numName,thisAddTime));
numCountMap.insert(map<int,int>::value_type(numName,thisAddTime));
//1、empty()
hash_map.empty()//
//2、size()
hash_map.size()//
//3、insert()
hash_map.insert({key,value})//插入键值对
//4、erase()
hash_map.erase(key)//删除某个键
//5、count()
hash_map.count(key)//返回匹配特定键的元素数量
//6、find()
hash_map.find(key)//查找给定键的位置，返回迭代器
//7、contains()
hash_map.contains(key)//检查容器是否含有带特定键的元素
//8、lower_bound()
hash_map.lower_bound(key)//返回指向首个不小于给定键的元素的迭代器
//9、upper_bound()
hash_map.upper_bound(key)//返回指向首个大于给定键的元素的迭代器
//10、clear()
hash_map.clear()
4 unordered_map
4.1 初始化
unordered_map<string, string> umap;4.2 操作
begin(); // 返回指向容器中第一个键值对的正向迭代器。
end(); // 返回指向容器中最后一个键值对之后位置的正向迭代器。
cbegin(); // 和 begin() 功能相同，只不过在其基础上增加了 const 属性，即该方法返回的迭代器不能用于修改容器内存储的键值对。
cend(); // 和 end() 功能相同，只不过在其基础上，增加了 const 属性，即该方法返回的迭代器不能用于修改容器内存储的键值对。
empty(); // 若容器为空，则返回 true；否则 false。
size(); // 返回当前容器中存有键值对的个数。
max_size(); // 返回容器所能容纳键值对的最大个数，不同的操作系统，其返回值亦不相同。
operator[key]; // 该模板类中重载了 [] 运算符，其功能是可以向访问数组中元素那样，只要给定某个键值对的键 key，就可以获取该键对应的值。注意，如果当前容器中没有以 key 为键的键值对，则其会使用该键向当前容器中插入一个新键值对。
at(key); // 返回容器中存储的键 key 对应的值，如果 key 不存在，则会抛出 out_of_range 异常。
find(key); // 查找以 key 为键的键值对，如果找到，则返回一个指向该键值对的正向迭代器；反之，则返回一个指向容器中最后一个键值对之后位置的迭代器（如果 end() 方法返回的迭代器）。
count(key); // 在容器中查找以 key 键的键值对的个数。0/1
equal_range(key); // 返回一个 pair 对象，其包含 2 个迭代器，用于表明当前容器中键为 key 的键值对所在的范围。
emplace(); // 向容器中添加新键值对，效率比 insert() 方法高。
emplace_hint(); // 向容器中添加新键值对，效率比 insert() 方法高。
insert(); // 向容器中添加新键值对。
erase(); // 删除指定键值对。
clear(); // 清空容器，即删除容器中存储的所有键值对。
swap(); // 交换 2 个 unordered_map 容器存储的键值对，前提是必须保证这 2 个容器的类型完全相等。
bucket_count(); // 返回当前容器底层存储键值对时，使用桶（一个线性链表代表一个桶）的数量。
max_bucket_count(); // 返回当前系统中，unordered_map 容器底层最多可以使用多少桶。
bucket_size(n); // 返回第 n 个桶中存储键值对的数量。
bucket(key); // 返回以 key 为键的键值对所在桶的编号。
load_factor(); // 返回 unordered_map 容器中当前的负载因子。负载因子，指的是的当前容器中存储键值对的数量（size()）和使用桶数（bucket_count()）的比值，即 load_factor() = size() / bucket_count()。
max_load_factor(); // 返回或者设置当前 unordered_map 容器的负载因子。
rehash(n); // 将当前容器底层使用桶的数量设置为 n。
reserve(); // 将存储桶的数量（也就是 bucket_count() 方法的返回值）设置为至少容纳count个元（不超过最大负载因子）所需的数量，并重新整理容器。
hash_function(); // 返回当前容器使用的哈希函数对象。
map与unordered_map的原理区别：
https://blog.csdn.net/qq_35102059/article/details/124110202?spm=1001.2014.3001.5502
5 queue
5.1 初始化和操作
#include<queue>
queue<int> q;
int num;
q.front(); //返回对头元素
q.back(); //访问队尾元素
q.push(num);//入队操作
q.pop(); //出队操作
q.empty(); //如果队列为空则返回真
q,size() ; //返回队列大小6 deque
6.1 初始化
所谓的deque是”double ended queue”的缩写，双端队列不论在尾部或头部插入元素，都十分迅速。而在中间插入元素则会比较费时，因为必须移动中间其他的元素。双端队列是一种随机访问的数据类型，提供了在序列两端快速插入和删除操作的功能，它可以在需要的时候改变自身大小，完成了标准的C++数据结构中队列的所有功能。
虽然deque也提供Random Access Iterator，但它的迭代器并不是普通指针，其复杂度和vector不可同日而语，这当然涉及到各个运算层面。因此，除非必要，我们应尽可能选择使用vector而非deque。对deque进行的排序操作，为了最高效率，可将deque先完整复制到一个vector身上，将vector排序后（利用STL的sort算法），再复制回deque。
#include<deque> / 头文件
deque<type> deq; / 声明一个元素类型为type的双端队列que
deque<type> deq(size); / 声明一个类型为type、含有size个默认值初始化元素的的双端队列que
deque<type> deq(size, value); / 声明一个元素类型为type、含有size个value元素的双端队列que
deque<type> deq(mydeque); / deq是mydeque的一个副本
deque<type> deq(first, last); / 使用迭代器first、last范围内的元素初始化deq6.2 操作
deque<int> deq;
deq[ ]：用来访问双向队列中单个的元素。
deq.front()：返回第一个元素的引用。
deq.back()：返回最后一个元素的引用。
deq.push_front(x)：把元素x插入到双向队列的头部。
deq.pop_front()：弹出双向队列的第一个元素。
deq.push_back(x)：把元素x插入到双向队列的尾部。
deq.pop_back()：弹出双向队列的最后一个元素。注意:deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。其余类似vector操作方法的使用。
7 priority_queue
本质是堆，但它具有队列的所有操作特性，与普通队列不同的地方就是出队的时候按照优先级顺序出队，这个优先级即最大堆或最小堆的规则（即大的为top优先出队或小的为top优先出队），在队列的基础上加了个堆排序。
7.1 初始化
//构造一个空的优先队列（此优先队列默认为大顶堆）
priority_queue<int> big_heap;
//另一种构建大顶堆的方法
priority_queue<int,vector<int>,less<int> > big_heap2;
//构造一个空的优先队列,此优先队列是一个小顶堆
priority_queue<int,vector<int>,greater<int> > small_heap; 7.2 操作
push(); // 它将新元素插入优先队列,自动调整排序。
pop(); // 它将优先级最高的元素从队列中删除。
top(); // 此函数用于寻址优先队列的最顶层元素。
size(); // 返回优先队列的大小。
empty(); // 它验证队列是否为空。基于验证，它返回队列的状态。
swap(); // 它将优先队列的元素与具有相同类型和大小的另一个队列交换。
emplace(); // 它在优先队列的顶部插入一个新元素。8 set
set集合容器：实现了红黑树的数据结构，插入元素时，它会自动调整（旋转最多3次）二叉树的排列，把元素放到适当的位置，以保证每个子树根节点键值大于左子树所有节点的键值，小于右子树所有节点的键值。二叉检索树使用中序遍历算法，检索效率高于vector、deque和list等容器，另外使用中序遍历可将键值按照从小到大遍历出来。构造set集合主要目的是为了快速检索，不可直接去修改键值（值为1）。
红黑树与平衡二叉树的原理区别：
https://blog.csdn.net/qq_35102059/article/details/124110202?spm=1001.2014.3001.5502
8.1 初始化
vector<int> ivec;
for (vector<int>::size_type i = 0; i != 10; ++i)
{
ivec.push_back(i);
ivec.push_back(i);
}
set<int> iset(ivec.begin(), ivec.end());
cout << ivec.size() << endl; //20个
cout << iset.size() << endl; // 10个
8.2 操作
// 添加元素
set<string> set1;
set1.insert("the"); //第一种方法：直接添加
set<int> iset2;
iset2.insert(ivec.begin(), ivec.end()); //第二中方法：通过指针迭代器
// 删除元素
set<int> s;
s.erase(2); //删除键值为2的元素
s.clear();
// 访问元素
set<int> iset;
for(int i = 0; i<10; i++)iset.insert(i);
iset.find(1) // 返回指向元素内容为1的指针
iset.find(11) // 返回指针iset.end()
iset.count(1) // 存在，返回1
iset.count(11) // 不存在，返回0
iset[11] // 次操作会直接创建11键值 ？？ 存疑9 list
9.1 初始化
#include <list> #使用时需要添加头文件
list<int> lst1; //创建空list
list<int> lst2(3); //创建含有三个元素的list
list<int> lst3(3,2); //创建含有三个元素的值为2的list
list<int> lst4(lst2); //使用lst2初始化lst4
list<int> lst5(lst2.begin(),lst2.end()); //同lst49.2 操作
lst1.assign(lst2.begin(),lst2.end()); //分配值
lst1.push_back(10); //添加值
lst1.pop_back(); //删除末尾值
lst1.begin(); //返回首值的迭代器
lst1.end(); //返回尾值的迭代器
lst1.clear(); //清空值
bool isEmpty1 = lst1.empty(); //判断为空
lst1.erase(lst1.begin(),lst1.end()); //删除元素
lst1.front(); //返回第一个元素的引用
lst1.back(); //返回最后一个元素的引用
lst1.insert(lst1.begin(),3,2); //从指定位置插入3个值为2的元素
lst1.rbegin(); //返回第一个元素的前向指针
lst1.remove(2); //相同的元素全部删除
lst1.reverse(); //反转
lst1.size(); //含有元素个数
lst1.sort(); //排序
lst1.unique(); //删除相邻重复元素
1510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
