C++STL常用函数

注：总结C++STL常用函数

1 数组

定义

int arr[size];//定义一个大小为size的数组。

若不初始化，数组中保存随机值。注意arr相当于一个指针，并不保存数组的大小。

2 顺序容器

string

• c++中的字符串可以理解为一个字符数组（但并不完全等价）

//定义&初始化
string s="hello";
string s("hello");
//求字符串长度
int size=s.size();

//字符串转整数
string s = "123";
int num = atoi(s.c_str());
//整数转字符串
int num = 123;
string num_str = to_string(num);

vector

//定义
vector<int> vec(3);//定义一个大小为3的向量（向量元素默认为0）
vector<int> vec(3,1);//每个元素为1

//求尺寸、判空
int size=vec.size();
bool empty():判断向量是否为空

//添加元素
vec.emplace_back(1);C++11对几乎所有容器新增了emplace函数，相比push效率更高
vec.push_back(1);//向尾部添加元素
vec.insert(iterator it,1);//向指定位置添加元素
vec.insert(iterator it,const_iterator first,const_iterator last);//向指定位置添加[first,last)之间的元素

//删除元素
vec.pop_back();//从尾部删除元素
vec.erase(iterator it);//删除指定位置的元素
vec.erase(iterator first,iterator last);//删除[first,last)之间的元素
vec.remove(1);//删除所有和指定元素值相等的元素，并返回指向最后一个元素下一个位置的迭代器。值得一提的是，调用该函数不会改变容器的大小和容量。
vec.clear();

//遍历
reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

//其它
void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中第n个元素的值为x

//排序
sort(vec.begin(),vec.end());//从小到大排序
sort(vec.rbegin(),vec.rend());//从大到小排序

list

list 容器，又称双向链表容器，即该容器的底层是以双向链表的形式实现的。这意味着，list 容器中的元素可以分散存储在内存空间里，而不是必须存储在一整块连续的内存空间中。

//定义&初始化
list<int> ls;
list<int> ls(10);
list<int> ls(10,5);

//添加
ls.push_back(1);
ls.push_front(1);
ls.emplace_back(1);
ls.emplace_front(1);
ls.insert(iterator it,1);//向指定位置添加元素

//删除
ls.pop_back();//从尾部删除元素
ls.pop_front();//从首部删除元素
ls.erase(iterator it);//删除指定位置的元素
ls.remove(1);
ls.clear();

//遍历
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回头指针，指向第一个元素
iterator end():返回尾指针，指向最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

//其它
void swap(list&):交换两个同类型向量的数据
reverse()//通过reverse()完成list的逆置。
merge(list&);//合并两个链表并使之默认升序(也可改)

3 容器适配器

标准库提供了三种顺序容器适配器：queue(FIFO队列)、priority_queue(优先级队列)、stack(栈)。学过Java的选手，可以在这里将容器适配器类比于Java中的接口，只定义一种规范，对容器进行包装，使其表现出另外一种行为。

stack

//定义
stack<int> s;
stack< int, vector<int> > stk;  //覆盖基础容器类型，使用vector实现stk
s.empty();  //判断stack是否为空，为空返回true，否则返回false
s.size();   //返回stack中元素的个数

//增、删、取首元素
s.push(item);
s.emplace(item); //在栈顶压入新元素item
s.pop();    //删除栈顶元素，但不返回其值
s.top();    //返回栈顶元素的值，但不删除此元素

queue

//定义
queue<int> q; //priority_queue<int> q;
q.empty();  //判断队列是否为空
q.size();   //返回队列长度

//增、删、取首元素
q.push(item);   //插入新元素
q.emplace(item);
q.pop(); //删除队首元素
q.front();  //返回队首元素的值，但不删除该元素
q.back();   //返回队尾元素的值，但不删除该元素

priority_queue

//定义
priority_queue<int> q;
q.empty();  //判断队列是否为空
q.size();   //返回队列长度

//增、删、取首元素
q.push(item);  //插入新元素
q.emplace(item);
q.pop(); //删除队首元素
q.top();    //返回具有最高优先级的元素值，但不删除该元素

4 关联容器-集合

set/multiset

set 是关联容器，含有 Key 类型对象的已排序集。set容器内的元素会被自动排序，set与map不同，set中的元素即是键值又是实值，set不允许两个元素有相同的键值。不能通过set的迭代器去修改set元素，原因是修改元素会破坏set组织。当对容器中的元素进行插入或者删除时，操作之前的所有迭代器在操作之后依然有效。
multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。

//定义
set<int> s;

//求大小 判空
int size=s.size();
bool isempty=s.empty();

//添加元素
s.emplace(1);
s.insert(10);

//删除元素
s.erase(1);

//查找元素
s.find(k)//根据k进行查找，返回一个指向被查找到元素的迭代器
s.count(k)//返回指定元素出现的次数

//遍历
iterator begin():返回头指针，指向第一个元素
iterator end():返回尾指针，指向最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

//其它
void swap( set& other );// 两个set的内容互换

unordered_set/unordered_multiset

使用方法与set几乎一致，区别在于set内部有序，而unordered_set内部无序。通常在没有排序要求的情况下，使用unordered_set以节省时间。

5 关联容器-映射

map/multimap

map和multimap都需要#include< map>，唯一的不同是，map的键值key不可重复，而multimap可以，也正是由于这种区别，map支持[ ]运算符，multimap不支持[ ]运算符。在用法上没什么区别。

//定义
map<int,string> mp;

//求大小 判空
int size=mp.size();
bool isempty=mp.empty();

//添加元素
mp.emplace(1,"cpp");//如果key存在会直接覆盖
mp.insert(pair<int, string>(1, "student_one"));//如果key存在则不插入

//删除元素
mp.erase(k);//删除k对应的键值对
iterator erase( iterator pos )// 删除迭代器指向位置的键值对，并返回一个指向下一元素的迭代器
iterator erase( const_iterator first, const_iterator last );// 删除一定范围内的元素，并返回一个指向下一元素的迭代器
size_t erase( const key_type& key );// 根据Key来进行删除， 返回删除的元素数量，在map里结果非0即1
void clear();// 清空map，清空后的size为0

//查找
mp.find(k)//根据k进行查找，如果mp的键中不存在key，则返货mp.end()
mp.count(k)//返回指定元素出现的次数

//遍历
iterator begin():返回头指针，指向第一个元素
iterator end():返回尾指针，指向最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

//其它
void swap( map& other );// 两个map的内容互换

unordered_map/unordered_multimap

使用方法与map几乎一致，区别在于map内部有序，而unordered_map内部无序。通常在没有排序要求的情况下，使用unordered_map以节省时间。