站在巨人的肩膀上，C++最常用的200个函数

1. //输入
2. cin>>a;
3. scanf("%d",&a);
4. scanf_s("%d",&a); //vs2019
5. fscanf(in,"%d",&a);
6. getchar();//获取一个字符
7. gets(a);//获取一行字符串
8. getline(cin,a);//获取一行String
9. 
10. //输出
11. cout<<b;
12. printf("%d",b);
13. puts(b);
14. putchar(b);
15. fprintf(out,"%d",b);//输出到文件

1. //二分查找：
2. lower_bound(a, a + 7, 7);//返回第一个大于等于7的地址
3.  upper_bound(a, a + 7, 7);//返回第一个小于等于7的地址
4.  binary_search(a, a + 7, 8);//若a到a+7有8，返回true 否则返回false
5. 
6. //反转函数：
7.  reverse(a, a + 7);//反转a到a+7的元素
8. 
9. //填充替换函数：
10.   fill(a, a + 7, 4);//填充函数，把a到a+7全部填充为4
11.   copy_backward(a, a + 7, b + 7);//把a数组复制到b，首地址，尾地址，复制后数组的尾地址
12.   replace(b, b + 4, 3, 5);//把b到b+4中所有3替换成5
13. 
14. //全排列函数：
15.   next_permutation(b, b + 4);//b数组的下一个排列
16.   prev_permutation(b, b + 4);//b数组的上一个排列
17. 
18. //排序去重函数：
19.   stable_sort(a, a + 7, cmp);//按照cmp规则稳定排序a到a+7
20.   unique(a, a + 7);//去重，返回去重后数组的尾地址
21.   printf("%d\n", *max_element(a, a + 6));//返回序列a到a+6的最大元素地址

1. //初始化：
2. memset(a, 0, sizeof(a));//初始化 只能0 -1
3. 
4. 
5. //取长度：
6. int len = strlen(a);//返回a的长度  到'\0'就算结束
7. 
8. 
9. //复制：
10. strcpy(a, b);//把b赋值给a 覆盖掉
11.   memcpy(a, b, 8);//把b赋值给a 覆盖掉8个长度
12. 
13. 
14. //连接：
15. strcat(a, b);//把b连接到a后面
16.   strncat(a, b, 3);//把b的最多3个字符连接到a后面
17. 
18. 
19. //比较大小：
20.   strcmp(a, b);//a>b 返回正数,a<b返回负数，一样返回0
21.   strncmp(a, b, 7);//比较a和b的前7位字符 返回规则同上
22. 
23. 
24. //查找：
25.   int xiabiao = strchr(a, 'l') - a;
26. //返回a中找字符l出现的首地址 没有返回NULL
27.   int xiabiao2 = (char*)memchr(a, 'l', 7) - a;
28. //返回a的前7个字符中找字符l出现的首地址 没有返回NULL
29.   strspn(a, b);//比较a和b 从第一位开始，返回从头数相等的长度
30.   strstr(a, b)-a;//返回b在a首次出现的地址

1.         e = sqrt(f);//平方根函数 返回根号f
2.  e = cbrt(f);//立方根函数 返回三次根号f
3.  e = pow(f, g); //幂函数 返回f的g次方
4.  e = floor(f);//向下取整 返回f的向下取整的整数
5.  e = ceil(f);//向上取整 返回f的向上取整的整数
6.  a = abs(b);//int类型 返回b的绝对值
7.  e = fabs(f);//double类型 返回f的绝对值
8.  e = fmod(f, g);//double类型 返回f除以g的余数
9.  e = modf(2.36, &f);//把2.36的整数部分赋值给f(有&) 把小数返回给e
10.   e = frexp(1024.0, &a);
11. //把1024.8转化为0.5*2^11;0.5返回 11赋值给a，返回的小数范围[0.5,1)
12.   e = ldexp(1.0, 3);//返回1.0 *(2^3) 
13.   e = exp(3);//返回e的3次方     exp(1)就是e的值  acos(-1)就是pai的值
14.   f = log(666.0);//返回log e (666.0)   以e为底数
15.   f = log10(666.0);//返回log 10 (666.0)   以10为底数
16.   f = log10(8) / log10(2);// 计算log 2 (8) 运用换底公式
17.   f = acos(-1);//返回以弧度表示的 -1 的反余弦
18.   f = asin(-1);//返回以弧度表示的 -1 的反正弦
19.   f = atan(-1);//返回以弧度表示的 -1 的反正切
20.   f = atan2(1, 2); //返回以弧度表示的 1/2 的反正切。1和2的值的符号决定了正确的象限。
21.   f = cos(1.1);//返回弧度为1.1的余弦
22.   f = sin(1.1);//返回弧度为1.1的正弦
23.   f = tan(1.1);//返回弧度为1.1的正切
24.   f = cosh(1.1);//返回弧度为1.1的双曲余弦
25.   f = sinh(1.1);//返回弧度为1.1的双曲正弦
26.   f = tanh(1.1);//返回弧度为1.1的双曲正切
27.   f = hypot(3, 4);//返回以3和4为直角边的三角形斜边长

1. //赋值初始化：
2.     string str = “abcd”;
3. 
4. 
5. //比大小：
6.     string a = "abc";
7.     string b = "abd";
8.     cout << a.compare(b) << endl; // -1
9. //a比b大就返回1，相等返回0，a比b小返回-1
10. //重载1：compare()参数可以是char[]类型 
11. //重载2：str1.compare(2,3,str2,0,3) //str1的第二位开始(下标从0开始算),长度3位，和str2第0位开始长度3位比较
12. //重载3：str1.compare(2,3,str2)
13. //str1的第二位开始(下标从0开始算),长度3位，和str2整体比较
14. //重载2中不允许第一二个参数为空
15. 
16. 
17. 
18. //连接：
19.     str1 += str2;
20. 
21. 
22. //长度：
23.     str1.length();
24.     str1.size();
25. 
26. 
27. //String转char[] ：
28.     string str = "hello world"; 
29. const char* a = str.c_str();
30. //这个a只能输出，不能修改
31. 
32. //char[]转String：
33. char a[20] = "hello world!";
34.     string str = a; //可以直接暴力转换
35. 
36. //截取：
37.     str.substr(2, 3);
38. //截取字符串str第二位开始的连续三位，下标从0开始，如果超出长度则到字符串结尾结束
39. 
40. 
41. //判断为空：
42.     Str.empty(); 是空返回真
43. 
44. 
45. //删除：
46.     s.erase(0,1); // 从0位置开始 删除1个字符

1. pair<set<int>::iterator, set<int>::iterator > p = equal_range(s.begin(), s.end(), 4);
2. //查找4这个元素

distance(p.first, p.second)，//若STL中不存在则返回0；否则存在

*p.first  << " " << *p.second

1. max_element(v.begin(),v.end());//返回v容器中的最大值的迭代器
2. 
3. min_element(v.begin(),v.end());//返回v容器中的最小值的迭代器

1. //定义： 
2.     set<int>s;
3. 
4. 
5. //插入数据： 
6.     s.insert(6);
7. 
8. 
9. //删除数据：
10.     s.erase(1);//删除集合中为1的所有元素
11.     s.clear();//全部删除
12. 
13. 
14. //遍历输出：
15. for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
16.      cout << *it << endl;
17.     }
18. 
19. 
20. //查找：
21.     s.count(1);//有返回true， 没有返回false
22.     cout << *s.find(1)<< endl;
23. //find函数返回一个迭代器，取值需要加*，找不到返回end()；
24. 
25. 
26. //元素个数：
27.      s.size(); 
28. 
29. 
30. //判断为空: 
31.     s.empty();
32. 
33. 
34. //迭代器相关：
35.     s.find();//返回一个迭代器，取值需要加*，找不到返回end()；
36.     s.equal_range() // 返回集合中与给定值相等的上下限的两个迭代器
37.     s.lower_bound()//返回指向⼤于（或等于）某值的第⼀个元素的迭代器
38.     s.upper_bound() // 返回⼤于某个值元素的迭代器
39. 
40. 
41. //反向迭代遍历：
42.     set<int>::reverse_iterator iter = s1.rbegin(); 
43. for(iter;iter!=s1.rend();iter++)
44.     {
45.         cout<<*iter<<" "; 
46.     }
47. 
48. 
49. //可重复的set集合：
50.     multiset<int>ss; 功能同set其中count(i)返回元素的个数

1. //创建： 
2.     map<string, int>m;
3. 
4. //插入数据：
5.     m.insert(map<string, int>::value_type("he", 2));
6. // insert函数返回一个pair，其first指向插入元素的迭代器；
7. // 若原本插入的键不存在，second返回true，若原本存在，second返回false
8.     m["ha"] = 3;
9. 
10. 
11. //遍历：
12. for (map<string, int>::iterator it = m.begin(); it != m.end(); it++) {
13.         cout << it->first << "  " << it->second << endl;
14.     }
15. 
16. //查找：
17.     map<string, int>::iterator it = m.find("he"); //找不到返回m.end();
18. 
19. //删除：
20.     m.erase("he");//删除键的值，返回被删除的个数(普通map为1)
21. 
22. //元素个数：
23.     m.size();
24. 
25. //判断为空：
26.     m.empty();
27. 
28. //清空：
29.     m.clear();
30. 
31. 
32. //map自定义排序：
33. struct cmp {
34. bool operator()(int const& a, int const& b)const {
35. return a>b;
36.         }
37.     };
38.     multimap<int, int, cmp>m;
39.   m.insert(pair<int, int>(1, 2));
40.   m.insert(pair<int, int>(2, 3));
41.   m.insert(pair<int, int>(3, 4));
42. 
43.   for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
44.     cout << it->first << " " << it->second << endl;
45.   }

1. //定义： 
2.     vector<int>v;
3. 
4. 
5. //插入元素：
6.     v.push_back(i); 
7.     v.push_back(it,i);//在迭代器it前插入i
8.     v.push_back(it,n,i);//在迭代器it前插入n个元素i
9. 
10. //尾部删除： 
11.     v.pop_back();
12. 
13. //首位元素：
14.     v.front();  
15. 
16. //尾部元素：
17.     v.back();
18. 
19. //判断为空：
20.     v．empty();
21. 
22. //元素个数： 
23.     v．size();
24. 
25. //遍历:
26. for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
27.         cout << *it << endl;
28.     }
29. 
30. //翻转：
31. reverse(v.begin(), v.end());
32. 
33. //排序：
34. sort(v.begin(), v.end());
35. sort(v.begin(), v.end(), cmp);
36. 
37. //交换容器：
38.     v.swap(v2);
39. 
40. //设置空间大小：
41.     v.resize(n);//设置长度为n

1. //普通队列：
2.         queue<int>q;//创建
3.  q.size();//返回元素个数
4.  q.empty();//返回是否为空
5.  q.push(3);  //插入元素3，入队
6.  q.pop();    //删除最上方元素，出队
7.  q.front();   //返回队首元素
8.  q.back();   //返回队尾元素
9. 
10. //优先队列：
11. 
12. //1.默认优先级：定义：
13.     priority_queue<int>q;//默认大的数优先
14. 
15. 
16. //2. 传入一个比较函数，使用functional.h函数对象作为比较函数
17.     priority_queue<int,vector<int>, greater<int> > q;//自定义小的数优先
18. 
19. 
20. //3. 传入比较结构体，自定义优先级：
21. struct cmp
22.     {
23.       bool operator()(int x,int y) {
24.     return x > y;//当前为小的数优先
25.       }
26.     };
27.     priority_queue<int,vector<int> ,cmp>q;
28. 
29. 
30. //4. 自定义数据结构，自定义优先级//最快的一种
31. 
32. struct ss {
33.       int x, y;
34.       ss(int xx, int yy) {
35.         x = xx;
36.         y = yy;
37.       }
38.       friend bool operator < (const ss& a, const ss& b) {
39.     if (b.x != a.x) return b.x < a.x;
40.         return b.y < a.y;
41.       }
42.     };
43.     priority_queue<ss>q;

1. //定义：
2.     stack<int>s;
3. 
4. //常用函数：
5. 
6. empty(); //堆栈为空则返回真
7. pop(); //移除栈顶元素
8. push(); //在栈顶增加元素
9. size(); //返回栈中元素数目
10. top(); //返回栈顶元素
11. 
12. 
13. //假设内置结构体有构造函数，则以下两句等价：
14.     s.push(ss(1, 2));
15.     s.emplace(1, 2);//免构造
16. 
17. 
18.     s.swap(ss)可以互换两个栈的元素

1. //头文件：
2. #include<utility>
3. 
4. //定义：
5.     pair<int, string>p;
6. 
7. //定义且初始化：
8.     pair<int, string>p(2,"hello");
9.     pair<int, string>p;
10.     p = make_pair(2, "hello");
11. 
12. //返回键：
13.     p.first
14. 
15. //返回值：
16.     p.second
17. 
18. //比较：
19.     p = make_pair(2, "hello");
20.   pp = make_pair(2, "hello");
21.   cout << (p == pp) << endl;//相等 返回true
22. 
23.     p = make_pair(1, "hello");
24.   pp = make_pair(2, "hello");
25.   cout << (p < pp) << endl;//p比pp小 返回true
26. 
27. //遵循字典序顺序，先比first，再比second

1. const int MAXBUF = 10000;
2. char buf[MAXBUF], * ps = buf, * pe = buf + 1;
3. inline void rnext()
4. {
5.  if (++ps == pe)
6.    pe = (ps = buf) + fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
7. }
8. 
9. template <class T>
10. inline bool in(T& ans)
11. {
12.   ans = 0;
13.   T f = 1;
14.   if (ps == pe) return false;
15.   do {
16.     rnext();
17.     if ('-' == *ps) f = -1;
18.   } while (!isdigit(*ps) && ps != pe);
19.   if (ps == pe) return false;
20.   do
21.   {
22.     ans = (ans << 1) + (ans << 3) + *ps - 48;
23.     rnext();
24.   } while (isdigit(*ps) && ps != pe);
25.   ans *= f;
26.   return true;
27. }