c++各个头文件所包含常用函数

目录:

1.<cstdlib>

2.<cctype>

3.<cstring>

4.<cmath>

5.<string>

6.<algorithm>

7.<utility>

8.<vector>向量容器（动态数组）

9.<set>集合容器（平衡二叉检索树/中序遍历）

10.<map>映照容器（平衡二叉检索树/中序遍历）

11.<deque>双端队列容器（线性表顺序存储）

12.<list>双端链表容器（双向循环链）

13.<bitset>位集合容器（bit位元素序列）

14.<stack>堆栈容器（后进先出的线性表）

15.<queue>队列容器（先进先出的线性表）

16.<bits/stdc++.h>万能头文件

--------------------------------------------------------------------------------------------------------------------------------------------

1.<cstdlib>

atof(a); // 字符串a转换为double类型
atoi(a); // 字符串a转换为int类型
atol(a); // 字符串a转换为long int类型
atoll(a); // 字符串a转换为long long int类型
rand(); // 生成一个随机数
abort(); // 终止程序
abs(a); // 返回整型a的绝对值
s=div(a,b); // 返回由结构体div_t变量s接收，s.quot是a，b的商，s.rem是余数

2.<cctype>

isalnum(c); // 判断字符c是否为字母数字
isalpha(c); // 判断字符c是否为字母
isblank(c); // 判断字符c是否为空白字符（’\t’，空格）
iscntrl(c); // 判断字符c是否为控制字符（NULL，’\t’，’ \f’，’ \v’，’ \n’，’ \r’）
isdigit(c); // 判断字符c是否为十进制数字
isgraph(c); // 判断字符c是否能用图形表示（标点字符，字母数字）
islower(c); // 判断字符c是否为小写字母
isprint(c); // 判断字符c是否为可打印字符（标点字符，字母数字，空格）
ispunct(c); // 判断字符c是否为标点字符
isspace(c); // 判断字符c是否为空白格（’\t’，空格，’\f’，’\v’，’\n’，’\r’）
isupper(c); // 判断字符c是否为大写字母
isxdigit(c); // 判断字符c是否为十六进制数字（’0’—‘9’，’a’—‘f’，’A’—‘F’）

3.<cstring>

strcpy(a,b); // 把字符串b复制给字符串a
strncpy(a,b,n); // 把字符串b的前n个字符复制给字符串a
strcat(a,b); // 把字符串b连接在字符串a之后
strncat(a,b,n); // 把字符串b前n个字符连接在字符串a之后
strcmp(a,b); // 返回值0，两字符串相等；返回值>0，b<a；返回值<0，a>b
strncmp(a,b,n); // 比较两个字符串的第n个字符
strspn(a,b); // 返回字符串b中字符在字符串a中出现的次数
strstr(a,b); // 返回字符串b在字符串a中第一次出现的地址
memset(a,c,n); // 将地址a开始的n个位置赋为c
strlen(a); // 返回字符串a的长度
strrev(a); // 将字符串a倒置
strstr(a,b); // 返回字符串b在字符串a中出现的地址
strchr(a,b); // 返回字符串b在字符串a中出现的地址
sscanf(a,”%...,%...,…”,…,...,…); // 将字符串a以空格拆分成各类型并赋给新的变量
sscanf示例：
{
char s[]=”lihua is 18 years old”; char a; int i;
	sscanf (s,"%s %*s %d",a,&i);
 	printf ("%s -> %d\n",a,i);
}
Output:   lihua -> 18   //%*s(d,f,lf,c)吞掉一个字符串（相应）类型的输入值
sprintf(a,”%...%...%...”,…,…,…,…); // 将各变量赋给字符串并存于a中
sprintf示例：
{
	char a[50]; int n, x=5, y=3;
 	n=sprintf (a, "%d plus %d is %d", x,y,x+y);
	printf(“[%s],%d”,a,n);
}
Output:   [5 plus 3 is 8],13   //n为新字符串a的长度

4.<cmath>

sqrt(a); // 返回a的平方根
cbrt(a); // 返回a的立方根
abs(a); // 返回整型a的绝对值
fabs(a); // 返回浮点型a的绝对值
pow(a,b); // 返回a的b次方
round(a); // 返回a四舍五入之后的值
ceil(a); // 返回比a大的最小整数
fioor(a); // 返回比a小的最大整数
trunc(a); // 返回a的整数部分
fmax(a,b); // 返回a，b中的最大的那个
fmin(a,b); // 返回a，b中的最小的那个
cos(a); // 计算a的余弦
sin(a); // 计算a的正弦
tan(a); // 计算a的正切
acos(a); // 计算a的反余弦
asin(a); // 计算a的反正弦
atan(a); // 计算a的反正切
log(a); // 计算a的自然对数
log10(a); // 计算a的常数对数
hypot(a,b); // 计算以a，b为直角边的三角形的斜边

5.<string>

getline(cin,a); // 输入一行字符串
getline(cin,a,c); // 输入到字符c为止的字符串
a+b; // 将字符串b连接到字符串a之后
a.begin(); // 返回字符串a的起始地址
a.end(); // 返回字符串a的结束地址
a.size(); // 返回字符串a的长度
a.length(); // 返回字符串a的长度
a.clear; // 清空字符串a
a.empty(); // 字符串a为空返回true；否则返回false
a.compare(b); // 比较字符串a，b；a大，返回1；b大，返回-1；相等，返回0
reverse(a.begin(),a.end()); // 将字符串a从首到尾反向排列
printf(a.c_str()); // 用c_str()方法将字符串a用printf输出
a.erase(p); // 清除地址p的一个字符
a.erase(p,n); // 清除从地址p开始的n个字符
a.erase(p,q); // 清除从地址p开始到地址q结束的字符
a.insert(n,s); // 在字符串a第n个位置插入字符串s
a.insert(n,s,m); // 在字符串a第n个位置插入字符串s的前m个字符
a.insert(n,m,c); // 在字符串a第n个位置插入m个字符c
a.replace(m,n,s); // 将字符串a第m个位置开始往后的n个字符替换为字符串s
a.replace(m,n,s,x,y); // 替换为字符串s中第x个位置开始往后的y个字符
a.replace(m,n,s,n); // 替换为字符串s的前n个字符
a.replace(m,n,x,c); // 替换为x个字符c
a.find(c); // 返回a中第一次出现字符c的位置
a.find(s); // 返回a中第一次出现字符串s的位置
a.rfind(c); // 返回a中最后一次出现字符c的位置
a.rfind(s); // 返回a中最后一次出现字符串s的位置
stoi(a); // 字符串a转换为int类型
stol(a); // 字符串a转换为long int类型
stoul(a); // 字符串a转换为unsigned long int类型
stoll(a); // 字符串a转换为long long int类型
stoul(a); // 字符串a转换为unsigned long long int类型
stof(a); // 字符串a转换为float类型
stod(a); // 字符串a转换为double类型
stold(a); // 字符串a转换为long double类型

6.<algorithm>

max(a,b); // 返回a，b中较大者
min(a,b); // 返回a，b中较小者
sort(a); // 将a从小到大排序

7.<utility>

swap(a,b); // 交换对象a，b的值

8.<vector>向量容器（动态数组）

创建vector对象
（1）不指定元素个数 e:   vector<int> v;
（2）指定元素个数 e:   vector<double> v(10); // 共10个元素，初始值都为0.0
（3）指定元素初始值和个数 e:   vector<double> v(10,8.6); // 初始值都为8.6
v.push_back(n); // 把n放在容器尾部
v.insert(p,n); // 把n插入到位置p
v.begin(); // 起始位置
v.end(); // 结束位置
v.erase(p,q); // 清除位置p到位置q间的元素
v.clear(); // 清空
reverse(v.begin(),v.end()); // 将容器v从首到尾反向排列
sort(v.begin(),v.end()); // 升序排列
v.size(); // 返回向量v的大小
v.empty(); // 判断向量是否为空

9.<set>集合容器（平衡二叉检索树/中序遍历）

创建set对象
e:   set<int> s;
s.erase(n); // 删除键值为n的元素
s.clear(); // 清空
s.find(n); // 查找键值为n的元素
s.insert(n); // 插入n，如果n重复出现，不做操作
创建multiset（多重集合容器）对象
multiset<string> ms;
ms.insert(n); // 插入n，n可以重复
n=ms.erase(s); // 删除值为字符串s的所有元素，返回删除个数
ms.find(n); // 返回键值为n的第一个元素的位置

10.<map>映照容器（平衡二叉检索树/中序遍历）

创建map对象
e:   map<char,int> m;
m[c]=n; // 将n插入到键值为c的映照数据中
m.erase(n); // 删除键值为n的元素
m.find(n); // 搜索键值n

11.<deque>双端队列容器（线性表顺序存储）

创建deque对象
（1）没有任何元素 e:   deque<int> d;
（2）指定元素个数 e:   deque<double> d(10); // 共10个元素
（3）指定元素初始值和个数 e:   deque<double> d(10,8.6); // 初始值都为8.6
d.push_back(n); // 从尾部插入元素n并扩张队列
d.pust_front(n); // 从头部插入元素n并覆盖原元素
d.insert(p,c); // 在位置p插入c并覆盖原元素
d.pop_front(); // 从头部删除元素
d.pop_back(); // 从尾部删除元素
d.erase(p); // 删除位置p的元素
d.clear(); // 清空

12.<list>双端链表容器（双向循环链）

创建list对象
（1）创建空链表 e:   list<int> l;
（2）指定元素个数 e:   list<int> l(10); // 共10个元素
l.push_back(n); // 从尾部插入元素n链表自动扩张
l.pust_front(n); // 从头部插入元素n链表自动扩张
l.insert(p,c); // 在位置p插入c链表自动扩张
l.remove(n); // 删除值为n的全部元素	
l.pop_front(); // 删除链表首元素
l.pop_back(); // 删除链表尾元素
l.erase(p); // 删除位置p的元素
l.clear(); // 清空
l.find(n); // 搜索值为n的元素
l.sort(); // 升序排列
l.unique(); // 剔除连续重复元素，保留一个

13.<bitset>位集合容器（bit位元素序列）

创建bitset对象
	必须指定容器大小，一经定义不能修改
e:    bieset<100000> b; // 100000个bit（位），此时所有元素为都为0
b.any(); // 判断b中是否存在值为1的二进制位
b.none(); // 判断b中不存在值为1的二进制位
b.count(); // 返回b中值为1的二进制位的个数
b.size(); // 返回b中二进制位的个数
b.test(p); // 判断位置p处的二进制位是否为1
b.set(); // 把b的所有二进制位都置为1
b.set(p); // 把位置p处的二进制位置为1
b.set(p,n); // 把位置p处的二进制位置为n，n为0或1
b.reset(); // 把b的所有二进制位都置为0
b.reset(p); // 把位置p处的二进制位置为0
b.flip(); // 把b的所有二进制位逐位取反
b.flip(p); // 把位置p处的二进制位取反

14.<stack>堆栈容器（后进先出的线性表）

创建stack对象
e:   stack<int> s;
s.push(n); // 元素n入栈
s.pop(); // 栈顶元素出栈
s.top(); // 访问栈顶元素
s.empty(); // 判断栈是否为空
s.size(); // 返回栈中元素个数

15.<queue>队列容器（先进先出的线性表）

创建queue对象
e:   queue<int> q;
q.push(n); // 将元素n入队
q.pop(); // 队首元素出队
q.front(); // 读取队首元素
q.back(); // 读取队尾元素
q.empty(); // 判断队列是否为空
q.size(); // 返回队列元素个数
创建priority_queue元素（优先队列,最大元素位于队首）
e:   priority_queue<int> pq;
pq.push(n); // 元素n入队
pq.pop(); // 队首元素出队
pq.top(); // 访问队首元素
pq.empty(); // 判断队列否为空
pq.size(); // 返回队列元素个数
重载”<”操作符来定义优先级（元素类型为结构体）
struct Info{
	int s;
	bool operator < (const Info &a) const
	{
		return a.s<s; // 按s由小到大排序，由大到小用”>”即可
}
} // priority_queue<Info> pq; // 元素类型为Info结构体
重载”()”操作符来定义优先级（元素类型可以不为结构体）
struct Info{
	bool operator()(const int &a,cons tint &b)
{
	return a>b; // 由小到大排序用”>”，由大到小用”<”
}
} // priority_queue<int,vector<int>,Info> pq; // 元素类型为int，内部结构是vector