C++ STL API

String字符串

	//**************string**************//
	#include<string>
	//赋值
	string str = "ABC";
	str.assign("ABCD");
	//增
	str.append("EF");
	str += "GH";
	//读
	char c = s[5];//越界崩溃
	c = s.at(5);//越界抛异常
	string s=str.substr(2,3);//取2位起始，长度为3的字符串
	//查
	int f = s.find("C");//正序
	int g = s.rfind("F");//逆序
	int size=s.size();//长度
	str.insert(3, "A");//插入	
	str.erase(2, 5);//删除	
	str.replace(2, 5, "B");//替换
	//大小写
	c = toupper(c);
	c = tolower(c);
	//**************string**************//

Vector动态数组

单端数组，双向迭代器，随机存取
内存动态扩充，复制到内存中足够大的位置后删掉原来的数据

    #include<vector>
    //**************vector**************//
	//构造
	vector<int> v1;
	vector<int> x(10, 0);//10个0
	vector<int> p(x);//copy
	vector<int> y(x.begin(), x.end());//copy
	vector<vector<int>> v(m, vector<int>(n, 0)); //m*n的二维数组，所有元素初始化为0
	//赋值
	vector<int> v2 = v1;
	v1.assign(x.begin(), x.end());
	v1.assign(10, 0);//10个0
	v1.swap(v2);//交换
	//遍历
	for (vector<int>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	//大小操作
	v1.size();//大小
	v1.empty();//true为空
	v1.resize(10);//重新指定容器长度为10（大于填充0，小于删除）
	v1.resize(10,100);//100默认填充值
	v1.capacity();//容量
	//读取
	v1[0];
	v1.at(0);
	v1.front();
	v1.back();
	//插入
	v1.insert(v1.begin(), 66);//传入迭代器
	v1.push_back(10);
	//删除
	v1.pop_back();//尾删
	v1.erase(v1.begin(), v1.begin() + 2);//区间删
	v1.clear();//清空
	//收缩空间
	vector<int>(v1).swap(v1);//vector<int>(v1)复制匿名对象
	//预留空间
	v1.reserve(10000);//一次扩充避免多次扩充内存
    //**************vector**************//

Deque动态数组

双端数组，双向迭代器，随机存取
没有容量，容量扩充时不连续，表维护内存

	#include<deque>
    //**************deque**************//
	deque<int> d;
	//增
	d.push_front(10);
	//删
	d.pop_front();
	//**************deque**************//

Stack栈/Queue队列

没有迭代器

	#include<stack>
	#include<queue>
    //**************stack**************//
	stack<int> s;
	//增
	s.push(10);
	//删
	s.pop();
	//栈顶
	s.top();
	//**************stack**************//
	//**************queue**************//
	queue<int> q;
	//增
	q.push(10);
	//删
	q.pop();
	//队头
	q.front();
	//**************queue*************//

List链表

双向循环链表，不支持随机存取

	#include<list>
    //**************list*************//
    bool my_sort(int p1, int p2) { return p1 > p2; }
	list<int> L;
	L.push_back(30);
	L.push_back(40);
	L.push_back(7000);
	L.push_front(100);
	L.reverse();//反转
	L.remove(100);//删除所有=100的值
	L.sort();//从小到大
	L.sort(my_sort);//修改排序为从大到小
	//**************list*************//

Set/Multiset集合

内部由红黑树实现，自动排序（二叉排序树，默认从小到大）
Set键值唯一，Mutiset键值可重复，不允许根据迭代器修改键值，只能增/删

	#include<set>//包含set和multiset
    //**************set/mutiset*************//
	set<int> st;
	st.insert(10);
	st.insert(20);
	st.insert(30);
	st.erase(200);//按值
	st.erase(st.begin());//按迭代器
	set<int>::iterator it=st.find(30);//按值，返回迭代器，失败返回end
	int c=st.count(30);//统计个数
	it = st.lower_bound(20);//返回>=20的迭代器
	it = st.upper_bound(20);//返回>20的迭代器

	pair<set<int>::iterator, set<int>::iterator> p;//对，第一个low，第二个up
	p = st.equal_range(20);
	*p.first;//>=20的迭代器
	*p.second;//>20的迭代器
	//pair构造
	pair<int, double> p(10, 20.0);
	pair<int, string> p = make_pair(10, "A");

class Person
{
public:
	int m_age;
	string m_name;
	Person(int age, string name)
	{
		this->m_age = age;
		this->m_name = name;
	}
};
class person_compare
{
public:
    //改变排序规则，从大到小<
	bool operator()(const Person& p1, const Person& p2) const {return p1.m_name < p2.m_name;}
};
	//set存放自定义类数据，先指定排序规则
    set<Person, person_compare> s;
	Person p1(10, "a");
	Person p2(60, "b");
	Person p3(30, "c");
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	for (set<Person, person_compare>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "Name " << it->m_name << "  Age " << it->m_age << endl;
	}
	//**************set/mutiset*************//

Map/Multimap

存放键值对，key和set类似
Map键值唯一，Multimap键值可重复

	#include<map>//包含map和multi
    map<int, int> m;
	//插入
	m.insert(pair<int, int>(1, 10));
	m.insert(make_pair(2, 20));//√
	m.insert(map<int, int>::value_type(3, 30));//不建议使用
	m[4] = 40;//不建议使用
	//删除
	m.clear();
	m.erase(4);//按key删除
	//查找
	auto pos = m.find(3);//返回迭代器
	int counter = m.count(3);//统计

Algorithm

	#include<algorithm>
	//遍历
	for_each(v.begin(), v.end(), [](int val) {cout << val << endl; });//Lambda表达式
	//回调函数
	void my_print(int val){cout << val<<" ";}
	for_each(v.begin(), v.end(),my_print);//无括号
	#include<functional>//适配器用
	//函数对象+适配器（增加参数）	
	class print:public binary_function<int,int,void>//继承binary_function 参数<参数1类型，参数2类型，返回类型>
	{
	public:
		void operator()(int val, int start) const{cout << val + start << endl;}//注意const
	};
	for_each(v.begin(), v.end(), bind2nd(print(),100));

	//统计"X"的个数
	int c=count(v.begin(), v.end(), "X");
	//统计满足条件 >30的个数
	int d = count_if(v.begin(), v.end(), [](int val)->bool {return val > 30; });
	//检索5，返回5的位置，失败返回v.end()，返回类型 迭代器
	auto pos = find(v.begin(), v.end(), 5);
	//检索满足条件的值，同上
	auto pos = find_if(v.begin(), v.end(), [](int val) {return val > 5; });

	//排序（从小到大）
	sort(v.begin(), v.end());
	//排序（从大到小）
	sort(v.begin(), v.end(), [](int v1, int v2) {return v1 > v2; });//Lambda表达式

	//合并，需要外部容器
	vector<int> target;
	//改变外部容器的容量
	target.resize(v1.size()+v2.size);
	//合并的两个容器必须有序
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());

	#include<ctime>
    //打乱排序
	srand((unsigned int)time(NULL));//随机种子
	random_shuffle(v.begin(), v.end());

	//逆序
	reverse(v.begin(), v.end());

	//v0分配大小
	v0.resize(v.size());
	//复制
	copy(v.begin(), v.end(), v0.begin());
	//替换	旧值，新值
	replace(v.begin(), v.end(), 10, 8000);
	//替换	满足条例，新值
	replace_if(v.begin(), v.end(), [](int val)->bool {return val > 50; }, 8000);
	//交换
	swap(v, v0);

	#include<numeric>
	//累加求和
	int a=accumulate(v.begin(), v.end(), 0);//初始值0
	v.resize(10);
	//全部填充
	fill(v.begin(), v.end(), 810);

	v2.resize(min(v.size(), v0.size()));//开辟空间
	//容器必须有序 返回迭代器最后一个的位置
	auto it_end=set_intersection(v.begin(), v.end(), v0.begin(), v0.end(), v2.begin());//交集
	v2.resize(max(v.size(), v0.size()));
	auto it_end = set_difference(v.begin(), v.end(), v0.begin(), v0.end(), v2.begin());//差集
	v2.resize(v.size() + v0.size());
	auto it_end = set_union(v.begin(), v.end(), v0.begin(), v0.end(), v2.begin());//并集