[系统运维]STL容器

STL

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。

1. 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
2. 算法：各种常用的算法，如sort、find、copy、for_each等
3. 迭代器：扮演了容器与算法之间的胶合剂。
4. 仿函数：行为类似函数，可作为算法的某种策略。
5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
6. 空间配置器：负责空间的配置与管理。

STL容器

近容器

int arr[ ]
string

	string s("abcdefg");//有参构造
	string s1(s);  //拷贝构造
	for (int i = 0; i < 10; i++) //尾插
	{
		s.push_back('a' + i);
	}
	
	s.pop_back();//尾删

	for (int i = 0; i < s.size(); i++)//遍历  修改
	{
		if (s[i] == 'b')
		{
			s[i] = 'y';
		}
		cout << s[i] << " ";
	}
	cout << endl;
	
	cout<<typeid(s.c_str()).name()<<endl;//c_str获取char*类型的指针  const char*
	

s.begin()返回迭代器，这个迭代器指向容器中第一个数据
s.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
通过迭代器.

//通过迭代器进行遍历
	string::iterator it = s.begin();
	for (; it != s.end(); it++)
	{
		if (*it == 'a')
		{
			it = s.insert(it, 'm');//增
			cout << *it << " "; //遍历
			it++;

			it = s.erase(it);//删
		}
		cout << *it << " ";
	}
	cout << endl;
	

注意：重新获取迭代器。

string 的其他函数：

	s.back();//获取尾部元素
	s.front();//获取头部元素
	s.empty();//判空
	int sit = s.find("def");
	cout << sit << endl;     //查找，找到返回下标，没找到返回-1

	s.clear();//清空
	char err[10] = { "abcdefg" };
	char* p = err;
	s.copy(p, 4);//从对象拷贝到指针
	cout << "================" << endl;
	cout << s << endl;
	cout << err << endl;


	s.resize();  //设置大小，分配容器的内存大小
	s.reserve();  //扩容，设置容器容量大小，但并没有真正分配内存
	s.swap(s1);//交换两个容器的数据

string 的构造，使用迭代器区间：

	string s2(s1.begin(), s1.end());//通过迭代器区间构造
	cout << s2 << endl;

顺序容器

vector 底层一维数组 按照1.5倍扩容；

	vector<int>v;
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);  //尾插
	}
	v.pop_back();//尾删
	v.swap(v1);//交换两个容器的数据
	v.size();//当前元素个数
	v.max_size();//当前内存空间最大可存放多少的值
	v.clear();
	v.empty();
	v.resize(10);
	v.reserve(10);

	for (int i = 0; i < v1.size(); i++)//通过下标遍历
	{
		cout << v1[i]<< " ";
	}
	cout << endl;
	

vector通过迭代器增删改查

//修改，先删除再插入
//vector 通过迭代器进行增删改查
	vector<int>::iterator it = v1.begin();
	
	for (; it != v1.end(); it++)
	{
		if (*it == 5)
		{
			it = v1.insert(it, 999);//插入
			it++;
			*it = 999;
			it = v1.erase(it);//删除
		}
		cout << *it <<" " ;
	}
	cout << endl;
	show_con(v1);

template<typename CON>
void show_con(CON& con)  //打印模板
{
	typename CON::iterator it = con.begin();
	for (; it != con.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

	copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, ""));//泛型算法
	
	//利用vector实现二维数组
	vector<vector<int>>;    
	//三维数组
	vector < vector<vector<int>>>;

使用链表迭代器区间初始化vector

vector<int>v1(L.begin(), L.end());//利用list构造vector对象

list 链表；

	list<int>L;
	for (int i = 0; i < 10; i++)
	{
		L.push_back(i);
	}
	show_con(L);
	
	vector<int>v1(L.begin(), L.end());//利用list构造vector对象
	show_con(v1);
	L.push_front(3);//头插
	L.pop_front();//头删

	L.resize(20);//新增加
	L.reverse();//逆序

deque 双端队列 二维数组；

双端队列如何扩容？
前后两边都可以增加；有两个指针分别指向头和尾，插入位置不定。

容器适配器

stack ——依赖于deque

	stack<int> s;
	for (int i = 0; i < 10; i++)
	{
		s.push(i);
	}
	s.pop();//删除
	s.top();//获取顶部元素
	s.empty();
	s.size();
	//s.swap();//交换

queue ——依赖于deque

	queue<int> q;
	for (int i = 0; i < 10; i++)
	{
		q.push(i);
	}
	q.pop();
	q.front();
	q.size();
	q.empty();
	//q.swap();

	//priority_queue<int>   优先级队列

关联容器

set 集合 数据有序 不允许重复 底层红黑树；

	set<int> s;
	
	s.insert(56);//增加
	s.insert(78);
	s.insert(24);
	s.insert(28);
	s.insert(97);
	s.insert(97);
	s.erase(97);//删除

	show_con(s);
	set<int>::iterator it = s.find(99);//查找
	if (it != s.end())
	{
		cout << *it << endl;
	}
	else
	{
		cout << "dont find" << endl;
	}
	s.clear();
	cout << s.count(78) << endl;//count计数 78出现的次数 ，返回结果 只有0或1，因为set不允许重复数据
	s.empty();
	s.size();
	//s.swap();

set应用例子：

小红有一些不同味道的糖果，由于蛀牙，她只能吃一般的糖果，
怎样能使她吃到的糖果种类最多？

2 3 3 4 3 4 2 3 2

vector<int> v
n/2    type
return min(set<int>(v.begin(),v.end()).size,v.size()/2);

multiset 多重集合 数据有序 允许重复 红黑树；

	multiset<int> ms;
	ms.insert(56);//增加
	ms.insert(78);
	ms.insert(24);
	ms.insert(28);
	ms.insert(97);
	ms.insert(97);
	ms.erase(97);//删除

	show_con(ms);
	multiset<int>::iterator it1 = ms.find(97);
	if (it1 != ms.end())
	{
		for (int i = 0; i < ms.count(97); i++)
		{
			cout << *it1 << endl;
			it1++;
		}
		//cout<<*(it1++)<<endl;

	}
	else
	{
		cout << "dont find" << endl;
	}

map 映射表 数据按key有序 不允许重复 底层红黑树；

	map<int, string> mm;
	mm.insert(make_pair(1, "aaaaa"));
	mm.insert(make_pair(3, "cccc"));
	mm.insert(make_pair(5, "eeeeee"));
	mm.insert(make_pair(2, "bbb"));
	mm.insert(pair<int, string>(4, "ddd"));

	map<int, string>::iterator it= mm.begin();
	for (;it!=mm.end(); it++)
	{
		cout << it->first << "--->";
		cout << it->second << endl;
	}
	map<int, string>::iterator it1 = mm.find(5);
	for (; it1 != mm.end(); it++)
	{
		cout << it1->first << "--->";
		cout << it1->second << endl;
	}

	mm.empty();
	mm.clear();
	mm.erase(5);
	mm.count(5);
	mm.size();

multimap 多重映射表 数据按key有序 允许重复 红黑树；

	multimap<int, string>mmm(mm.begin(), mm.end());
	mmm.insert(make_pair(1, "aaaaa"));
	mmm.insert(make_pair(3, "cccc"));
	mmm.insert(make_pair(5, "eeeeee"));
	mmm.insert(make_pair(2, "bbb"));
	map<int, string>::iterator it2 = mmm.begin();
	for (; it2 != mmm.end(); it2++)
	{
		cout << it2->first << "--->";
		cout << it2->second << endl;
	}

	
}