c++标准库STL学习汇总

核心组件

• 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。
• 算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte.
• 迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++,operator–等指针相关操作予以重载的class template. 所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。
  主要解决：有相似逻辑的一类代码的抽象

容器

容器是用来存放数据的，STL的容器将运用最广泛的一些数据结构实现出来
常见的数据结构有： 数组(array),链表(list),tree(树)，栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性

• 序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
• 关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。Set/multiset容器 Map/multimap容器

void test02()
{
	//声明容器
	vector<int> v;//声明一个容器，这个容器中存放int类型数据，对象名称V，

	//向容器中加入数据
	v.push_back(10);
	v.push_back(10);
	v.push_back(10);
	v.push_back(10);

	//遍历容器中的数据
	//利用迭代器

	vector<int>::iterator itBegin = v.begin();//inBegin指向的是v容器中的起始位置

	vector<int>::iterator itEnd = v.end();//itEnd指向v容器中的最后一个位置的下一个地址

	//第一种遍历方式
	//while (itBegin != itEnd)
	//{
	//	cout << *itBegin << endl;
	//	itBegin++;
	//}


	//第二种遍历方式
	//过去常用for(int i=0;i<10;i++)
	//for (vector<int>::iterator it=v.begin();it!=v.end();it++)
	//{
		//注意(*it)就是尖括号里面的内容
	//	cout << *it << endl;
	//}


	//第三种方式，利用算法
	for_each(v.begin(), v.end(), myPaint);

}

自定义数据类型使用容器及容器的嵌套

//存放自定义数据类型的指针
void test04()
{
	vector<Person *> v;
	Person p1("张三", 10);
	Person p2("张四", 20);
	Person p3("张五", 30);

	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);


	//遍历
	for (vector<Person *>::iterator it = v.begin(); it != v.end(); it++)
	{
		//注意(*it)就是尖括号里面的内容
		cout << "姓名" << (*it)->m_Name << "   年龄：" << (*it)->m_Age << endl;
	}
}


//容器嵌套容器
void test05()
{
	vector<vector<int>> v;
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;

	for (int i = 0; i < 5;i++)
	{
		v1.push_back(i);
		v2.push_back(i + 10);
		v3.push_back(i + 100);
	}

	//将小容器放入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);

	//遍历所有数据
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		//注意(*it)就是尖括号里面的内容,因此*it还是一个容器，还需要遍历
		for (vector<int > ::iterator it1 = (*it).begin(); it1 != (*it).end(); it1++)
		{
			cout << (*it1) << " ";
		}
		cout << endl;
	}
}

string容器

定义在头文件#include中

• char*是一个指针，string是一个类
• String封装了很多实用的成员方法
  查找find，拷贝copy，删除delete 替换replace，插入insert
• string不用考虑内存释放和越界，string管理char*所分配的内存。

vector容器

vertor容器和数组很像，但是两者的唯一差别在于空间运用上的灵活性，数组是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，可以，一切琐碎得由自己来，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必害怕空间不足而一开始就要求一个大块头的array了

vertor提供的迭代器operator是随机访问迭代器： 即：迭代器是尖括号里面内容的指针
Vector::iterator it1;
Vector::iterator it2;
it1的型别其实就是Int*,it2的型别其实就是Teacher*.

vector的数据结构

vector是单向开口的连续内存空间

• vector采取的是线性连续的空间，它以两个迭代器_Myfirst和_Mylast分别指向配置得来的连续空间中目前已被使用的范围，并以迭代器_Myend指向整块连续内存空间的尾端。
• 为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求大一些，以备将来可能的扩充，这边是容量的概念。换句话说，一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector容器就得另觅居所。

vector常用的API

vector<int> v
//1.压入数据
v.push_bach(1);
v.push_bach(2);

//2.获取容器的容量
cout << v.capacity() << endl;  // v.capacity()容器的容量

1.构造与赋值

void test02()
{
	//一下代码都是vector的构造，及初始化操作
	vector<int> v;

	//例子 使用第二个构造函数 我们可以...
	int arr[] = { 2,3,4,1,9 };
	vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));//从数据的头指针到数组的尾指针

	vector<int> v2(v1.begin(), v1.end());//从迭代器的头初始化尾部

	printVector(v2);//输出结果为：2 3 4 1 9

	vector<int> v3(10, 100);//表示那个几
	printVector(v3);//（输出结果为10 个100）


	//一下代码是vector的常用赋值操作
	//赋值使用
	vector<int>v4;
	v4.assign(v1.begin(), v1.end());//将【v1.begin(), v1.end()）的值复制给v4
	printVector(v4);//2 3 4 1 9


	v4.swap(v3);//两个容器中的值交换
	cout << "交换后的v4:" << endl;
	printVector(v4);					
	cout << "交换后的v3:" << endl;
	printVector(v3);




	if (v4.empty())//或者用size()为0也是空
	{
		cout << "v4是空" << endl;
	}
	else
	{
		cout << "v4不空" << endl;
	}

	//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
	v4.resize(20,8);//重新指定v4的大小，第二个参数是默认值，默认值为0，
	printVector(v4);//结果为：100  100  100  100  100  100  100  100  100  100  8  8  8  8  8  8  8  8  8  8（超出的部分填充8）

	v4.resize(5);
	printVector(v4);//100  100  100  100  100  （多余的部分全部裁剪）
}

2.数据的存取插入删除

/*
3.2.4.4 vector数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素

3.2.4.5 vector插入和删除操作
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素

*/

void test05()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(50);

	cout << "v的front：" << v.front() << endl;//获取头值：10
	cout << "v的back：" << v.back() << endl;//获取尾值：50



	//插入
	v.insert(v.begin()+1, 2,100);//第一个：迭代器，参数二：参入的个数，默认1，参数三：具体插入的内容
	printVector(v);//10  100  100  20  50

	//尾删除
	v.pop_back();
	printVector(v);

	//erase删除
	v.erase(v.begin());//删除指定位置
	printVector(v);

	v.erase(v.begin(),v.end()-1);//删除指定位置
	printVector(v);

	//删除所有数据
	v.clear();
	if (v.empty())
	{
		cout << "clear数据清空" << endl;
	}
}

空间保留

//reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
void test04()
{
	vector<int>v;
	v.reserve(10000);//预留出空间

	int *p = NULL;
	int num = 0;
	for (int i = 0; i < 10000; i++)
	{
		v.push_back(i);

		if (p != &v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;
	//开辟10000数据用了多少次空间
}

deque容器

deque是双向开口的连续线性空间

• 头尾两端分别做元素的插入和删除操作
• vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受

Deque容器和vector容器最大的差异

• 一在于deque允许使用常数项时间对头端进行元素的插入和删除操作
• 二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector那样，”旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间”这样的事情在deque身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能.
• 除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque

deque常用的API

/*
3.3.3.1 deque构造函数
deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将n个elem拷贝给本身。
deque(const deque &deq);//拷贝构造函数。

3.3.3.2 deque赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将deq与本身的元素互换

3.3.3.3 deque大小操作
deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。
*/

//公用打印数据
void printDeque(deque<int>&d)
{
	//iterator普通迭代器，reverse_iterator逆序迭代器，const_iterator只读迭代器
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}


void test01()
{
	//构造
	deque<int> d;
	d.push_back(10);
	d.push_back(40);
	d.push_back(30);
	d.push_back(20);

	printDeque(d);//10 40 30 20

	deque<int> d2(d.begin(), d.end());//拷贝构造   10 40 30 20
	d2.push_back(10000);

	//交换
	d.swap(d2);
	printDeque(d);
	if (d2.empty())
	{
		cout << "kong" << endl;
	}
	else
	{
		cout << "不为空，大小为：" << d2.size() << endl;
	}
}


/*
3.3.3.4 deque双端插入和删除操作
push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据

3.3.3.5 deque数据存取
at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据
3.3.3.6 deque插入操作
insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
3.3.3.7 deque删除操作
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。

*/


void test02()
{
	deque<int>d;
	d.push_back(10);
	d.push_back(20);
	d.push_back(30);

	d.push_front(100);
	d.push_front(200);
	d.push_front(300);

	printDeque(d);//300 200 100 10 20 30


	//删除头和尾
	d.pop_back();
	d.pop_front();
	printDeque(d);//200 100 10 20

	//查看头尾
	cout << "front=" << d.front() << endl;//200
	cout << "back=" << d.back() << endl;//20

	//插入insert
	deque<int>d2;
	d2.push_back(30);
	d2.push_back(50);
	d2.insert(d2.begin(),d.begin(),d.end());
	printDeque(d2);//200 100 10 20 30 50

}
//排序规则
bool myCompare(int v1, int v2)
{
	return v1 > v2;
}

//排序sort
void test03()
{
	deque<int>d;
	d.push_back(5);
	d.push_back(51);
	d.push_back(15);
	d.push_back(5);
	d.push_back(8);
	d.push_back(3);

	printDeque(d);

	//排序
	//从小到大排序
	sort(d.begin(), d.end());
	printDeque(d);


	//从大到小排序
	sort(d.begin(), d.end(), myCompare);
	printDeque(d);

}

stack容器

stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历行为。

• 有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.
  

stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历行为。

queue容器

Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素
也没有迭代器，不可以遍历
可以获取头尾的元素

/*

3.5.3.1 queue构造函数
queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：
queue(const queue &que);//拷贝构造函数
3.5.3.2 queue存取、插入和删除操作
push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素

3.5.3.3 queue赋值操作
queue& operator=(const queue &que);//重载等号操作符
3.5.3.4 queue大小操作
empty();//判断队列是否为空
size();//返回队列的大小
*/

void test01()
{
	queue<int>q;
	q.push(10);//往队尾添加元素
	q.push(20);
	q.push(30);
	q.push(40);

	while (!q.empty())//不为空
	{
		cout << "对头元素:" << q.front() << endl;
		cout << "对尾元素:" << q.back() << endl;

		//弹出对头元素
		q.pop();
	}

	cout << "q.size()=" << q.size() << endl;
}

cout:
对头元素:10
对尾元素:40
对头元素:20
对尾元素:40
对头元素:30
对尾元素:40
对头元素:40
对尾元素:40
q.size()=0

list容器

list的数据结构

• 链表是一种物理存储单元上非连续、非顺序的存储结构。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
• 相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。
• List和vector是两个最常被使用的容器。
• List容器是一个双向链表。

list的迭代器是一个特殊的迭代器，不能想vector迭代器一样保证其节点在同一块连续的内存空间上。
List迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取操作。所谓”list正确的递增，递减、取值、成员取用”是指，递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的数据值，成员取用时取的是节点的成员。
list是一个双向的链表，迭代器必须具有前移和后移的功能

频繁的插入删除可以考虑list容器
list和vector迭代器的区别
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至List元素的删除，也只有被删除的那个元素的迭代器失效，其他迭代器不受任何影响。

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
链表灵活，但是空间和时间额外耗费较大

list的API

1.构造与删除

//list常用API
/*
list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。
3.6.4.2 list数据元素插入和删除操作
push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。

*/
//打印数据
void printList(list<int>&L)
{
	for (list<int>::iterator it = L.begin(); it != L.end(); it++)//正向打印
	{
		cout << *it << " ";
	}
	cout << endl;
}


void test02()
{
	//构造
	list<int>L(5, 10);//5个10
	list<int>L2(L.begin(), L.end());
	printList(L);//10 10 10 10 10
	printList(L2);//10 10 10 10 10
	L2.push_back(100);

	//逆向打印
	cout << "逆向打印:";
	for (list<int>::reverse_iterator it = L2.rbegin(); it != L2.rend(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;//逆向打印:100 10 10 10 10 10


	//list迭代器不支持随机访问
	list<int>::iterator itBegin = L2.begin();
	//itBegin = itBegin + 1;//不支持



	//插入数据
	list<int>L3;
	L3.push_back(10);//从尾部插入数据
	L3.push_back(20);
	L3.push_back(30);
	L3.push_front(100);//从头部插入数据
	L3.push_front(200);
	L3.push_front(300);
	printList(L3);//300 200 100 10 20 30

	//删除两端数据
	L3.pop_back();//尾删
	L3.pop_front();//头删
	printList(L3);//200 100 10 20

	//插入
	L3.insert(L3.begin(), 1000);//头插入1000
	L3.push_back(10);//尾部插入10
	printList(L3);//1000 200 100 10 20 10

	//remove(elem);//删除容器中所有与elem值匹配的元素。
	L3.remove(10);//参数：直接放值
	printList(L3);//1000 200 100 20
}

2.获取list的信息

/*
3.6.4.3 list大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，
若容器变长，则以默认值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
若容器变长，则以elem值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。

3.6.4.4 list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。
3.6.4.5 list数据的存取
front();//返回第一个元素。
back();//返回最后一个元素。
*/

void test03()
{
	//插入数据
	list<int>L3;
	L3.push_back(10);
	L3.push_back(20);
	L3.push_back(30);
	L3.push_front(100);
	L3.push_front(200);
	L3.push_front(300);

	//输出大小
	cout << "大小：" << L3.size() << endl;
	if (L3.empty())
	{
		cout << "空" << endl;
	}
	else
	{
		cout << "L3不为空" << endl;
	}

	//与vector容器用法一致
	L3.resize(10);
	printList(L3);
	L3.resize(5);
	printList(L3);

	cout << "front" << L3.front() << endl;
	cout << "back" << L3.back() << endl;
}


/*
3.6.4.6 list反转排序
reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); //list排序
*/
bool myCompare(int v1,int v2)
{
	return v1 > v2;
}

void test04()
{
	list<int>L;
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_back(40);

	//翻转数据
	L.reverse();
	printList(L);

	//所有不支持随机范围的迭代器，不可以用系统提供的算法
	//如果不支持用系统提供算法，那么这个类内部会提供
	//sort(L.begin(), L.end());
	L.sort();
	printList(L);


	//从大到小排序
	L.sort(myCompare);
	printList(L);
}

set容器

Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值（如果有重复的会自动被覆盖），multiset可以允许有重复的键值。

我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素的排序规则。
如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator.
set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，
在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。

/*
set<T> st;//set默认构造函数：
mulitset<T> mst; //multiset默认构造函数:
set(const set &st);//拷贝构造函数
3.7.2.2 set赋值操作
set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器
3.7.2.3 set大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空

3.7.2.4 set插入和删除操作
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。
*/

//打印方法
void printSet(set<int>&s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s1;
	//关联式容器，根据key值，自动排序，默认从小到大
	s1.insert(5);
	s1.insert(1);
	s1.insert(9);
	s1.insert(3);
	s1.insert(7);
	//打印
	printSet(s1);//1 3 5 7 9

	if (s1.empty())
	{
		cout << "set为空" << endl;
	}
	else {
		cout << "set不为空" << endl;
		cout <<"size值="<< s1.size() << endl;//5
	}

	//删除的时候提供了两种方式：迭代器和传值的方式
	s1.erase(s1.begin());//3579
	printSet(s1);
	s1.erase(3);//579
	printSet(s1);
}

查找操作

/*

3.7.2.5 set查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//查找键key的元素个数
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
*/
void test02()
{
	set<int>s1;
	//关联式容器，根据key值，自动排序，默认从小到大
	s1.insert(5);
	s1.insert(1);
	s1.insert(9);
	s1.insert(3);
	s1.insert(7);
	//对于set没有value,key就是value
	

	//查找
	set<int>::iterator pos=s1.find(3);//查找返回的是对应位置的迭代器
	if (pos != s1.end())
	{
		cout << "找到了:值为" <<*pos<< endl;//找到了:值为3
	}
	else
	{
		cout << "未找到" << endl;
	}

	//count(key);//查找键key的元素个数  set而言结果0或者1
	int num=s1.count(1);
	cout << "1的个数为：" << num << endl;

	//lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。（大于等于）
	set<int>::iterator it=s1.lower_bound(2);//应该是3的迭代器，第一个大于等于2的迭代器
	if (it != s1.end())
	{
		cout << "找到了lower_bound(2):值为" << *it << endl;
	}
	else
	{
		cout << "未找到" << endl;//10就是未找到
	}

	//upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。（和上面相比，有大于，没有等于）
	set<int>::iterator it2 = s1.upper_bound(3);//第一个大于3的迭代器（注意：set容器中的值是按照循序		 排列的）
	if (it2 != s1.end())
	{
		cout << "找到了upper_bound(3):值为" << *it2 << endl;
	}
	else
	{
		cout << "未找到" << endl;//10就是未找到
	}


	//equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
	//上下限就是lower_bound和upper_bound
	pair<set<int>::iterator,set<int>::iterator> ret=s1.equal_range(3);
	//获取第一个值
	if (ret.first != s1.end())
	{
		cout << "找到equal_range中 lower_bound 的值 ：" << *(ret.first) << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

	//获取第二个值
	if (ret.second != s1.end())
	{
		cout << "找到equal_range中 upper_bound 的值 ：" << *(ret.second) << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

找到了:值为3
1的个数为：1
找到了lower_bound(2):值为3
找到了upper_bound(3):值为5
找到equal_range中 lower_bound 的值 ：3
找到equal_range中 upper_bound 的值 ：5

set中指定插入的排序规则：重载（）符号，书写仿函数，指定规则

//指定set的排序规则，从大到小
//仿函数
class myCompare
{
public:
	//重载（）;
	bool operator()(int v1,int v2)
	{
		return v1 > v2;
	}
};

//set容器排序
void test04()
{
	set<int>s1;
	//关联式容器，根据key值，自动排序，默认从小到大
	s1.insert(5);
	s1.insert(1);
	s1.insert(9);
	s1.insert(3);
	s1.insert(7);

	printSet(s1);//默认从小到大

	//从大到小排序
	//在插入之前就指定排序规则
	set<int,myCompare>s2;//插入前指定规律，不能写函数，仿函数自定义的数据类型
	s2.insert(5);
	s2.insert(1);
	s2.insert(9);
	s2.insert(3);
	s2.insert(7);

	for (set<int, myCompare>::iterator it = s2.begin(); it != s2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

pair容器

• 对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。
• 类模板：template <class T1, class T2> struct pair.

//第一种方法创建一个对组
pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl; //访问pair第一个值
cout << pair1.second << endl;//访问pair第二个值
//第二种
pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
//pair=赋值
pair<string, int> pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;

map容器

• Map的特性是，所有元素都会根据元素的键值自动排序。
• Map所有的元素都是pair,同时拥有实值和键值，pair的第一元素被视为键值，第二元素被视为实值，map不允许两个元素有相同的键值。
• 我们可以通过map的迭代器改变map的键值吗？答案是不行，因为map的键值关系到map元素的排列规则，任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的，（但是不可以改变键值）。
• Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
  Multimap和map的操作类似，唯一区别multimap键值可重复。

map的API

1.数值的插入操作：推荐使用（make_pair(x,y)）

/*
3.8.2.1 map构造函数
map<T1, T2> mapTT;//map默认构造函数:
map(const map &mp);//拷贝构造函数


3.8.2.2 map赋值操作
map& operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器

3.8.2.3 map大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空
3.8.2.4 map插入数据元素操作
map.insert(...); //往容器插入元素，返回pair<iterator,bool>
map<int, string> mapStu;
// 第一种 通过pair的方式插入对象
mapStu.insert(pair<int, string>(3, "小张"));
// 第二种 通过pair的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过value_type的方式插入对象
mapStu.insert(map<int, string>::value_type(1, "小李"));
// 第四种 通过数组的方式插入值
mapStu[3] = "小刘";
mapStu[5] = "小王";
*/

void test01()
{
	map<int, int> m;
	//插入值
	//4种方式
	//第一种
	m.insert(pair<int,int>(1,10));

	//第二种（推荐）
	m.insert(make_pair(2, 20));

	//第三种类（不推荐）
	m.insert(map<int,int>::value_type(3,30));
	//第四种，如果保证key存在，那么可以通过[]访问
	m[4] = 40;



	//遍历
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << it->first << "   value=" << (*it).second << endl;
	}


	//第四种方式不保险
	//m[5];
	//for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	//{
	//	cout << "key=" << it->first << "   value=" << (*it).second << endl;
	//}

	//如果保证key存在，那么可以通过[]访问
	cout << m[4] << endl;

	if (m.empty())
	{
		cout << "m空" << endl;
	}
	else
	{
		cout << "非空,size=" << m.size() << endl;
	}
}

2.Map的删除操作

/*
3.8.2.5 map删除操作
clear();//删除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中key为keyElem的对组。
3.8.2.6 map查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end();
count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
*/
void test02()
{
	map<int, int> m;
	//插入4个数
	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.erase(1);//擦除键值为1，对应的map元素
	//遍历
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << it->first << "   value=" << (*it).second << endl;
	}

	map<int, int>::iterator pos = m.find(2);//找到键值为2，对应的map元素的迭代器
	if (pos != m.end())
	{
		cout<<"找到了，key="<< pos->first << "   value=" << pos->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

	int num = m.count(3);//map的count  要么0 要么1
	cout << "num=" <<num<<endl;


	// lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。

	map<int, int>::iterator ret = m.lower_bound(3);
	if (ret != m.end())
	{
		cout << "lower_bound 中key" << ret->first << " value: " << ret->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

	//upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
	ret = m.upper_bound(3);
	if (ret != m.end())
	{
		cout << "upper_bound 中key" << ret->first << " value: " << ret->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

	//equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

	pair<map<int, int>::iterator, map<int, int>::iterator> ret2 = m.equal_range(3);

	if (ret2.first != m.end())
	{
		cout << "找到了equal_range 中的lower_bound 的key " << ret2.first->first << " value: " << ret2.first->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

	if (ret2.second != m.end())
	{
		cout << "找到了equal_range 中的upper_bound 的key " << ret2.second->first << " value: " << ret2.second->second << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}

}

3.改变map的排列方式（通过仿函数）

//仿函数
class myCompare
{
public:
	bool operator()(const int &v1,  const int &v2)
	{
		return v1 > v2;
	}
};
//指定排序规则（默认从小到大）
void test03()
{
	map<int, int,myCompare> m;
	//插入4个数
	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;//这个尽量别用，亲测出错。

	//遍历
	for (map<int, int, myCompare>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << it->first << "   value=" << (*it).second << endl;
	}
}

使用场景

• vector的使用场景：==尽可能多的查找，而不需要进行删除操作的地方，==比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。

• deque的使用场景：比如排队购票系统，对排队者的存储可以采用deque，支持头端的快速移除，尾端的快速添加。如果采用vector，则头端移除时，会移动大量的数据，速度慢。

• vector与deque的比较：
  一：vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的开始位置 却是不固定的。
  二：如果有大量释放操作的话，vector花的时间更少，这跟二者的内部实现有关。
  三：deque支持头部的快速插入与快速移除，这是deque的优点。

• list的使用场景：比如公交车乘客的存储，随时可能有乘客下车，支持频繁的不确实位置元素的移除插入。

• set的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。

• map的使用场景：==比如按ID号存储十万个用户，想要快速要通过ID查找对应的用户。==二叉树的查找效率，这时就体现出来了。如果是vector容器，最坏的情况下可能要遍历完整个容器才能找到该用户。

迭代器

将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们通过迭代器撮合在一起。

算法

函数对象

重载函数调用符号（）的类，其对象常称为函数对象，他是行为类似函数的对象，也叫仿函数。
1.形式上与函数的调用一样，类内重载()

• .函数对象(仿函数)是一个类，不是一个函数。
• 函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。

class MyPrint
{
public:
	void operator()(int num)
	{
		cout << "num:" << num << endl;
		count++;//可以保存状态
	}

	int count = 0;
};
//函数调用
void MyPrint2(int num)
{
	cout << "num:" << num << endl;
}

void test01()
{
	//想函数一样调用
	//MyPrint是一个类，而不是函数
	MyPrint myPrint;
	myPrint(11);//仿函数调用（仿在了形式上）结果：num:11
	MyPrint2(11);//函数调用			        结果：num:11，因此形式上与函数的调用一样

	MyPrint()(1000);//类似匿名对象的调用
}

2.函数对象超出了普通函数的概念，内部可以保存状态

//函数对象超出了普通函数的概念，内部可以保存状态
void test02()
{
	MyPrint myPrint;
	myPrint(111);
	myPrint(111);
	myPrint(111);
	myPrint(111);
	myPrint(111);
	myPrint(111);

	cout << "myPrint使用次数：" << myPrint.count << endl;
}

3.函数对象可以作为参数

//函数对象作为参数
void doPrint(MyPrint print, int num)
{
	print(num);
}
void test03()
{
	doPrint(MyPrint(), 20);
}

谓词

？（工作中遇到好好学）
谓词是特殊的仿函数，是返回值为bool类型的仿函数

• 普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)=。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词

class GreaterThen20
{
public:
	bool operator()(int val)
	{
		return val > 20;
	}
};

//一元谓词(返回值为bool)
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);

	//查找第一个大于20的数字
	//第三个参数  函数对象，匿名对象
	vector<int>::iterator pos=find_if(v.begin(), v.end(), GreaterThen20());
	if (pos != v.end())
	{
		cout << "找到大于20的数：" << *pos << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}


}

class myCompare
{
public:
	bool operator()(int v1, int v2)
	{
		return v1 > v2;
	}
};

//二元谓词
void test02()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);

	sort(v.begin(), v.end(), myCompare());

	//匿名函数，lambda表达式，[](){}
	for_each(v.begin(), v.end(), [](int val) {cout << val << " "; });
}

函数对象的适配器

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
#include<vector>
#include <algorithm>
#include<functional>


class MyPrint:public binary_function<int,int,void>//继承：类型，类型，返回值
{
public:
	void operator()(int v,int start) const
	{
		cout << "val=" << v << " start=" << start << " v+start=" << v + start << endl;
	}

};

//适配器使用步骤
//第一步绑定数据bind2nd
//第二步继承类 binary_function<参数类型1，参数类型2，返回值类型>
//加上const修饰operator()
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//假设用户输入
	int num;
	cout << "请输入起始值：" << endl;
	cin >> num;

	//打印
	//for_each(v.begin(), v.end(), bind2nd(MyPrint(),num));
	for_each(v.begin(), v.end(), bind1st(MyPrint(), num));//与上方绑定反着的
}

//大于5的数
class GreaterThenFive:public unary_function<int,bool>//适配器，要写上继承
{
public:
	bool operator()(int v) const
	{
		return v > 5;
	}
};


//取反适配器
//1.一元取反适配器  not1
//继承  unary_function<参数类型1，返回值类型>
//加上const修饰operator()
void test02()
{
	//一元取反
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	//查找一个大于5的数字
	//vector<int>::iterator pos=find_if(v.begin(), v.end(), GreaterThenFive());

	//需求改为：找一个小于5的数
	//vector<int>::iterator pos = find_if(v.begin(), v.end(), not1(GreaterThenFive()));

	//上式的高端操作：//看不懂就算了
	vector<int>::iterator pos = find_if(v.begin(), v.end(), not1(bind2nd(greater<int>(),5)));

	if (pos != v.end())
	{
		cout << "找到大于5的数:" << *pos << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
	
}

void MyPrint03(int v,int start)
{
	cout << v + start << " ";
}

//函数指针适配器
void test03()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	//将函数指针，适配为函数对象
	//ptr_fun

	for_each(v.begin(), v.end(), bind2nd(ptr_fun(MyPrint03),100));

}



//成员函数适配器
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	//如果是成员函数
	void showPerson()
	{
		cout << "成员函数中：姓名： " << m_Name << " 年龄：" << m_Age << endl;
	}

	//多活100岁
	void plusAge()
	{
		m_Age = m_Age + 100;
	}
	string m_Name;
	int m_Age;
};

void MyPrintPerson(Person & p)
{
	cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}

void test04()
{
	vector<Person>v;

	Person p1("aaa", 10);
	Person p2("bbb", 15);
	Person p3("ccc", 18);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	//for_each(v.begin(), v.end(), MyPrintPerson);//全局函数


	//成员函数的适配器
	//mem_fun_ref
	for_each(v.begin(), v.end(),mem_fun_ref(&Person::showPerson));
	for_each(v.begin(), v.end(), mem_fun_ref(&Person::plusAge));
	cout << "----------第二次输出-----------" << endl;
	for_each(v.begin(), v.end(), mem_fun_ref(&Person::showPerson));

}

int main()
{
	test01();
	//test02();
	//test03();
	//test04();
	system("pause");
	return EXIT_SUCCESS;
}

遍历

/*
	遍历算法 遍历容器元素
	@param beg 开始迭代器
	@param end 结束迭代器
	@param _callback  函数回调或者函数对象
	@return 函数对象
*/
//1.for_each(iterator beg, iterator end, _callback);


//仿函数
struct myPrint01//也可以写成class
{
	void operator()(int v)
	{
		cout << v << endl;
	}
};
//回调函数
void MyPrint(int v)
{
	cout << v << endl;
}
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	//打印
	for_each(v.begin(), v.end(), MyPrint);

	//打印
	for_each(v.begin(), v.end(), myPrint01());
}

搬运

//仿函数
class TransForm
{
public:
	int operator()(int val)
	{
		return val;
	}
};

void test04()
{
	vector<int>v;//源容器
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>vTarget;//目标容器
	//一定要记住： transform 不会给目标容器分配内存，所以需要我们提前分配好内存
	vTarget.resize(v.size());

	//transform搬运操作，将一个容器中的值搬运到另一个容器中
	transform(v.begin(), v.end(), vTarget.begin(), TransForm());

	for_each(vTarget.begin(), vTarget.end(), [](int val) {cout << val << endl; });


}



//2.transform的第二种用法:将两个容器数据相加搬运到目标容器
//仿函数
class TransForm2
{
public:
	int operator()(int val,int val2)
	{
		return val+val2;
	}
};

void test05()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(100 + i);
		v2.push_back(200 + i);
	}
	vector<int>vTarget; //目标容器
	//搬运前，一定要分配内存
	vTarget.resize(v1.size());
	//将两个容器数据相加搬运到目标容器
	transform(v1.begin(), v1.end(), v2.begin(), vTarget.begin(), TransForm2());

	//打印
	for_each(vTarget.begin(), vTarget.end(), [](int val) {cout << val << endl; });


}

查找

/*
	find算法 查找元素
	@param beg 容器开始迭代器
	@param end 容器结束迭代器
	@param value 查找的元素
	@return 返回查找元素的位置
*/
//利用find查找自定义数据类型
void test02()
{
	vector<Person>v;

	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator pos=find(v.begin(), v.end(), p2);//返回找到p2的迭代器

	if (pos != v.end())
	{
		cout << "找到数据，姓名：" << pos->m_Name<<"     年龄："<<pos->m_Age << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

排序

/*
	merge算法 容器元素合并，并存储到另一容器中,这两个容器 必须也是有序的
	@param beg1 容器1开始迭代器
	@param end1 容器1结束迭代器
	@param beg2 容器2开始迭代器
	@param end2 容器2结束迭代器
	@param dest  目标容器开始迭代器
*/
void test01()
{
	vector<int>v1;
	vector<int>v2;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 1);
	}

	vector<int>vTarget;
	//一定要开辟空间
	vTarget.resize(v1.size() + v2.size());
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

	//输出
	for_each(vTarget.begin(), vTarget.end(), [](int val) {cout << val << " "; });
}


/*
sort算法 容器元素排序
注意:两个容器必须是有序的
@param beg 容器1开始迭代器
@param end 容器1结束迭代器
@param _callback 回调函数或者谓词(返回bool类型的函数对象)
*/
void test02()
{
	vector<int>v1;

	v1.push_back(10);
	v1.push_back(40);
	v1.push_back(20);
	v1.push_back(90);
	v1.push_back(50);

	//默认从小到大排序
	sort(v1.begin(), v1.end());
	for_each(v1.begin(), v1.end(), [](int val) {cout << val << " "; });
	cout << endl;

	//从大到小排序
	sort(v1.begin(), v1.end(),greater<int>());
	for_each(v1.begin(), v1.end(), [](int val) {cout << val << " "; });
	cout << endl;
}

//random_shuffle(iterator beg, iterator end) 洗牌
void test03()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	random_shuffle(v.begin(), v.end());//使用他的时候需要一个随机种子，不然会导致，每次洗牌的值一样
	for_each(v.begin(), v.end(), [](int val) {cout << val << " "; });

}

//reverse(iterator beg, iterator end)//翻转算法
void test04()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	v.push_back(0);

	reverse(v.begin(), v.end());
	for_each(v.begin(), v.end(), [](int val) {cout << val << " "; });
}