vector list deque set map 容器的基本使用方法 包括了容器中几乎所有的成员函数
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
#include<deque>
#include<set>
#include<map>
using namespace std;
int main()
{
//vector
{
std::vector<int> v{ 1,2,3,4,5,6,7,8,9,10 };
std::vector<int> v1{ 1,2,3,4,5,6,7,8,9,10 };
//迭代器
v.begin();
v.end();//迭代终止值//无值
v.rbegin();//反向迭代起点
v.rend();//反向迭代终止值//无值
v.cbegin();//const迭代起点
v.cend();//const迭代终止值//无值
v.crbegin();//const反向迭代起点
v.crend();//const反向迭代终止值//无值
//信息
v.size();//容器大小
v.max_size();//容器最大容量
v.empty();//容器是否为空
v.capacity();//容器容量
//容器调整
v.reserve(10);//容器容量设置为10//不进行缩容
v.shrink_to_fit();//容器容量调整为实际大小
v.clear();//清空容器
v.resize(10);//设置容器大小为10
v.resize(10, 1);//设置容器大小为10，值为1
//删
v.pop_back();//删除容器末尾元素
auto iter = v.erase(v.begin());//删除容器头部元素
v.erase(v.begin(), v.end());//删除容器头部到尾部元素
//增//可以使用move
v.push_back(11);//在容器末尾添加一个元素
v.insert(v.begin(), 11);//在容器头部插入一个元素
v.insert(v.begin(), 11, 0);//在容器头部插入11个元素
v.insert(v.begin(), { 1,2,3,4 });//在容器头部插入一个数组
v.insert(v.begin(), v1.begin(), v1.end());//在容器头部插入v1容器的元素
// 不会构建临时类
v.emplace(v.begin(), 1);//在容器头部插入一个元素
v.emplace_back(1);//在容器尾部插入一个元素
//查
v[0];//获取第一个元素
v.at(0);//获取容器第一个元素
v.front();//获取容器第一个元素
v.back();//获取容器最后一个元素
v.data();//获取容器数据指针
//改
v.assign(10, 1);//设置容器大小为10，值为1
v.assign(v.begin(), v.end());//迭代替换内容//设置容器大小为容器大小，值为容器值
v.assign({ 1,2,3 });//替换内容
v.swap(v);//交换容器内容
}
//list
{
std::list<int> l{ 1,2,3,4,5,6,7,8,9,10 };
std::list<int> l1{ 1,2,3,4,5,6,7,8,9,10 };
//迭代器
l.begin();//迭代起点
l.end();//迭代终止值//无值
l.rbegin();//反向迭代起点
l.rend();//反向迭代终止值//无值
l.cbegin();//const迭代起点
l.cend();//const迭代终止值//无值
l.crbegin();//const反向迭代起点
l.crend();//const反向迭代终止值//无值
//信息
l.size();//容器大小
l.max_size();//容器最大容量
l.empty();//容器是否为空
//容器调整
l.clear();//清空容器
l.resize(10);//设置容器大小为10
l.resize(10, 1);//设置容器大小为10，值为1
l.reverse();//反转容器
//删
l.pop_front();//删除容器头部元素
l.pop_back();//删除容器末尾元素
auto iter = l.erase(l.begin());//删除容器头部元素
l.erase(l.begin(), l.end());//删除容器头部到尾部元素
l.remove(1);//删除容器中值为1的元素
l.remove_if([](int i) {return i % 2 == 0; });//删除容器中值为偶数的元素
//增//可以使用move
l.push_front(11);//在容器头部插入一个元素
l.push_back(11);//在容器末尾添加一个元素
l.insert(l.begin(), 11);//在容器头部插入一个元素
l.insert(l.begin(), 11, 0);//在容器头部插入11个元素
l.insert(l.begin(), { 1,2,3,4 });//在容器头部插入一个数组
l.insert(l.begin(), l1.begin(), l1.end());//在容器头部插入v1容器的元素
// 不会构建临时类
l.emplace(l.begin(), 1);//在容器头部插入一个元素
l.emplace_front(1);//在容器头部插入一个元素
l.emplace_back(1);//在容器尾部插入一个元素
//归并排序
l.sort();
l1.sort();
l.merge(l1);//合并l1到l中
//剪切粘贴
l.splice(l1.begin(), l1);//将l1中的元素粘贴到l中
//l1空
l1.insert(l1.begin(), { 1, 2, 3, 4 });
//
l.splice(l.begin(), l1, l1.begin());//将l1中的元素粘贴到l中，从l1的第一个元素开始
//l1空
l1.insert(l1.begin(), { 1, 2, 3, 4 });
//
l.splice(l.begin(), l1, l1.begin(), l1.end());//将l1中的元素粘贴到l的前面，从l1的头部到尾部
//查
l.front();//获取容器第一个元素
l.back();//获取容器最后一个元素
//改
l.assign(10, 1);//设置容器大小为10，值为1
l.assign(l.begin(), l.end());//迭代替换内容//设置容器大小为容器大小，值为容器值
l.assign({ 1,2,3 });//替换内容
l.swap(l);//交换容器内容
}
//deque
{
std::deque<int> d{ 1,2,3,4,5,6,7,8,9,10 };
std::deque<int> d1{ 1,2,3,4,5,6,7,8,9,10 };
//迭代器
d.begin();//迭代起点
d.end();//迭代终止值//无值
d.rbegin();//反向迭代起点
d.rend();//反向迭代终止值//无值
d.cbegin();//const迭代起点
d.cend();//const迭代终止值//无值
d.crbegin();//const反向迭代起点
d.crend();//const反向迭代终止值//无值
//信息
d.size();//容器大小
d.max_size();//容器最大容量
d.empty();//容器是否为空
//容器调整
d.clear();//清空容器
d.resize(10);//设置容器大小为10
d.resize(10, 1);//设置容器大小为10，值为1
d.shrink_to_fit();//调整容器大小为实际大小
//删
d.pop_front();//删除容器头部元素
d.pop_back();//删除容器末尾元素
auto iter = d.erase(d.begin());//删除容器头部元素
d.erase(d.begin(), d.end());//删除容器头部到尾部元素
//增//可以使用move
d.push_front(11);//在容器头部插入一个元素
d.push_back(11);//在容器末尾添加一个元素
d.insert(d.begin(), 11);//在容器头部插入一个元素
d.insert(d.begin(), 11, 0);//在容器头部插入11个元素
d.insert(d.begin(), { 1,2,3,4 });//在容器头部插入一个数组
d.insert(d.begin(), d.begin(), d.end());//在容器头部插入一个容器
// 不会构建临时类
d.emplace(d.begin(), 1);//在容器头部插入一个元素
d.emplace_front(1);//在容器头部插入一个元素
d.emplace_back(1);//在容器尾部插入一个元素
//查
d[0];//获取容器第一个元素
d.at(0);//获取容器第一个元素
d.front();//获取容器第一个元素
d.back();//获取容器最后一个元素
//改
d.assign(10, 1);//设置容器大小为10，值为1
d.assign(d1.begin(), d1.end());//迭代替换内容//设置容器大小为容器大小，值为容器值
d.assign({ 1,2,3 });//替换内容
d.swap(d1);//交换容器内容
}
//set
//C++ 标准库容器类 set 用于存储和检索集合中的数据。
//元素的值 set 是唯一的，用作数据自动排序依据的键值。
//可能不会直接更改元素的值 set 。
//必须先删除旧值，才能插入具有新值的元素。
{
std::set<int> s{ 1,2,3,4,5,6,7,8,9,10 };
std::set<int> s1{ 1,2,3,4,5,6,7,8,9,10 };
//迭代器
s.begin();//迭代起点
s.end();//迭代终止值//无值
s.rbegin();//反向迭代起点
s.rend();//反向迭代终止值//无值
s.cbegin();//const迭代起点
s.cend();//const迭代终止值//无值
s.crbegin();//const反向迭代起点
s.crend();//const反向迭代终止值//无值
//信息
s.size();//容器大小
s.max_size();//容器最大容量
s.empty();//容器是否为空
//容器调整
s.clear();//清空容器
//删
s.erase(2);//删除容器中键匹配的元素
//一般不使用
if(false)
{
auto iter = s.erase(s.begin());//删除容器头部元素
s.erase(s.begin(), s.end());//删除容器头部到尾部元素
}
//增//可以使用move
s.insert(11);//在容器中插入一个元素
s.insert({ 1,2,3,4 });
//可能会引发异常//一般不使用
if (false)
{
s.insert(s.begin(), 11);//在容器头部插入一个元素
s.insert(s1.begin(), s1.end());//在容器头部插入一个容器
}
// 不会构建临时类
s.emplace(1);//在容器中插入一个元素
//一般不使用
{
s.emplace_hint(s.begin(), 1);//在容器头部插入一个元素
}
//查
s.find(1);//查找迭代器
s.count(1);//获取元素个数
s.lower_bound(1);//返回最后一个 key<=Keyval 元素的迭代器
s.upper_bound(1);//返回最后一个 key>Keyval 元素的迭代器
s.equal_range(11);//返回容器中 key 与 Keyval 相等的上下限的两个迭代器
//改
s.swap(s);//交换容器内容
//特殊
//key_compare两者value_compare都是模板参数Traits的同义词
set <int, less<int> > s2;
set<int, less<int> >::key_compare kc2 = s2.key_comp();
bool result2 = kc2(2, 3);//true
set <int, greater<int> > s3;
set<int, greater<int> >::key_compare kc3 = s3.key_comp();
bool result3 = kc3(2, 3);//false
}
//map
{
std::map<int, int> m{ { 1,1 },{ 2,2 },{ 3,3 },{ 4,4 },{ 5,5 },{ 6,6 },{ 7,7 },{ 8,8 },{ 9,9 },{ 10,10 } };
std::map<int, int> m1{ { 1,1 },{ 2,2 },{ 3,3 },{ 4,4 },{ 5,5 },{ 6,6 },{ 7,7 },{ 8,8 },{ 9,9 },{ 10,10 } };
//迭代器
m.begin();//迭代起点
m.end();//迭代终止值//无值
m.rbegin();//反向迭代起点
m.rend();//反向迭代终止值//无值
m.cbegin();//const迭代起点
m.cend();//const迭代终止值//无值
m.crbegin();//const反向迭代起点
m.crend();//const反向迭代终止值//无值
//信息
m.size();//容器大小
m.max_size();//容器最大容量
m.empty();//容器是否为空
//容器调整
m.clear();//清空容器
//删
m.erase(2);//删除容器中键匹配的元素
//一般不使用
if (false)
{
auto iter = m.erase(m.begin());//删除容器头部元素
m.erase(m.begin(), m.end());//删除容器头部到尾部元素
}
//增//可以使用move
m.insert({ 11,11 });//在容器中插入一个元素
m.insert({ { 1,1 },{ 2,2 },{ 3,3 },{ 4,4 },{ 5,5 },{ 6,6 },{ 7,7 },{ 8,8 },{ 9,9 },{ 10,10 } });
//可能会引发异常//一般不使用
if (false)
{
m.insert(m.begin(), { 11,11 });//在容器头部插入一个元素
m.insert(m1.begin(), m1.end());//在容器头部插入一个容器
}
// 不会构建临时类
m.emplace(1, 1);//在容器中插入一个元素
//一般不使用
{
m.emplace_hint(m.begin(), 1, 1);//在容器头部插入一个元素
}
//查
m[1];//获取元素
m.at(1);//获取元素
m.find(1);//查找迭代器
m.count(1);//获取元素个数
m.key_comp();//获取关键字比较函数
m.value_comp();//获取值比较函数
m.lower_bound(1);//返回最后一个 key<=Keyval 元素的迭代器
m.upper_bound(1);//返回最后一个 key>Keyval 元素的迭代器
m.equal_range(11);//返回容器中 key 与 Keyval 相等的上下限的两个迭代器
//改
m.swap(m);//交换容器内容
//特殊
//key_compare两者value_compare都是模板参数Traits的同义词
map <int, int, less<int> > m2;
map<int, int, less<int> >::key_compare kc2 = m2.key_comp();
bool result2 = kc2(2, 3);//true
map <int, int, greater<int> > m3;
map<int, int, greater<int> >::key_compare kc3 = m3.key_comp();
bool result3 = kc3(2, 3);//false
}
}
