耗时一周，一万字总结——C++提升编程二：：STL，肯定不点个收藏？？？

种类	功能	支持运算
输入迭代器	对数据只读访问	只读，支持++，==，--
输出迭代器	对数据只写访问	只写，支持++
前向迭代器	读写操做，并能向前推动迭代器	读写，支持++，==，！=
双向迭代器	读写操做，并能向前和向后操做	读写，支持++，--
随机访问迭代器	读写操做，能够以跳跃式的方式访问任意数据，功能最强的迭代器	读写，支持++，--，[n]，-n，<，<=，>,>=

经常使用的迭代器种类为双向迭代器和随机访问迭代器

1.5容器算法迭代器初始

STL中最经常使用的容器为vector，能够理解为数组

1.5.1vector存放内存数据类型

容器：vector

算法：for_each

迭代器：vector<int>::intertor

#include<iostream>
using namespace std;

#include<vector>
#include<algorithm>

void show(int a)
{
	cout << a << endl;
}

void Test()
{
	//使用vector容器对象，而且经过模板参数指定容器中存放的数据的类型
	vector<int> a;
	//向容器中放数据
	a.push_back(10);
	a.push_back(20);
	a.push_back(30);
	a.push_back(40);
	a.push_back(50);

	//每个容器中都有本身的迭代器
	//a.begin()返回迭代器，这个迭代器指向容器中的第一个数据
	//a.end()返回迭代器，这个迭代器指向容器中的最后一个元素的下一个位置
	//vector<int>::iterator 拿到vector<int>这种容器的迭代类型
	vector<int>::iterator P_begin = a.begin();
	vector<int>::iterator P_end = a.end();

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

	//第二种遍历方式
	for (vector<int>::iterator i = P_begin; i != P_end; i++)
	{
		cout << *i;
	}

	//第三种遍历方式
	//使用STL的遍历算法，头文件：algorithm
	for_each(P_begin, P_end, show);
}

int main()
{
	Test();
	system("pause");
	return 0;
}

1.5.2 Vector存放自定义数据类型

将数据类型变为自定义的，好比类和其余的本身定义出来的东西

#include<iostream>
using namespace std;

#include<vector>
#include<algorithm>

class Person
{
public:
	Person(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
	int a;
	int b;
};
void show(int a)
{
	cout << a << endl;
}


void Test()
{
	Person p1(10, 20);
	Person p2(10, 20);
	Person p3(10, 20);
	Person p4(10, 20);
	Person p5(10, 20);

	vector<Person> a;
	//向容器中放数据
	a.push_back(p1);
	a.push_back(p2);
	a.push_back(p3);
	a.push_back(p4);
	a.push_back(p5);

	for (vector<Person>::iterator i = a.begin(); i != a.end(); i++)
	{
		cout << (*i).a << "    " << (*i).b << endl;
	}
}

void Test1()
{
	Person p1(10, 20);
	Person p2(10, 20);
	Person p3(10, 20);
	Person p4(10, 20);
	Person p5(10, 20);

	vector<Person*> a;
	//向容器中放数据
	a.push_back(&p1);
	a.push_back(&p2);
	a.push_back(&p3);
	a.push_back(&p4);
	a.push_back(&p5);

	for (vector<Person*>::iterator i = a.begin(); i != a.end(); i++)
	{
		cout << (*i)->a << "    " << (*i)->b << endl;
	}
}

int main()
{
	Test();
	Test1();
	system("pause");
	return 0;
}

1.5.3 Vector容器嵌套容器

一个数组中嵌套一个小数组，相似于二维数组

#include<iostream>
using namespace std;

#include<vector>
#include<algorithm>

void Test()
{
	vector<vector<int>> a;

	vector<int> a1;
	vector<int> a2;
	vector<int> a3;
	vector<int> a4;
	vector<int> a5;

	for (int i = 0; i < 4; i++)
	{
		//向容器中放数据
		a1.push_back(i+1);
		a2.push_back(i+2);
		a3.push_back(i+3);
		a4.push_back(i+4);
		a5.push_back(i+5);
	}

	a.push_back(a1);
	a.push_back(a2);
	a.push_back(a3);
	a.push_back(a4);
	a.push_back(a5);

    //经过大容器，把全部数据遍历一遍
	for (vector<vector<int>>::iterator i = a.begin(); i != a.end(); i++)
	{
        //（*）it————容器vector<int>
		for (vector<int>::iterator j = (*i).begin(); j != (*i).end(); j++)
		{
			cout << *j <<"   ";
		}
		cout << endl;
	}
}

int main()
{
	Test();
	system("pause");
	return 0;
}

2，STL经常使用容器

注：下面几乎所有都是套用模板，因此有些地方未展现代码，均可以根据模板本身尝试

2.1string容器

2.1.1string基本概念

本质：

string是C++风格的字符串，而string本质上是一个类

string和char*的区别：

char*是一个指针
string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器

特色：

string内部封装了不少成员方法

2.1.2string构造函数

string(); //建立一个空的字符串

string s1;

string(const char *s); //使用字符串s初始化

const char *a = "hello world";
string s2(a);

string(const string &str); //使用一个string对象初始化另外一个string对象

string s3(a);

string(int n,char c); //使用n个字符c初始化

string s4(5, 'a');

2.1.3string赋值操做

功能：

给string类型字符串进行赋值

赋值的函数原型：

string& operator=(const char*s); //char*类型字符串，赋值给当前的字符串

string s1=("hello world");

string& operator=(const string*s); //把字符串s赋值给当前的字符串

string s2=a;

string& operator=(char c); //字符赋值给当前的字符串

string s3 = ("h");

string& assign(const char*s); //把字符串s赋值给当前的字符串

s4.assign(a);

string& assign(const char*s,int n); //把字符串s的前n个字符赋给当前的字符串

s5.append("hello world", 5);

string& assign(const string*s); //把字符串s赋给当前字符串

string s6;

s6.assign("hello world");

string& assign(int n,const c); //用n个字符c赋值给当前字符串

string s7(5, 'a');

2.1.4string字符串拼接

功能：

实如今字符串末尾拼接字符串

函数原型：

string& operator+=(const char* str); //重载+=操做符

s1 += "hello";

string& operator+=(const char c); //重载+=操做符

s1 += ',';

string& operator+=(const string& str); //重载+=操做符

s1 += s2;

string& append(const char* s); //把字符串s链接到当前字符后才能结尾

s3.append("am");

string& append(const char* s,int n); //把字符串s的前n个字符链接到当前字符串结尾

s3.append("abcdef", 4);

string& append(const string &s); //同operator+=(const string& str);

s3.append(s2);

string& append(const string &s,int pos,int n); //字符串s中从pos开始的n个字符链接到字符串结尾

s3.append(s2, 0, 4);

2.1.5string查找和替换

功能描述：

查找：查找指定字符串是否存在
替换：在指定位置替换字符串

函数原型：

int find(const string& str,int pos=0) const; //查找str第一次出现位置，从pos开始查找
int find(const char* str,int pos=0) const; //查找s第一次出现位置，从pos开始查找

   const char *a1 = "wo";
   string a2 = "hello world";
   int b = a2.find(a1);

int find(const char*s, int pos,int n) const; //从pos位置查找s的前n个字符第一次位置

int b = a2.find(a1, 2, 1);

int find(const char c,int pos=0) const; //查找字符c第一次出现位置
int rfind(const string& str,int pos=npos) const; //查找str最后一次位置，从pos开始查找
int rfind(const char* s,int pos=npos) const; //查找s最后一次出现位置，从pos开始查找

   const char *a1 = "wo";
   string a2 = "hello worldwo";
   int b = a2.rfind(a1);

int rfind(const char* s,int pos,int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c,int pos=0) const; //查找字符c最后一次出现位置
string& replace(int pos,int n,const string &str) ; //替换从pos开始n个字符为字符串str

string a2 = "hello world";
a2.replace(1, 3, "aaaaa");

string& replace(int pos,int n,const char *s) ; //替换从pos开始的n个字符为字符串s

总结：

find查找是从左往右，rfind从右往左
find找到字符后返回查找的第一个字符位置，找不到返回-1
replace在替换时，要指定从哪一个位置起，多少个字符，替换成什么样的字符串

2.1.6string字符串比较

功能介绍：

字符之间进行比较

比较方式：

字符串是按照字符的ASCLL码进行比较对比

= 返回 0
> 返回 1
< 返回 -1

函数原型：

int compare(const string &s) const; //与字符串进行比较
int compare(const char *s) const; //与字符串进行比较

#include<iostream>
using namespace std;
#include<string>

int main()
{
	string a = "hello";
	string b = "hello";
	if (a.compare(b) == 0)
	{
		cout << "a与b相等" << endl;
	}
	else if (a.compare(b) == 1)
	{
		cout << "a大于b" << endl;
	}
	else
	{
		cout << "a小于b" << endl;
	}
	system("pause");
	return 0;
}

总结：主要目的是判断是否相等，并非判断谁大谁小

2.1.7 string字符存取

string中单个字符的存取方式有两种

char &operator[](int n); //经过[]方式取字符
char &at(int n); //经过at方式取字符

#include<iostream>
using namespace std;
#include<string>

int main()
{
	string a = "hello";

	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << "  " << a.at(i) << endl;
	}
	a[0] = 'a';
	cout << a << endl;
	a.at(1) = 'a';
	cout << a << endl;
	system("pause");
	return 0;
}

总结：利用“[ ]”和“at()”；

2.1.8string插入和删除

功能描述：

对string类型进行插入和删除字符操做

函数原型：

string &insert(int pos,const char*s); //插入字符串

string a = "hello";
a.insert(1, "aaa");

string &insert(int pos,const string&s); //插入字符串
string &insert(int pos,int n,char c); //在指定位置插入n个字符c
string &erase(int pos,int n=npos); //删除从Pos开始的n个字符

a.erase(1, 3);

2.1.9string子串

功能描述：

从字符串中获取想要的字串

函数原型：

string substr(int pos =0,int n=npos) const; //返回由pos开始的n个字符组成的字符串

string a = "helloasdq";
string b = a.substr(2, 5);

2.2vector容器

2.2.1 vector基本概念

功能：

vector数据结构和数组很是类似，也称为单端数组

vector与普通数组区别：

不一样之处在于数组是静态空间，而vector能够动态扩展

动态扩展：

并非在原空间以后续接新空间，而是找更大的内存空间，而后将原数据拷贝新空间，释放原空间。
vector容器是支持随机访问的迭代器

2.2.2vector构造函数

功能描述：

建立vector容器

函数原型：

vector<T> v; //采用模板实现类实现，默认构造函数

   vector<int> a;
   for (int i = 0; i < 10; i++)
   {
       a.push_back(i);
   }

vector(v.begin(),v.end()); //将v[begin(),end()]区间中的元素拷贝给自己

vector<int>b(a.begin(), a.end());

vector(n,elem); //构造函数将n个elem拷贝给自己

vector<int>c(10, 100);

vector(const vector &vec); //拷贝构造函数

vector<int>d(c);

2.2.3vector赋值操做

功能描述：

给vector容器进行赋值

函数原型：

vector &operator=(const vector &vec); //重载等号操做符

vector<int>b;
b.assign(a.begin(), a.end());

assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给自己

vector<int>c;
c = a;

assign(n,elem); //将n个elem拷贝赋值给自己

vector<int>d;
d.assign(10, 100);

2.2.4vector容量和大小

功能描述：

对vector容器的容量和大小操做

函数原型：

empty(); //判断容器是否为空

   if (a.empty())
   {
       cout << "容器为空" << endl;
   }

capacity(); //容器的容量

cout << a.capacity() << endl;

size(); //返回容器中元素的个数

cout << a.size() << endl;

resize(int num); //从新指定元素的长度为num，若容器变长，则以默认值填充新位置，若是变短，则超出部分删除

a.resize(5);

resize(int num,elem); //从新指定容器长度，若是边长，则用elem填充，若是变短，则超出部分删除

a.resize(3, 10);

2.2.5vector插入和删除

功能描述：

对vector容器进行插入，删除操做

函数原型：

push_back(ele); //尾部插入元素ele

   vector<int> a;
   for (int i = 0; i < 10; i++)
   {
       a.push_back(i);
   }

pop_back(); //删除最后一个元素

a.pop_back();

insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele

a.insert(a.begin(), 100);

insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele

a.insert(a.begin(), 3, 100);

erase(const_iterator pos); //删除迭代器指向的元素

a.erase(a.begin());

erase(const_iterator start,const_iterator end); //删除迭代器从start到end之间的元素

a.erase(a.begin(), a.end());

clear(); //删除容器中全部的元素

a.clear();

2.2.6vector数据存取

功能描述：

对vector中的数据的存取操做

函数原型：

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个元素数据
break(); //返回容器中最后一个数据元素

   cout << a[1];
   cout << a.at(1);
   cout << a.front();
   cout << a.back();

2.2.7vector互换容器

功能描述：

实现两个容器内元素进行互换

函数原型：

swap(vec); //将vec与自己的元素互换

   b.swap(a);
   vector<int>(a).swap(a); //当容量过大，可是数据不多时，能够用这种方法收缩内存
   （经过匿名对象）

2.2.8预留空间

功能描述：

减小vector在动态扩展容量时的扩展次数

函数原型：

reserve(int len); //容器中预留len个元素长度，预留位置不初始化，元素不可访问

2.3deque容器

2.3.1deque容器基本概念

功能：

双端数组，能够对头部进行插入删除操做

deque和vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度比vector快
vector访问元素时的速度会比deque快，这和二者内部是实现有关

deque内部工做原理：

中控器用来维护每段缓冲区中的内容，缓冲区中存放真实数据，若是一个缓冲区数据存满以后，则在中控器中开辟新的一块，维护新的一段缓冲器来保存数据。中控器中维护的是每一个缓冲区的地址，使得使用deque时，像一片连续的内存空间

deque使用了两个迭代器M_start和M_finish，对首个deque块和末deque块进行控制访问。迭代器iterator共有4个变量域，包括M_first、M_last、M_cur和M_node。M_node存放当前deque块的Map数据项地址，M_first和M_last分别存放该deque块的首尾元素的地址（M_last实际存放的是deque块的末尾字节的地址），M_cur则存放当前访问的deque双端队列的元素地址。

2.3.2deque构造函数

功能描述：

deque容器构造

函数原型：

deque<T> deqT; //默认构造函数

   deque<int> a;
   for (int i = 0; i < 5; i++)
   {
       a.push_back(i);
   }

deque(beg,end); //构造函数将[beg，end]区间中的元素拷贝给自己

deque<int>b(a.begin(),a.end());

deque(n,len); //构造函数将n个elem拷贝给自己

deque<int>c(10, 100);

deque(const deque &deq); //拷贝构造函数

deque<int>d(c);

2.3.3deque赋值操做

功能描述：

给deque容器进行赋值

函数原型：

deque operator=(const deque &deq); //重载等号运算符

deque<int>d;
d=a;

assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给自己

b.assign(a.begin(), a.end());

assign(n,elem); //将n个elem拷贝赋值给自己

c.assign(10, 100);

2.3.4deque大小操做

功能描述：

对deque容器的大小进行操做

函数原型：（直接套用模板，没有展现代码部分）

deque.empty(); //判断是否为空
deque.size(); //返回容器中的个数
deque.resize(num); //从新指定个数，容器变长则填充默认值，容器变短，则超出部分删除
deque.resize(num,elem); //从新制定个数，容器变长则用elem填充，容器变短，则超出部分删除
deque中没有容量的概念

2.3.5deque插入和删除

功能描述：

向deque容器中插入和删除数据

函数原型：（代码实现直接套用模板）

两端插入操做：

push_back(elem);
push_front(elem);
pop_back();
pop_front();

指定位置操做：

insert(pop,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值

a.insert(a.begin(),10);
a.insert(a.begin(), 5, 100);

insert(pop,beg,end); //在pos位置插入[beg，end]区间的数据，无返回值
clear(); //清空全部数据
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置
erase(pos); /删除pos位置的数据，返回下一数据的位置

a.erase(a.begin() + 7);

插入删除提供的位置都是迭代器

2.3.6deque数据存储

功能描述：

对deque中的数据的存取操做

函数原型：（代码实现直接套用模板）

at(int idx); //返回索引idx所指向的数据
operator[ ]; //返回索引idx所指向的数据
front(); //返回容器中第一个数据元素
back() //返回容器中最后一个数据元素

2.3.7deque排序

功能描述：

利用算法实现对deque容器进行排序

算法：

sort(iterator beg,iterator end); //对beg和end区间内数据进行排序

#include<iostream>
using namespace std;
#include<deque>
#include<algorithm>    //标准算法头文件

void show(const deque<int>&a)
{
	for (deque<int>::const_iterator i = a.begin(); i != a.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
}
int main()
{
	deque<int> a;
	for (int i = 0; i < 5; i++)
	{
		a.push_back(i);
	}
	for (int i = 5; i < 10; i++)
	{
		a.push_front(i);
	}
	show(a);

	sort(a.begin(),a.end());
	show(a);
	system("pause");
	return 0;
}

注：

默认排序为从小到大排序
须要包含头文件：#include<algorithm> //标准算法头文件

2.4stack容器

2.4.1stack的基本概念

概念：stack是一种先进后出的数据结构，它只有一个出口

栈中只有栈顶的元素才能够被外界使用，所以栈中不容许有遍历行为

栈中进入数据称为——入栈 push
栈中弹出数据称为——出栈 pop

2.4.2stack经常使用接口

功能描述：

栈容器经常使用的对外接口

构造函数：

stack<T> stk; //stack采用模板类实现，stack对象的默认构造形式

stack<int> a;

stack(const stack &stk); //拷贝构造函数

赋值操做：

stack operator=(const stack &stk) //重载等号操做符

数据存取：

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

大小操做：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

   stack<int> a;
   for (int i = 0; i < 5; i++)
   {
       a.push(i);
   }
   stack<int> b(a);
   stack<int>c;
   c= a;
   while (!a.empty())
   {
       cout << a.top() << endl;
       a.pop();
   }

2.5queue容器

2.5.1queue基本概念

概念：queue是一种先进先出的数据结构，他有两个出口

队列容器容许从队尾新增数据，从队头移除数据，只有队头和队尾才能被外界使用，因此不容许有遍历行为

队列中进数据称为——入队 push
队列中出数据称为——出队 pop

2.5.2quene经常使用接口

功能描述：

队列容器经常使用的对外接口

构造函数：

quene<T> que; //quene采用模板类实现，quene对象的默认构造形式
quene(const quene &que); //拷贝构造函数

赋值操做：

quene operator=(const quene &stk) //重载等号操做符

数据存取：

push(elem); //向队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素

cout << a.front() << " " << a.back() << endl;

大小操做：

empty(); //判断容器是否为空
size(); //返回容器的大小

2.6 list容器

2.6.1 list基本概念

功能：将数据进行链式存储

链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是经过链表中的指针链表实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据单元的数据域，另外一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

因为链表的存储方式并非连续的内存地址，所以链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优势：

采用动态存储分配，不会形成内存浪费和溢出
链表执行插入和删除操做十分方便，修改指针便可，不须要移动大量元素

list的缺点：

链表灵活，可是空间（指针域）和时间（遍历）额外消耗较大

list在插入操做和删除操做都不会形成原有list迭代器失效，这在vector是不成立的

2.6.2 list构造函数

功能描述：

建立list容器

函数原型：

list<T> lst; //list采用采用模板类实现，对象的默认构造形式
list(beg,end); //构造函数将(beg ,end)区间中的元素拷贝给自己
list(n,elem); //构造函数将n个elem拷贝给自己
list(const list&lst); //拷贝构造函数

2.6.3list赋值和交换

功能描述：

给list容器进行赋值，以及交换list容器

函数原型：

assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给自己
assign(n,elem); //将n个elem拷贝赋值给自己
list& operator=(const list &lst); //重载等号操做符
swap(lst); //将list与自己的元素互换

2.6.4 list大小操做

功能描述：

对list容器的大小进行操做

函数原型：（直接套用模板，没有展现代码部分）

empty(); //判断是否为空
size(); //返回容器中的个数
resize(num); //从新指定个数，容器变长则填充默认值，容器变短，则超出部分删除
resize(num,elem); //从新制定个数，容器变长则用elem填充，容器变短，则超出部分删除

2.6.5list插入和删除

功能描述：

向list容器中进行数据插入和删除

函数原型：（代码实现直接套用模板）

两端插入操做：

push_back(elem); //在容器尾部加一个元素
push_front(elem); //在容器开头插入一个元素
pop_back(); //删除容器最后一个元素
pop_front(); //从容器开头移除第一个元素
insert(pop,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值
insert(pop,beg,end); //在pos位置插入[beg，end]区间的数据，无返回值
clear(); //清空全部数据
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置
erase(pos); /删除pos位置的数据，返回下一数据的位置
remove(elem); //删除容器中全部与elem值匹配的元素

2.6.6 list数据存取

功能描述：

对list容器中数据进行存取

函数原型：

front(); //返回第一个元素
back(); //返回最后一个元素

#include<iostream>
using namespace std;
#include<list>
#include<algorithm>    //标准算法头文件


int main()
{
	list<int> a;
	for (int i = 0; i < 5; i++)
	{
		a.push_back(i);
	}
	list<int> b(a);
	while (!a.empty())
	{
		cout << a.front() << "  " << a.back() << endl;
		a.pop_back();
	}
	b.erase(b.begin());
	cout << b.front() << endl;
	b.remove(3);

	system("pause");
	return 0;
}

2.6.7 list反转与排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表
sort(); //链表排序（从小到大）

#include<iostream>
using namespace std;
#include<list>
#include<algorithm>    //标准算法头文件


int main()
{
	list<int> a;
	a.push_front(40);
	a.push_front(20);
	a.push_front(30);
	a.push_front(10);
	a.push_front(90);
	a.push_front(60);
	list<int>b;
	b = a;
	list<int>c(b);
	while (!a.empty())
	{
		cout << a.front()<<" ";
		a.pop_front();
	}
	cout << endl;
	b.reverse();
	while (!b.empty())
	{
		cout << b.front() << "  ";
		b.pop_front();
	}
	cout << endl;
	c.sort();
	while (!c.empty())
	{
		cout << c.front() << "  ";
		c.pop_front();
	}
	system("pause");
	return 0;
}

2.7 set/mutiset容器

2.7.1 set基本概念

简介：

全部元素都会在插入时自动被排序

本质：

set/multiset属于关联式容器，底层结构是用二叉树实现

set和multise区别：

set不容许容器中有重复的元素
multise容许容器中有重复的元素

2.8.2 set构造和赋值

功能描述：建立set容器以及赋值

构造：

set<T> st; //默认构造函数
set(const set &st); //拷贝构造函数

赋值：

set & operator=(cosnt set &st)； //重载等号操做符

2.8.3set大小和交换

功能描述：

统计set容器的大小以及交换set容器

函数原型：

size(); //返回容器中元素的个数
empty(); //判断容器是否为空
swap(st); //交换两个集合容器

2.8.4 set插入和删除

功能描述：

set容器中插入和删除数据

函数原型：（代码实现直接套用模板）

insert(elem); //在容器中插入元素
clear(); //清空全部数据
earse(beg,end); //删除[beg,end]区间的数据，返回下一个元素的迭代器
earse(pos); /删除pos迭代器所指的元素，返回下一元素的迭代器
earse(elem); //删除容器中值为elem的元素

for (set<int>::iterator i = a.begin(); i != a.end();i++)

2.8.5 set查找和统计

功能描述：

对set容器进行查找数据以及统计数据

函数原型：

find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();
cout(key); //统计key的元素个数

#include<iostream>
using namespace std;
#include<set>
#include<algorithm>    //标准算法头文件


int main()
{
	set<int>a;
	a.insert(1);
	a.insert(2);
	a.insert(3);
	a.insert(3);         //数字重复，不会插入
	a.insert(4);
	a.insert(5);

	if (a.find(4) != a.end())
	{
		cout<<"找到数据：" << *a.find(4)<<endl;
	}
	cout << "个数为：" << a.count(3) << endl;
	system("pause");
	return 0;
}

2.8.6 set和multise区别

区别：

set不能够插入重复数据，而multise能够
set插入数据的同时会返回插入结果，表示插入是否成功
multise不会监测数据，所以能够插入重复数据

2.8.7pair对组建立

功能描述：

成对出现的数据，利用对组能够返回两个数据

两种建立方式：

pair<type,type> p(value1, value2);
pair<type,type> p=make_pair(value1,value2);

   pair<int, int> a(10, 20);
   cout << a.first << " " << a.second << endl;
   pair<int, int> b=pair<int,int>(10, 20);

2.8.8 set容器排序

1.内置数据类型

#include<iostream>
using namespace std;
#include<set>
#include<algorithm>

class Test
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}

};
int main()
{
	set<int>a;
	for (int i = 0; i < 5; i++)
	{
		a.insert(i);
	}
	for (set<int>::iterator j = a.begin(); j != a.end(); j++)
	{
		cout << *j << "   ";
	}
	cout << endl;

	set<int,Test>b;
	for (int i = 0; i < 5; i++)
	{
		b.insert(i);
	}
	for (set<int>::iterator j = b.begin(); j != b.end(); j++)
	{
		cout << *j << "   ";
	}
	system("pause");
	return 0;
}

2，自定义数据类型

#include<iostream>
using namespace std;
#include<set>
#include<algorithm>
#include<string>

class Test
{
public:
	Test(string a, int b)
	{
		this->a = a;
		this->b = b;
	}
	string a;
	int b;
};

class Test1
{
public:
	bool operator()(const Test &a1, const Test &a2)
	{
		return a1.b > a2.b;
	}
};

int main()
{
	Test p1("小明", 10);
	Test p2("小红", 20);
	Test p3("小华", 30);
	set<Test,Test1> s;
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	for (set<Test,Test1>::iterator j = s.begin(); j != s.end(); j++)
	{
		cout << (*j).a<<"    "<<(*j).b<<endl;
	}
	system("pause");
	return 0;
}

2.9 map/multimap容器

2.9.1 map基本概念

简介：

map中全部元素都是pair
pair中第一个元素为key（键值），起到索引做用，第二个元素为value（实值）
全部元素都会根据元素的键值自动排序

本质：

map/multimap属于关联式容器，底层结构是用二叉树实现

优势：

能够根据key值快速找到value值

map和multimap区别：

map不容许容器有重复的key值元素
multimap容许容器中有重复的key值元素

2.9.2 map构造函数

功能描述：

对map让其进行构造和赋值操做

函数原型：

构造：

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

赋值：

map & operator=(const map &mp); //重载等号操做符

2.9.3 map大小和交换

功能描述：

统计map容器的大小以及交换set容器

函数原型：

size(); //返回容器中元素的数目
empty(); //判断容器是否为空
swap(st); //交换两个集合容器

2.9.4 map插入和删除

功能描述：

map容器中插入和删除数据

函数原型：（代码实现直接套用模板）

insert(elem); //在容器中插入元素
clear(); //清空全部数据
earse(beg,end); //删除[beg,end]区间的数据，返回下一个元素的迭代器
earse(pos); /删除pos迭代器所指的元素，返回下一元素的迭代器
earse(elem); //删除容器中值为elem的元素

2.9.5 map查找和统计

功能描述：

对map容器进行查找数据以及统计数据

函数原型：

find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();
cout(key); //统计key的元素个数

#include<iostream>
using namespace std;
#include<map>
#include<algorithm>    //标准算法头文件

int main()
{
	map<int,int>a;
	a.insert(pair<int, int>(1, 10));
	a.insert(pair<int, int>(2, 20));
	a.insert(pair<int, int>(3, 30));
	a.insert(pair<int, int>(4, 40));

	for (map<int, int>::iterator i = a.begin(); i != a.end(); i++)
	{
		cout << i->first << "   " << (*i).second << endl;
	}
	cout << "3个数为：" << a.count(3) << endl;
	cout << a.size() << endl;
	system("pause");
	return 0;
}

2.9.6 map容器排序

利用仿函数进行排序:

class Test
{
public:
   bool operator()(int val1, int val2)
   {
       return val1 > val2;
   }
};

3，STL——函数对象

3.1函数对象

3.1.1函数对象概念

概念：

重载函数调用操做符的类，其对象常称为函数对象
函数对象使用重载的（）时，行为相似函数调用，也叫仿函数

本质：

函数对象（仿函数）是一个类，不是一个函数

3.1.2函数对象使用

特色：

函数对象在使用时，能够像普通函数那样调用，能够有参数，能够有返回值
函数对象超出普通函数的概念，函数对象能够有本身的状态
函数对象能够做为参数传递

3.2谓词

3.2.1谓词概念

概念：

返回bool类型的仿函数称为谓词
若是operator（）接受一个参数，那么叫作一元谓词
若是operator（）接受两个参数，那么叫作二元谓词

3.2.2一元谓词

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

class Test
{
public:
	bool operator()(int val)
	{
		return val > 2;
	}
};
int main()
{
	vector<int>a;
	for (int i = 0; i < 5; i++)
	{
		a.push_back(i);
	}
	vector<int>::iterator j = find_if(a.begin(), a.end(), Test());
	if (j == a.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << *j << endl;
	}
	system("pause");
	return 0;
}

3.2.3二元谓词

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

class Test
{
public:
	bool operator()(int val1,int val2)
	{
		return val1 > val2;
	}
};
int main()
{
	vector<int>a;
	for (int i = 0; i < 5; i++)
	{
		a.push_back(i);
	}
	for (vector<int>::iterator j = a.begin(); j != a.end(); j++)
	{
		cout << *j << "   ";
	}
	cout << endl;
	sort(a.begin(), a.end(), Test());
	for (vector<int>::iterator j = a.begin(); j != a.end(); j++)
	{
		cout << *j << "   ";
	}
	system("pause");
	return 0;
}

3.3内建函数对象

3.3.1内建函数对象意义

概念：

STL内建了一些函数对象

分类：

算法仿函数
关系仿函数
逻辑仿函数

用法：

这些仿函数所产生的对象，用法和通常函数彻底相同
使用内建函数对象，须要引入头文件#include<function>

3.3.2算数仿函数

功能描述：

实现四则运算
其中negate是一元运算，其它都是二元运算

仿函数原型：

template<class T> T plus<T> //加法仿函数
template<class T> T minus<T> //减法仿函数
template<class T> T multiplies<T> //乘法仿函数
template<class T> T divides<T> //除法仿函数
template<class T> T modulus<T> //取模仿函数
template<class T> T negate<T> //取反仿函数

   plus<int>a;
   cout << a(10, 20) << endl;
   multiplies<int>b;
   cout << b(10, 20) << endl;

3.3.3关系仿函数

功能描述：

实现关系对比

仿函数原型：

template<class T> bool equal_to<T> //等于
template<class T> bool not_equal_to<T> //不等于
template<class T> bool greater<T> //大于
template<class T> bool greater_equal<T> //大于等于
template<class T> bool less<T> //小于
template<class T> bool less_equal<T> //小于等于

sort(a.begin(), a.end(), greater<int>());

3.3.4逻辑仿函数

功能描述：

实现逻辑运算

仿函数原型：

template<class T> bool logical_and<T> //逻辑与
template<class T> bool logical_or<T> //逻辑或
template<class T> bool logical_not<T> //逻辑非

transform(a.begin(), a.end(), b.begin(), logical_not<bool>());

4，STL——经常使用算法

概述：

算法主要是由头文件<algorithm> <functional> <numeric>组成
<algorithm>李时全部STL头文件中最大的一个，范围涉及到比较，交换，查找，遍历操做，复制，修改等等
<numeric>体积很小，只包括几个在序列上面进行简单数字运算的模板函数
<functional>定义了一些模板类，用以声明函数对象

4.1经常使用遍历算法

算法简介：

for_each //遍历容器
transform //搬运容器到另外一个容器中

4.1.1 for_each

功能描述：

实现遍历容器

函数原型：

for_each(iterator beg,iterator end,_func);

//beg开始迭代器；end结束迭代器；_func函数或者函数对象

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

void show(bool a)
{
	cout << a << "  ";
}
int main()
{
	vector<bool>a;
	a.push_back(true);
	a.push_back(false);
	a.push_back(false);
	a.push_back(true);
	a.push_back(true);
	a.push_back(false);
	for_each(a.begin(), a.end(), show);
	system("pause");
	return 0;
}

4.1.2 transform

功能描述：

搬运容器到另外一个容器中

函数原型：

transform(iterator beg1,iterator end1,iterator beg2，_func);

//beg1源容器开始迭代器；end1源容器结束迭代器；beg2目标容器开始迭代器；_func函数或者函数对象

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

bool take(bool a)
{
	return a;
}
void show(bool a)
{
	cout << a << "  ";
}
int main()
{
	vector<bool>a;
	a.push_back(true);
	a.push_back(false);
	a.push_back(false);
	a.push_back(true);
	a.push_back(true);
	a.push_back(false);
	vector<bool>b;
	b.resize(a.size());
	transform(a.begin(), a.end(), b.begin(),take);
	for_each(b.begin(), b.end(), show);
	system("pause");
	return 0;
}

4.2经常使用查找算法（全部模板都同样）

算法简介：

find //查找元素
find_if //按条件查找元素
adjacent_find //查找相邻重复元素
binary_search //二分查找法
count //统计元素个数
count_if //按条件统计元素个数

4.2.1 find

功能描述：

查找指定元素，找到返回指定元素的迭代器，找不到的返回结束迭代器end()

函数原型：

find(iterator beg,iterator end,value);

//beg开始迭代器；end结束迭代器；value查找的元素

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

int main()
{
	vector<int>a;
	for (int i = 0; i < 10; i++)
	{
		a.push_back(i);
	}
	vector<int>::iterator b = find(a.begin(), a.end(), 5);
	if (b == a.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "找到数据" << endl;
	}
	system("pause");
	return 0;
}

4.2.2 find_if

功能描述：

按条件查找元素

函数原型：

find(iterator beg,iterator end,_Pred);

//按值查找指定元素，找到返回指定元素的迭代器，找不到的返回结束迭代器end(）

//beg开始迭代器；end结束迭代器；_Pred函数或者谓词（返回bool类型的仿函数）

4.2.3 adjacent_find

功能描述：

查找相邻重复的元素

函数原型：

adjacent_find(iterator beg,iterator end);

//查找相邻重复元素，返回相邻元素的第一个位置

//beg开始迭代器；end结束迭代器；

4.2.4 binary_search

功能描述：

查找指定元素是否存在

函数原型：

bool binary_search(iterator beg,iterator end,value);

//查找相邻指定元素，查到返回true，不然返回false

//在无序中不可用

//beg开始迭代器；end结束迭代器；value查找的元素

4.2.5 count

功能描述：

统计元素个数

函数原型：

cout(itrerator beg,iterator end,value);

//统计元素出现次数

//beg开始迭代器；end结束迭代器；value统计的元素

4.2.6 count_if

功能描述：

按条件统计元素个数

函数原型：

cout_if(itrerator beg,iterator end,_Pred);

//按条件统计元素出现次数

//beg开始迭代器；end结束迭代器；_Pred 谓词

4.3经常使用的排序算法

算法简介：

sort //对容器内元素进行排序
random_shuffle //洗牌指定范围内的元素随机调整次序
merge //容器元素合并，并存储到另外一个容器中
reverse //反转指定范围的元素

4.3.1 sort

功能描述：

对容器内元素进行排序

函数原型：

sort(itrerator beg,iterator end,_Pred);

按值查找指定元素，找到返回指定元素的迭代器，找不到的返回结束迭代器

//beg开始迭代器；end结束迭代器；_Pred 谓词

4.3.2 random_shuffle

功能描述：

洗牌指定范围内的元素随机调整次序

函数原型：

random_shuffle(itrerator beg,iterator end);

//指定范围内的元素随机调整次序

//beg开始迭代器；end结束迭代器；

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<functional>
#include<numeric>

void show(int a)
{
	cout << a << "  ";
}
int main()
{
	vector<int>a;
	for (int i = 0; i < 10; i++)
	{
		a.push_back(i);
	}
	random_shuffle(a.begin(), a.end());
	for_each(a.begin(), a.end(), show);
	system("pause");
	return 0;
}

4.3.3 merge

功能描述：

两个容器合并，并存储到另外一个容器中

函数原型：

merge(itrerator beg1,iterator end1,itrerator beg2,iterator end2,iterator dest);

//两个容器必须有序

//beg1是容器1开始迭代器；end1容器1结束迭代器；beg2容器2开始迭代器；end2容器2结束迭代器；dest目标容器开始迭代器

   vector<int>c;
   c.resize(a.size() + b.size());
   merge(a.begin(), a.end(),b.begin(),b.end(),c.begin());
   for_each(c.begin(), c.end(), show);

4.3.4 reverse

功能描述：

将容器内元素进行反转

函数原型：

reverse(iterator beg,iterator end);

//反转指定范围的元素

//beg开始迭代器，end结束迭代器

4.4经常使用拷贝和替换算法

算法简介：

copy //容器内指定范围内的元素拷贝到另外一个容器中
replace //将容器内指定范围的旧元素改成新元素
replace_if //容器内指定范围知足条件的元素替换为新元素
swap //互换两个容器的元素

4.4.1 copy

功能描述：

容器内指定范围内的元素拷贝到另外一个容器中

函数原型：

copy(itrerator beg,iterator end,iteartor dest);

//按值查找元素，找到返回指定位置的迭代器，找不到返回结束迭代器位置

//beg开始迭代器；end结束迭代器；dest目标起始迭代器

4.4.2 replace

功能描述：

将容器内指定范围的旧元素改成新元素

函数原型：

replace(itrerator beg,iterator end,oldvalue,newvalue);

//按值查找元素，找到返回指定位置的迭代器，找不到返回结束迭代器位置

//beg开始迭代器；end结束迭代器；oldvalue 旧元素；newvalue新元素

4.4.3 replace_if

功能描述：

将容器内知足条件的元素替换为指定元素

函数原型：

replace_if(itrerator beg,iterator end,_Pred,newvalue);

//按条件替换元素，知足条件则替换

//beg开始迭代器；end结束迭代器；_Pred 谓词；newvalue替换的新元素

4.4.4 swap

功能描述：

互换两个容器的元素

函数原型：

swap(container c1,container c2);

//互换两个容器的元素

//c1容器1；c2容器2

4.5经常使用算术生成算法

注：

须要加头文件#include<numeric>

算法简介：

accumulate； //计算容量元素累计综合
fill; //向容器中添加元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<numeric>
#include<functional>

void show(int a)
{
	cout << a << "  ";
}
int main()
{
	vector<int>a;
	for (int i = 0; i < 10; i++)
	{
		a.push_back(i);
	}
	int b = 0;
	b = accumulate(a.begin(), a.end(), 0);
	cout << b << endl;
	system("pause");
	return 0;
}

4.5.1 accumulate

功能描述：

计算区间内容量元素累计总和

函数原型：

accumlate(iterator beg,iterator end,value);

//beg开始迭代器；end结束迭代器；value起始值

4.5.2 fill

功能描述：

向容器中填充指定的元素

函数原型：

fill(iterator beg,iterator end,value);

//beg开始迭代器；end结束迭代器；value填充的值

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<numeric>
#include<functional>

void show(int a)
{
	cout << a << "  ";
}
int main()
{
	vector<int>a;
	for (int i = 0; i < 10; i++)
	{
		a.push_back(i);
	}
	fill(a.begin(), a.end(), 0);
	for_each(a.begin(), a.end(), show);
	system("pause");
	return 0;
}

4.6经常使用集合算法

算法简介：

set_intersection //求两个容器的交集
set_union //求两个元素的并集
set_difference //求两个容器的差值

4.6.1 set_intersection

函数原型： set_intersection（iterator beg1;iterator end1;iterator beg2,iterator end2,iterator dest);

//beg1是容器1开始迭代器；end1容器1结束迭代器；beg2容器2开始迭代器；end2容器2结束迭代器；

//dest目标容器开始迭代器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<numeric>
#include<functional>

void show(int a)
{
	cout << a << "  ";
}
int main()
{
	vector<int>a;
	for (int i = 0; i < 10; i++)
	{
		a.push_back(i);
	}
	vector<int>b;
	for (int i = 5; i < 15; i++)
	{
		b.push_back(i);
	}
	vector<int>c;
	c.resize(a.size() + b.size());
	set_intersection(a.begin(), a.end(), b.begin(), b.end(), c.begin());
	for_each(c.begin(), c.end(), show);
	system("pause");
	return 0;
}

4.6.2 set_union

函数原型：

set_union（iterator beg1;iterator end1;iterator beg2,iterator end2,iterator dest);

//两个集合的并集，两个集合必须是有序序列

//beg1是容器1开始迭代器；end1容器1结束迭代器；beg2容器2开始迭代器；end2容器2结束迭代器；

//dest目标容器开始迭代器

4.6.3 set_different

函数原型： set_different(iterator beg1;iterator end1;iterator beg2,iterator end2,iterator dest);

//beg1是容器1开始迭代器；end1容器1结束迭代器；beg2容器2开始迭代器；end2容器2结束迭代器；

//dest目标容器开始迭代器