​C++STL库函数总结​

转载自C++STL库函数总结

• #include< algorithm >库函数
• • • 1.sort排序
    • 2.reverse倒转
    • 3.unique去重
    • 4.二分查找
    • 5.find函数查找
    • 6.字符串和整型的互换
    • 7.排列组合
• #include< vector >库函数
• • • 1.vector介绍
    • 2.vector的功能函数
• #include< stack >堆栈库函数
• • • 1.stack介绍
    • 2.stack的函数
• #include< queue >队列库函数
• • • 1.queue正常队列
    • 2.priority_queue优先队列
• #include< list >双向链表库函数
• • • 1.list介绍
    • 2.list的函数
• #include< deque >双向队列库函数
• • • 1.deque介绍
    • 2.deque函数
• #include< ctype.h>字符串判断库函数
• • • 1.ctype介绍
    • 2.ctype函数
• #include< stdlib.h>网络库函数
• • • 1.stdlib介绍
    • 2.stdlib函数
• #include< math.h>数学库函数
• • • 1.取整函数

#include< algorithm >库函数

1.sort排序

函数原型：sort(起始地址, 末尾地址, cmp),其中cmp是可以自己定义的函数名.

sort(a,a+5);//默认从小到大
sort(a,a+5,cmp);//需要自己构造函数
sort(vec.begin(),vec.end());//vector排序
sort(vec.begin(),vec.end(),cmp);//vector自定义构造函数排序

2.reverse倒转

函数原型：reverse(起始地址，末尾地址)。

reverse(a,a+5);//普通数组
reverse(vec.begin(),vec.end());//vector倒转

3.unique去重

注意：unique去重需要先用sort排序，去重后重复的元素会放在数组尾端并且缩减数组长度，需要用erase函数实现真正删除。

sort(a,a+5);//数组
int pos = unique(a,a+5);//unique去重返回尾地址pos
erase(pos,a+5);//从尾地址到最后空间进行删除
-------------------------------------------------
sort(vec.begin(),vec.end());//vector
int pos = unique(vec.begin(), vec.end());//unique去重返回尾地址pos
vec.erase(pos, vec.end());//从尾地址到最后空间进行删除

4.二分查找

函数原型：
1.lower_bound(起始地址, 末尾地址,x)：查找第一个大于等于x目标值的位置
2.upper_bound(起始地址, 末尾地址,x)：查找第一个大于x目标值的位置
3.binary_search(起始地址, 末尾地址,x)：查找x是否存在于数组或vector中，找到返回true，否则返回false

int pos1=lower_bound(a,a+5,2)-a;//数组
int pos2=upper_bound(a,a+5,2)-a;
int flag=binary_search(a,a+5,2);
-----------------------------------------------------------
int pos1=lower_bound(vec.begin(),vec.end(),2)-vec.begin();//vector
int pos2=upper_bound(vec.begin(),vec.end(),2)-vec.begin();
int flag=binary_search(vec.begin(),vec.end(),2);

5.find函数查找

函数原型：
1.s1.find(s2)：在s1字符串中查找s2，查找到返回第一个字符的位置，查找失败返回s1.npos，这个其实是一个数字4294967295，即s1.npos=4294967295
2.set.find(a)：查找a是否在set中，如果找不到，返回set.end()
2.set.count(a)：本来是计算a出现的次数，但是由于集合中是没有重复元素的，于是count函数也就被作为查找函数了，因为a只能出现1次或者0次，查找成功，返回1；查找失败返回0
3.map.find()：主要用于查找key是否存在map中，不存在返回map.end()，用法和set一样

6.字符串和整型的互换

函数原型：
1.stoi(s)：将字符串s转化成整形，s为string类型，即string --> int
2.atoi(s)：将字符串转化为整形，但s为const char类型，可以先用s.c_str()方法把string类型转化为const char类型，再转为整形，即const char --> int
3.stringstream：需要头文件#include< sstream>,可将只含数字的字符串转化为整形，也可将数字和小数点组成的字符串转化为浮点型，即string --> int, string --> double
4.stringstream：需要头文件#include< sstream>，可将整形或浮点型数字转化为字符串，即int --> string, double --> string
5.to_string()：可将整形转化为字符串，不推荐将浮点型转化为字符串

7.排列组合

next_permutation()，求当前排列的下一个全排列
prev_permutation()，求当前排列的上一个全排列

#include< vector >库函数

1.vector介绍

vector和built-in数组类似，拥有一段连续的内存空间，能非常好的支持随即存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当插入较多的元素后，预留内存空间可能不够，需要重新申请一块足够大的内存并把原来的数据拷贝到新的内存空间。这些影响了vector的效率，但是实际上用的最多的还是vector容器，建议大多数时候使用vector效率一般是不错的。

创建vector对象，vector< int > vec;
/vector的函数部分适用于string字符串/

2.vector的功能函数

vec.push_back();//在vector的最后位置添加一个数据
vec.pop_back();//去掉vector的最后一个数据 
vec.at();//得到编号位置的数据
vec.begin();//得到vector头的指针
vec.end();//得到vector的最后一个单元+1的指针
vec.front();//得到vector最前面的值
vec.back();//得到数组的最后一个单元的引用
vec.max_size();//得到vector最大可以是多大/ 区别与vec.size()
vec.capacity();//当前vector分配的大小
vec.size();//当前使用数据的大小
vec.resize();//改变当前使用数据的大小，如果它比当前使用的大,则填充默认值
vec.reserve();//改变当前vecotr所分配空间的大小
vec.erase();//删除指针指向的数据项
vec.clear();//清空当前的vector
vec.rbegin();//将vector反转后的开始指针返回(其实就是原来的end-1)
vec.rend();//将vector反转构的结束指针返回(其实就是原来的begin-1)
vec.empty();//判断vector是否为空,为空返回true,否则返回false
vec.swap();//与另一个vector交换数据

#include< stack >堆栈库函数

1.stack介绍

堆栈是一个线性表，插入和删除只在表的一端进行。这一端称为栈顶(Stack Top)，另一端则为栈底(Stack Bottom)。堆栈的元素插入称为入栈，元素的删除称为出栈。由于元素的入栈和出栈总在栈顶进行，因此，堆栈是一个后进先出(Last In First Out)表，即 LIFO 表。为了严格遵循堆栈的数据后进先出原则，stack 不提供元素的任何迭代器操作，因此，stack 容器也就不会向外部提供可用的前向或反向迭代器类型。

2.stack的函数

创建stack对象，stack< int >s

s.empty();//堆栈为空则返回true,否则返回false
s.pop();//移除栈顶元素
s.push();//在栈顶增加元素
s.size();//返回栈中元素数目
s.top();//返回栈顶元素

#include< queue >队列库函数

1.queue正常队列

创建queue对象，queue< int >q

q.push();//将元素接到队列的末端；
q.pop();//弹出队列的第一个元素，并不会返回元素的值；
q.front();//访问队首元素
q.back();//访问队尾元素
q.size();//访问队中的元素个数
q.empty();//队列为空返回true,否则返回false

2.priority_queue优先队列

创建priority_queue对象，priority_queue< int >q;//默认大顶堆

priority_queue <int,vector<int>,greater<int> > q;//升序队列,小顶堆
priority_queue <int,vector<int>,less<int> >q;//降序队列,大顶堆

优先队列的使用工具与队列相同，不同点在于优先队列具有自动排序功能

#include< list >双向链表库函数

1.list介绍

list就是数据结构中的双向链表(根据sgi stl源代码)，因此它的内存空间是不连续的，通过指针来进行数据的访问，这个特点使得它的随即存取变的非常没有效率，因此它没有提供[]操作符的重载。但由于链表的特点，它可以以很好的效率支持任意地方的删除和插入。

2.list的函数

list的构造函数
创建list对象，list< int >l

list()//声明一个空列表；
list(n)//声明一个有n个元素的列表，每个元素都是由其默认构造函数T()构造出来的
list(n,val)//声明一个由n个元素的列表，每个元素的值都是val得来的
list(first,last)//声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素
list<int> list1(10,0);//创建长度为10，每个元素的值都为0

list的功能函数

l.begin();//首元素地址
l.end();//尾元素地址
l.push_back();//插入list末端
l.push_front();//插入list首端
l.empty();//list为空返回true，否则返回false
l.resize(n);//将list的长度改为n，超出的元素将被删除
l.clear();//清空list
l.assign(a.begin(),a.end());//将a的begin到end中的元素赋值给list
l.swap(l2);//等同于swap(l,l2); 交换两个链表
l.reverse();//逆置list
l.merge(l2);//将list和l2合并并且变成升序(默认升序)
l.merge(l2,greater<int>());//将list和l2合并并且变成降序
l.insert(l.begin(),l2,begin(),l2.end());//list头部插入从l2开始到结尾的元素
l.insert(l.begin(),n);//在list开始位置插入一个n
l.insert(l.begin(),x,n);//在list开始位置插入x个n
l.erase(l.begin());//将list第一个元素删除
l.erase(l.begin(),l.end());//将list从begin()到end()删除

//以下操作需要empty前置查看list是否为空

l.front();//获取list头部元素
l.back();//获取list最后一个元素
//当list为空时front()和back()不会报错

l.pop_back();//删除最后一个元素
l.pop_front();//删除第一个元素
//当list为空是调用pop_back()和pop_front()会使程序崩溃

• 1
• 27

#include< deque >双向队列库函数

1.deque介绍

deque是一个double-ended queue，它的具体实现不太清楚，但知道它具有以下两个特点：它支持[]操作符，也就是支持随即存取，并且和vector的效率相差无几，它支持在两端的操作：push_back,push_front,pop_back,pop_front等，并且在两端操作上与list的效率也差不多。

2.deque函数

deque的构造函数
创建deque对象，deque< int >d

deque();//创建一个空deque
deque(int nSize);//创建一个deque,元素个数为nSize
deque(int nSize,const T& t);//创建一个deque,元素个数为nSize,且值均为t
deque(const deque &);//复制构造函数

• 1
• 2
• 3
• 4

deque的功能函数

d.begin();//首元素地址
d.end();//尾元素地址
d.push_back();//插入deque末端
d.push_front();//插入deque首端
d.empty();//deque为空返回true，否则返回false
d.resize(n);//将deque的长度改为n，超出的元素将被删除
d.clear();//清空deque
d.assign(a.begin(),a.end());//将a的begin到end中的元素赋值给deque
d.swap(d2);//等同于swap(d,d2); 交换两个队列
d.reverse();//逆置deque
d.merge(d2);//将deque和d2合并并且变成升序(默认升序)
d.merge(d2,greater<int>());//将deque和d2合并并且变成降序
d.insert(d.begin(),d2,begin(),d2.end());//deque头部插入从d2开始到结尾的元素
d.insert(d.begin(),n);//在deque开始位置插入一个n
d.insert(d.begin(),x,n);//在deque开始位置插入x个n
d.erase(d.begin());//将deque第一个元素删除
d.erase(d.begin(),d.end());//将deque从begin()到end()删除

//以下操作需要empty前置查看deque是否为空

d.front();//获取deque头部元素
d.back();//获取deque最后一个元素
//当deque为空时front()和back()不会报错

d.pop_back();//删除最后一个元素
d.pop_front();//删除第一个元素
//当deque为空是调用pop_back()和pop_front()会使程序崩溃

#include< ctype.h>字符串判断库函数

1.ctype介绍

该函数库包含1.isalpha() 2.isalnum() 3.islower() 4.isupper四个函数

2.ctype函数

isalpha();//判断字符是否为字母,是返回1,否则返回0
isalnum();//判断字符是否为数字或者字母,也就是说判断一个字符是否属于a~z||A~Z||0~9
islower();//判断字符是否为小写字母,是否属于a~z
isupper();//判断字符是否为大写字母,是否属于A~Z

#include< stdlib.h>网络库函数

1.stdlib介绍

目前接触到有改写字符的大小写。

2.stdlib函数

tolower();//将字符转化为小写
toupper();//将字符转化为大写

#include< math.h>数学库函数

1.取整函数

ceil();//向上取整
floor();//向下取整
round();//四舍五入取整