前言
当我们需要实现某一个功能的时候，常常需要自己编写一些代码才能实现。
有些时候对于常用模块，我们可以采用他人编写好的代码，加快编程效率。
比如进制转换，与其自己写个Stack模拟，不如调用itoa()函数一步实现......
本文纯本人手打，且原创首发在CSDN
我将根据我的学习进度，不定期更新，若有不足，欢迎指出，谢谢！
基本输入输出
//输入
cin>>a;
scanf("%d",&a);
scanf_s("%d",&a); //vs2019
fscanf(in,"%d",&a);
getchar();//获取一个字符
gets(a);//获取一行字符串
getline(cin,a);//获取一行String
//输出
cout<<b;
printf("%d",b);
puts(b);
putchar(b);
fprintf(out,"%d",b);//输出到文件函数库—algorithm
固定数组 int a[] = { 1, 3, 5, 7, 9, 11, 13 }; int b[11] = { 1, 2, 3, 4 };
用于下列函数测试
//二分查找：
lower_bound(a, a + 7, 7);//返回第一个大于等于7的地址
upper_bound(a, a + 7, 7);//返回第一个小于等于7的地址
binary_search(a, a + 7, 8);//若a到a+7有8，返回true 否则返回false
//反转函数：
reverse(a, a + 7);//反转a到a+7的元素
//填充替换函数：
fill(a, a + 7, 4);//填充函数，把a到a+7全部填充为4
copy_backward(a, a + 7, b + 7);//把a数组复制到b，首地址，尾地址，复制后数组的尾地址
replace(b, b + 4, 3, 5);//把b到b+4中所有3替换成5
//全排列函数：
next_permutation(b, b + 4);//b数组的下一个排列
prev_permutation(b, b + 4);//b数组的上一个排列
//排序去重函数：
stable_sort(a, a + 7, cmp);//按照cmp规则稳定排序a到a+7
unique(a, a + 7);//去重，返回去重后数组的尾地址
printf("%d\n", *max_element(a, a + 6));//返回序列a到a+6的最大元素地址函数库—cstring
固定数组 用于验证函数。char a[200] = "hello world"; char b[] = "hello acm";
//初始化：
memset(a, 0, sizeof(a));//初始化 只能0 -1
//取长度：
int len = strlen(a);//返回a的长度 到'\0'就算结束
//复制：
strcpy(a, b);//把b赋值给a 覆盖掉
memcpy(a, b, 8);//把b赋值给a 覆盖掉8个长度
//连接：
strcat(a, b);//把b连接到a后面
strncat(a, b, 3);//把b的最多3个字符连接到a后面
//比较大小：
strcmp(a, b);//a>b 返回正数,a<b返回负数，一样返回0
strncmp(a, b, 7);//比较a和b的前7位字符 返回规则同上
//查找：
int xiabiao = strchr(a, 'l') - a;
//返回a中找字符l出现的首地址 没有返回NULL
int xiabiao2 = (char*)memchr(a, 'l', 7) - a;
//返回a的前7个字符中找字符l出现的首地址 没有返回NULL
strspn(a, b);//比较a和b 从第一位开始，返回从头数相等的长度
strstr(a, b)-a;//返回b在a首次出现的地址 函数库—cmath
int a = 1, b = -2, c = 3, d = 4;
double e = 1.1, f = 8.36, g = 2.2, h =3.4;
e = sqrt(f);//平方根函数 返回根号f
e = cbrt(f);//立方根函数 返回三次根号f
e = pow(f, g); //幂函数 返回f的g次方
e = floor(f);//向下取整 返回f的向下取整的整数
e = ceil(f);//向上取整 返回f的向上取整的整数
a = abs(b);//int类型 返回b的绝对值
e = fabs(f);//double类型 返回f的绝对值
e = fmod(f, g);//double类型 返回f除以g的余数
e = modf(2.36, &f);//把2.36的整数部分赋值给f(有&) 把小数返回给e
e = frexp(1024.0, &a);
//把1024.8转化为0.5*2^11;0.5返回 11赋值给a，返回的小数范围[0.5,1)
e = ldexp(1.0, 3);//返回1.0 *(2^3)
e = exp(3);//返回e的3次方 exp(1)就是e的值 acos(-1)就是pai的值
f = log(666.0);//返回log e (666.0) 以e为底数
f = log10(666.0);//返回log 10 (666.0) 以10为底数
f = log10(8) / log10(2);// 计算log 2 (8) 运用换底公式
f = acos(-1);//返回以弧度表示的 -1 的反余弦
f = asin(-1);//返回以弧度表示的 -1 的反正弦
f = atan(-1);//返回以弧度表示的 -1 的反正切
f = atan2(1, 2); //返回以弧度表示的 1/2 的反正切。1和2的值的符号决定了正确的象限。
f = cos(1.1);//返回弧度为1.1的余弦
f = sin(1.1);//返回弧度为1.1的正弦
f = tan(1.1);//返回弧度为1.1的正切
f = cosh(1.1);//返回弧度为1.1的双曲余弦
f = sinh(1.1);//返回弧度为1.1的双曲正弦
f = tanh(1.1);//返回弧度为1.1的双曲正切
f = hypot(3, 4);//返回以3和4为直角边的三角形斜边长函数库—string
※vector的各种操作都适用于string
//赋值初始化：
string str = “abcd”;
//比大小：
string a = "abc";
string b = "abd";
cout << a.compare(b) << endl; // -1
//a比b大就返回1，相等返回0，a比b小返回-1
//重载1：compare()参数可以是char[]类型
//重载2：str1.compare(2,3,str2,0,3) //str1的第二位开始(下标从0开始算),长度3位，和str2第0位开始长度3位比较
//重载3：str1.compare(2,3,str2)
//str1的第二位开始(下标从0开始算),长度3位，和str2整体比较
//重载2中不允许第一二个参数为空
//连接：
str1 += str2;
//长度：
str1.length();
str1.size();
//String转char[] ：
string str = "hello world";
const char* a = str.c_str();
//这个a只能输出，不能修改
//char[]转String：
char a[20] = "hello world!";
string str = a; //可以直接暴力转换
//截取：
str.substr(2, 3);
//截取字符串str第二位开始的连续三位，下标从0开始，如果超出长度则到字符串结尾结束
//判断为空：
Str.empty(); 是空返回真
//删除：
s.erase(0,1); // 从0位置开始 删除1个字符STL通用库函数
二分查找函数：equal_range
用法：
equal_range是C++ STL中的一种二分查找的算法，试图在已排序的[first,last)中寻找value，它返回一对迭代器i和j，其中i是在不破坏次序的前提下，value可插入的第一个位置（亦即lower_bound），j则是在不破坏次序的前提下，value可插入的最后一个位置（亦即upper_bound），因此，[i,j)内的每个元素都等同于value，而且[i,j)是[first,last)之中符合此一性质的最大子区间。
pair<set<int>::iterator, set<int>::iterator > p = equal_range(s.begin(), s.end(), 4);
//查找4这个元素求i和j的距离：
distance(p.first, p.second)，//若STL中不存在则返回0；否则存在求i和j迭代器指向的值：
*p.first << " " << *p.second
Find_if函数：
用法：从begin开始 ，到end为止，返回第一个让 func这个函数返回true的iterator。
求最大最小值：
max_element(v.begin(),v.end());//返回v容器中的最大值的迭代器
min_element(v.begin(),v.end());//返回v容器中的最小值的迭代器STL之set
//定义：
set<int>s;
//插入数据：
s.insert(6);
//删除数据：
s.erase(1);//删除集合中为1的所有元素
s.clear();//全部删除
//遍历输出：
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
cout << *it << endl;
}
//查找：
s.count(1);//有返回true， 没有返回false
cout << *s.find(1)<< endl;
//find函数返回一个迭代器，取值需要加*，找不到返回end()；
//元素个数：
s.size();
//判断为空:
s.empty();
//迭代器相关：
s.find();//返回一个迭代器，取值需要加*，找不到返回end()；
s.equal_range() // 返回集合中与给定值相等的上下限的两个迭代器
s.lower_bound()//返回指向⼤于（或等于）某值的第⼀个元素的迭代器
s.upper_bound() // 返回⼤于某个值元素的迭代器
//反向迭代遍历：
set<int>::reverse_iterator iter = s1.rbegin();
for(iter;iter!=s1.rend();iter++)
{
cout<<*iter<<" ";
}
//可重复的set集合：
multiset<int>ss; 功能同set其中count(i)返回元素的个数STL之map
//创建：
map<string, int>m;
//插入数据：
m.insert(map<string, int>::value_type("he", 2));
// insert函数返回一个pair，其first指向插入元素的迭代器；
// 若原本插入的键不存在，second返回true，若原本存在，second返回false
m["ha"] = 3;
//遍历：
for (map<string, int>::iterator it = m.begin(); it != m.end(); it++) {
cout << it->first << " " << it->second << endl;
}
//查找：
map<string, int>::iterator it = m.find("he"); //找不到返回m.end();
//删除：
m.erase("he");//删除键的值，返回被删除的个数(普通map为1)
//元素个数：
m.size();
//判断为空：
m.empty();
//清空：
m.clear();
//map自定义排序：
struct cmp {
bool operator()(int const& a, int const& b)const {
return a>b;
}
};
multimap<int, int, cmp>m;
m.insert(pair<int, int>(1, 2));
m.insert(pair<int, int>(2, 3));
m.insert(pair<int, int>(3, 4));
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
cout << it->first << " " << it->second << endl;
}STL之vector
//定义：
vector<int>v;
//插入元素：
v.push_back(i);
v.push_back(it,i);//在迭代器it前插入i
v.push_back(it,n,i);//在迭代器it前插入n个元素i
//尾部删除：
v.pop_back();
//首位元素：
v.front();
//尾部元素：
v.back();
//判断为空：
v．empty();
//元素个数：
v．size();
//遍历:
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << endl;
}
//翻转：
reverse(v.begin(), v.end());
//排序：
sort(v.begin(), v.end());
sort(v.begin(), v.end(), cmp);
//交换容器：
v.swap(v2);
//设置空间大小：
v.resize(n);//设置长度为n
STL之queue
//普通队列：
queue<int>q;//创建
q.size();//返回元素个数
q.empty();//返回是否为空
q.push(3); //插入元素3，入队
q.pop(); //删除最上方元素，出队
q.front(); //返回队首元素
q.back(); //返回队尾元素
//优先队列：
//1.默认优先级：定义：
priority_queue<int>q;//默认大的数优先
//2. 传入一个比较函数，使用functional.h函数对象作为比较函数
priority_queue<int,vector<int>, greater<int> > q;//自定义小的数优先
//3. 传入比较结构体，自定义优先级：
struct cmp
{
bool operator()(int x,int y) {
return x > y;//当前为小的数优先
}
};
priority_queue<int,vector<int> ,cmp>q;
//4. 自定义数据结构，自定义优先级//最快的一种
struct ss {
int x, y;
ss(int xx, int yy) {
x = xx;
y = yy;
}
friend bool operator < (const ss& a, const ss& b) {
if (b.x != a.x) return b.x < a.x;
return b.y < a.y;
}
};
priority_queue<ss>q;STL之stack
//定义：
stack<int>s;
//常用函数：
empty(); //堆栈为空则返回真
pop(); //移除栈顶元素
push(); //在栈顶增加元素
size(); //返回栈中元素数目
top(); //返回栈顶元素
//假设内置结构体有构造函数，则以下两句等价：
s.push(ss(1, 2));
s.emplace(1, 2);//免构造
s.swap(ss)可以互换两个栈的元素STL之pair
//头文件：
#include<utility>
//定义：
pair<int, string>p;
//定义且初始化：
pair<int, string>p(2,"hello");
pair<int, string>p;
p = make_pair(2, "hello");
//返回键：
p.first
//返回值：
p.second
//比较：
p = make_pair(2, "hello");
pp = make_pair(2, "hello");
cout << (p == pp) << endl;//相等 返回true
p = make_pair(1, "hello");
pp = make_pair(2, "hello");
cout << (p < pp) << endl;//p比pp小 返回true
//遵循字典序顺序，先比first，再比second输入挂
const int MAXBUF = 10000;
char buf[MAXBUF], * ps = buf, * pe = buf + 1;
inline void rnext()
{
if (++ps == pe)
pe = (ps = buf) + fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool in(T& ans)
{
ans = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do
{
ans = (ans << 1) + (ans << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
ans *= f;
return true;
}
