五味的编程日记

【C++】STL 总结

C++提高编程

2 STL初识

2.1 STL的诞生

长久以来，软件界一直希望建立一种可重复利用的东西

C++的面向对象和泛型编程思想，目的就是复用性的提升

大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作

为了建立数据结构和算法的一套标准,诞生了STL

2.2 STL基本概念

STL(Standard Template Library,标准模板库)

STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)

容器和算法之间通过迭代器进行无缝连接。

STL 几乎所有的代码都采用了模板类或者模板函数

2.3 STL六大组件

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

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。

算法：各种常用的算法，如sort、find、copy、for_each等

迭代器：扮演了容器与算法之间的胶合剂。

仿函数：行为类似函数，可作为算法的某种策略。

适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。

空间配置器：负责空间的配置与管理。

2.4 STL中容器、算法、迭代器

容器：置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表等

这些容器分为序列式容器和关联式容器两种:

序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)

算法分为:质变算法和非质变算法。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等

非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

迭代器：容器和算法之间粘合剂

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

每个容器都有自己专属的迭代器，迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

迭代器种类：

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

常用的容器中迭代器种类为双向迭代器，和随机访问迭代器

如果迭代器不进行修改操作，建议使用只读迭代器，const_iterator，反之则使用iterator迭代器。

2.5 容器算法迭代器（应该在后面）

了解STL中容器、算法、迭代器概念之后，我们利用代码感受STL的魅力

STL中最常用的容器为vector，可以理解为数组（本质是动态数组），下面我们将学习如何向这个容器中插入数据、并遍历这个容器

2.5.1 vector存放内置数据类型

容器： vector

算法： for_each

迭代器： vector::iterator

示例：

#include 
#include 

void MyPrint(int val)
{
    cout << val << endl;
}

void test01() {
    
    //创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
    vector v;
    //向容器中放数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    
    //每一个容器都有自己的迭代器，迭代器是用来遍历容器中的元素
    //v.begin()返回迭代器，这个迭代器指向容器中第一个数据
    //v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
    //vector::iterator 拿到vector这种容器的迭代器类型
    
    vector::iterator pBegin = v.begin();
    vector::iterator pEnd = v.end();
    
    //第一种遍历方式：
    while (pBegin != pEnd) {
        cout << *pBegin << endl;
        pBegin++;
    }
    
    
    //第二种遍历方式：
    for (vector::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << endl;
    }
    cout << endl;
    
    //第三种遍历方式：
    //使用STL提供标准遍历算法  头文件 algorithm
    for_each(v.begin(), v.end(), MyPrint);
}

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

v.end（）和v.begin()注意都有括号

push_back（）

for _each()

MyPrint 注意不用体现指针

2.5.2 Vector存放自定义数据类型

学习目标：vector中存放自定义数据类型，并打印输出

放对象

放对象指针

示例：

#include 
#include 

//自定义数据类型
class Person {
public:
	Person(string name, int age) {
		mName = name;
		mAge = age;
	}
public:
	string mName;
	int mAge;
};
//存放对象
void test01() {

	vector v;

	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

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

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << "Name:" << (*it).mName << " Age:" << (*it).mAge << endl;

	}
}


//放对象指针
void test02() {

	vector v;

	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

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

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		Person * p = (*it);
		cout << "Name:" << p->mName << " Age:" << (*it)->mAge << endl;
	}
}


int main() {

	test01();
    
	test02();

	system("pause");

	return 0;
}

写一个函数show_array，要求传入两个参数。

void show_array(T t,int len)

第一个参数为数组默认值，第二个参数为数组的长度。

此函数的功能为创建一个长度为len类型是T，默认值为t的数组并输出。

尽量不用使用c语言的数组。

#include 
#include 

using namespace std;

template 
void show_array(T defaultValue, int len)
{
    // 使用vector代替数组
    vector arr(len, defaultValue);

    // 输出数组的每个元素
    for (const auto& element : arr)
    {
        cout << element << " ";
    }
    cout << endl;
}

int main()
{
    // 创建一个长度为 5，类型为 int，默认值为 0 的数组
    show_array(0, 5);

    cout << "Hello World!" << endl;
    return 0;
}

2.5.3 Vector容器嵌套容器

学习目标：容器中嵌套容器，我们将所有数据进行遍历输出

示例：

#include 

//容器嵌套容器
void test01() {

	vector< vector >  v;

	vector v1;
	vector v2;
	vector v3;
	vector v4;

	for (int i = 0; i < 4; i++) {
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}

	//将容器元素插入到vector v中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);


	for (vector>::iterator it = v.begin(); it != v.end(); it++) {

		for (vector::iterator vit = (*it).begin(); vit != (*it).end(); vit++) {
			cout << *vit << " ";
		}
		cout << endl;
	}

}

int main() {

	test01();

	system("pause");

	return 0;
}

2.6 迭代器遍历

#include 

using namespace std;

int main()
{
    string s = "abcdefg";
    // 迭代器遍历string
    for(string::const_iterator iter = s.begin(); iter != s.end(); iter++)
    {
        cout << *iter;
    }
    cout << endl;
    // 迭代器遍历array
    array arr{23,22,66,8,21};
    for(array::const_iterator iter = arr.begin(); iter != arr.end();iter++)
    {
        cout << *iter << " ";
    }
    cout << endl;

    // 迭代器遍历 vector
    vector vec(6,"hello");
    for(vector::const_iterator iter = vec.begin(); iter != vec.end();iter++)
    {
        cout << *iter << endl;
    }
    cout << endl;
    // 迭代器遍历list
    listlis(6,"world");
    for(list::const_iterator iter = lis.begin(); iter != lis.end();iter++)
    {
        cout << *iter << endl;
    }
    cout << endl;

    // 迭代器遍历deque
    deque de(6,"nihao");
    for(deque::const_iterator iter = de.begin(); iter != de.end();iter++)
    {
        cout << *iter << endl;
    }

    // 迭代器遍历map
    map ma;
    ma["年龄"]  = 23;
    ma["身高"]  = 190;
    ma["体重"]  = 170;

    for(map::const_iterator iter = ma.begin(); iter != ma.end(); iter++)
    {
        // first 是键 second是值
        cout << iter->first << " " << iter->second << endl;
    }

    return 0;
}

3 STL- 常用容器

3.1 string容器（类）

字符串对象是一种特殊类型的容器，专门设计用于操作字符串的。

区别下面：char数组

#include 
 
using namespace std;
 
int main ()
{
   char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};    #这样才可以
       
 
   cout << "菜鸟教程: ";
   cout << site << endl;
 
   return 0;
}

1	strcpy(s1, s2);= 复制字符串 s2 到字符串 s1。
2	strcat(s1, s2);+ 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号，例如: string str1 = "runoob"; string str2 = "google"; string str = str1 + str2;
3	strlen(s1); 返回字符串 s1 的长度。
4	strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1s2 则返回值大于 0。
5	strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

3.1.1 string基本概念

本质：

string是C++风格的字符串，而string本质上是一个类（区别于char字符串数组）

**string和char 区别：

char * 是一个指针

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

特点：

string 类内部封装了很多成员方法

例如：查找find，拷贝copy，删除delete 替换replace，插入insert

string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

3.1.2 string构造函数

构造函数原型：

string(); //创建一个空的字符串例如: string str;
string(const char* s); //使用字符串s初始化

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

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

示例：

#include 
//string构造
void test01()
{
	string s1; //创建空字符串，调用无参构造函数
	cout << "str1 = " << s1 << endl;

	const char* str = "hello world";
	string s2(str); //把c_string转换成了string

	cout << "str2 = " << s2 << endl;

	string s3(s2); //调用拷贝构造函数
	cout << "str3 = " << s3 << endl;

	string s4(10, 'a');    //注意是单引号
	cout << "str3 = " << s3 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：string的多种构造方式没有可比性，灵活使用即可

3.1.3 string赋值操作

功能描述：

给string字符串进行赋值

赋值的函数原型：

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

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

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

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

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

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

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

示例：

//赋值
void test01()
{
	string str1;
	str1 = "hello world";
	cout << "str1 = " << str1 << endl;

	string str2;
	str2 = str1;
	cout << "str2 = " << str2 << endl;

	string str3;
	str3 = 'a';
	cout << "str3 = " << str3 << endl;

	string str4;
	str4.assign("hello c++");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("hello c++",5);              //前几个个字符
	cout << "str5 = " << str5 << endl;


	string str6;
	str6.assign(str5);  
	cout << "str6 = " << str6 << endl;

	string str7;
	str7.assign(5, 'x');             //连续5个x
	cout << "str7 = " << str7 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

string的赋值方式很多，operator= 这种方式是比较实用的

3.1.4 string字符串拼接

功能描述：

实现在字符串末尾拼接字符串

函数原型：

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

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

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

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

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

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

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

示例：

//字符串拼接
void test01()
{
	string str1 = "我";

	str1 += "爱玩游戏";

	cout << "str1 = " << str1 << endl;
	
	str1 += ':';

	cout << "str1 = " << str1 << endl;

	string str2 = "LOL DNF";

	str1 += str2;

	cout << "str1 = " << str1 << endl;

	string str3 = "I";
	str3.append(" love ");
	str3.append("game abcde", 4);     //new
	//str3.append(str2);
	str3.append(str2, 4, 3); // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾
	cout << "str3 = " << str3 << endl;
}
int main() {

	test01();

	system("pause");

	return 0;
}

总结：字符串拼接的重载版本很多，初学阶段记住几种即可（+=,append）

3.1.5 string查找和替换

功能描述：

查找：查找指定字符串是否存在

替换：在指定的位置替换字符串

函数原型：

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

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

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

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开始查找

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& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s

示例：

//查找和替换
void test01()
{
	//查找
	string str1 = "abcdefgde";

	int pos = str1.find("de");

	if (pos == -1)
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "pos = " << pos << endl;
	}
	

	pos = str1.rfind("de");

	cout << "pos = " << pos << endl;

}

void test02()
{
	//替换
	string str1 = "abcdefgde";
	str1.replace(1, 3, "1111");

	cout << "str1 = " << str1 << endl;
}

int main() {

	//test01();
	//test02();

	system("pause");

	return 0;
}

总结：

find查找是从左往后，rfind从右往左

find找到字符串后返回查找的第一个字符位置，找不到返回-1

replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串

3.1.6 string字符串比较

功能描述：

字符串之间的比较

比较方式：

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

= 返回 0

> 返回 1

< 返回 -1

函数原型：

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

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

示例：

//字符串比较
void test01()
{

	string s1 = "hello";
	string s2 = "aello";

	int ret = s1.compare(s2);

	if (ret == 0) {
		cout << "s1 等于 s2" << endl;
	}
	else if (ret > 0)
	{
		cout << "s1 大于 s2" << endl;
	}
	else
	{
		cout << "s1 小于 s2" << endl;
	}

}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

3.1.7 string字符存取

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

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

char& at(int n); //通过at方法获取字符

示例：

void test01()
{
	string str = "hello world";

	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;


	//字符修改
	str[0] = 'x';
	str.at(1) = 'x';
	cout << str << endl;
	
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：string字符串中单个字符存取有两种方式，利用 [ ] 或 at

3.1.8 string插入和删除

功能描述：

对string字符串进行插入和删除字符操作

函数原型：

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

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

string& insert(int pos, int n, char c); //在指定位置插入n个字符c

string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

示例：

//字符串插入和删除
void test01()
{
	string str = "hello";
	str.insert(1, "111");
	cout << str << endl;

	str.erase(1, 3);  //从1号位置开始3个字符
	cout << str << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：插入和删除的起始下标都是从0开始

3.1.9 string子串

功能描述：

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

函数原型：

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

示例：

//子串
void test01()
{

	string str = "abcdefg";
	string subStr = str.substr(1, 3);
	cout << "subStr = " << subStr << endl;

	string email = "[email protected]";
	int pos = email.find("@");
	string username = email.substr(0, pos);
	cout << "username: " << username << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：灵活的运用求子串功能，可以在实际开发中获取有效的信息

3.2.0总

#include 
#include 

using namespace std;

int main()
{
    string s; // 创建一个空字符串
    // 判断是否为空
    cout << s.empty() << endl;

    // 隐式调用构造函数
    string s1 = "hello";
    cout << s1 << endl;

    // 显示调用构造函数，等同于上面写法
    string s2("world");
    cout << s2 << endl;

    // ==、!=、> < 都是判断编码
    cout << (s1 == s2) << endl; // 0
    cout << (s1 != s2) << endl; // 1
    cout << (s1 > s2) << endl; // 0
    cout << (s1 < s2) << endl; // 1

    // 拷贝构造
    string s3(s2);
    cout << s3 << endl; // 等同于 string s3 = s2;

    // 参数1：char* 字符串
    // 参数2：保留的字符数
    string s4("ABCDEFG",3);
    cout << s4 << endl;

    // 参数1：std::string 原字符串
    // 参数2：不保留的字符串，从头开始
    string s5(s2,3);
    cout << s5 << endl; // ld

    // 参数1：字符数量
    // 参数2：字符内容 char
    string s6(5,'a');
    cout << s6 << endl; //aaaaa

    // 交换
    cout << "原s5 = " << s5 << " " << "原s6 = " << s6 << endl;
    swap(s5,s6);
    cout << "转换后s5 = " << s5 << " " << "转换后s6 = " << s6 << endl;

    // 字符串连接
    string s7 = s5 + s6;
    cout << s7 << endl; // aaaaald

    // 向后追加字符串
    s7.append("jiajia");
    cout << s7 << endl; // aaaaaldjiajia

    // 向后追加单字符
    s7.push_back('s');
    cout << s7 << endl; // aaaaaldjiajias

    // 插入
    // 参数1：插入的位置
    // 参数2：插入的内容
    s7.insert(1,"234");
    cout << s7 << endl; // a234aaaaldjiajias

    // 删除字符串
    // 参数1：起始位置
    // 参数2：删除的字符数量
    s7.erase(2,5);
    cout << s7 << endl; // a2aldjiajias

    // 替换
    // 参数1：起始位置
    // 参数2：被替换的字符数
    // 参数3：替换的新内容
    s7.replace(0,3,"***");
    cout << s7 << endl; // ***ldjiajias

    // 清空
    s7.clear();
    cout << s7.length() << endl; // 0

    string s8 = "hahaha";

    // 重新赋值
    s8 = "ABCDEFGH";
    cout << s8 << endl;

    // 参数1：拷贝的目标
    // 参数2：拷贝的字符数量
    // 参数3：拷贝的起始位置
    char arr[20] = {0};
    s8.copy(arr,6,1);
    cout << arr << endl; // BCDEFG

    // C++string 到C string用到C语言中的strcpy
    // c_str，C++的字符串转换成C语言的字符数组
    // c_str 返回了一个const char *
    char c[20] = {0};
    strcpy(c,s8.c_str());
    cout << c << endl;

    return 0;
}

3.2 array数组（熟悉）

array是C++11新增的容器类型，与传统数组相比更加安全。更加易于使用。array数组是定长的。没有办法方便的伸缩。

#include 
#include 

using namespace std;

int main()
{

    // 创建了一个长度为5的int数组
    array arr = {1,2,3}; // 默认补零
    cout << arr[0] << endl;
    cout << arr[4] << endl;

    cout << arr.at(2) << endl;

    arr[3] = 200;
    // for
    for(int i = 0; i < arr.size(); i++)
    {
        cout << arr[i]<< " ";
    }
    cout << endl;

    // for each
    for(int i :arr)
    {
        cout << i << " " ;
    }
    cout << endl;

    // 迭代器遍历，后边写

    return 0;
}

3.3 vector容器（数组）

1、vector vec; 里面可以是常见的数据类型，也可以是对象、对象指针、或另一个vector容器（嵌套）

2、向量容器（一个 C++ 标准的模板），它与数组十分相似，唯一不同的是，向量在需要扩展大小的时候，会自动处理它自己的存储需求：

3、迭代器：

vertor::iterator v = vec.begin();
while(v != vec.end())
{
    cout << "value of v = " << *v << endl;
    v++;
}

3.3.1 vector基本概念

功能：

vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：

不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

vector容器的迭代器是支持随机访问的迭代器

3.3.2 vector构造函数

功能描述：

创建vector容器

函数原型：

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

vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。

vector(n, elem); //构造函数将n个elem拷贝给本身。

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

示例：

#include 

void printVector(vector& v) {

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);    
	}
	printVector(v1);

	vector v2(v1.begin(), v1.end());
	printVector(v2);

	vector v3(10, 100);    //10个100！！！vector v3(10); 10个0
	printVector(v3);
	
	vector v4(v3);
	printVector(v4);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：vector的多种构造方式没有可比性，灵活使用即可

vector> dp(m, vector(n));

vector> dp(m, vector(n, 0));（和上面一样）

vector> dp(m, vector(n, 1));

3.3.3 vector赋值操作

功能描述：

给vector容器进行赋值（和上一节差不多，这个是声明完在赋值，上一节是直接。）

函数原型：

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

assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。

assign(n, elem); //将n个elem拷贝赋值给本身。

示例：

#include 

void printVector(vector& v) {

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//赋值操作
void test01()
{
	vector v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vectorv2;
	v2 = v1;
	printVector(v2);

	vectorv3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	vectorv4;
	v4.assign(10, 100);
	printVector(v4);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结： vector赋值方式比较简单，使用operator=，或者assign都可以

3.3.4 vector容量和大小

功能描述：

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

函数原型：

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

capacity(); //容器的容量

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

resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。

resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除

resize是对size的操作，和capacity完全无关

示例：

#include 

void printVector(vector& v) {

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	if (v1.empty())
	{
		cout << "v1为空" << endl;
	}
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量 = " << v1.capacity() << endl;
		cout << "v1的大小 = " << v1.size() << endl;
	}

	//resize 重新指定大小 ，若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充
	v1.resize(15,10);
	printVector(v1);

	//resize 重新指定大小 ，若指定的更小，超出部分元素被删除
	v1.resize(5);
	printVector(v1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

判断是否为空 --- empty

返回元素个数 --- size

返回容器容量 --- capacity

重新指定大小 --- resize

3.2.5 vector插入和删除

功能描述：

对vector容器进行插入、删除操作

函数原型：

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

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

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

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

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

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

clear(); //删除容器中所有元素

示例：


#include 

void printVector(vector& v) {

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//插入和删除
void test01()
{
	vector v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	printVector(v1);
	//尾删
	v1.pop_back();
	printVector(v1);
	//插入
	v1.insert(v1.begin(), 100); //指向的前面
	printVector(v1);

	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);

	//删除
	v1.erase(v1.begin());
	printVector(v1);

	//清空
	v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

尾插 --- push_back

尾删 --- pop_back

插入 --- insert (位置迭代器)

删除 --- erase （位置迭代器）

清空 --- clear

3.3.6 vector数据存取

功能描述：

对vector中的数据的存取操作

函数原型：

at(int idx); //返回索引idx所指的数据

operator[]; //返回索引idx所指的数据

front(); //返回容器中第一个数据元素

back(); //返回容器中最后一个数据元素

示例：

#include 

void test01()
{
	vectorv1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " ";
	}
	cout << endl;

	cout << "v1的第一个元素为： " << v1.front() << endl;
	cout << "v1的最后一个元素为： " << v1.back() << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

除了用迭代器获取vector容器中元素，[ ]和at也可以

front返回容器第一个元素

back返回容器最后一个元素

3.3.7 vector互换容器

功能描述：

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

函数原型：

swap(vec); // 将vec与本身的元素互换

示例：

#include 

void printVector(vector& v) {
    
    for (vector::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vectorv1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    printVector(v1);
    
    vectorv2;
    for (int i = 10; i > 0; i--)
    {
        v2.push_back(i);
    }
    printVector(v2);
    
    //互换容器
    cout << "互换后" << endl;
    v1.swap(v2);
    printVector(v1);
    printVector(v2);
}

void test02()
{
    vector v;
    for (int i = 0; i < 100000; i++) {
        v.push_back(i);
    }
    
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
    
    v.resize(3);
    
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
    
    //收缩内存
    vector(v).swap(v); //匿名对象
    
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
}

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

vector(v)是匿名对象，类似拷贝构造函数，但是这个时候v的capacity变成和size大小相同，这是（v）在和v swap就好了，而且（v）这个匿名空间在编译之后会被回收，不用我们管，就留下了v

总结：swap可以使两个容器互换，可以达到实用的收缩内存效果

3.3.8 vector预留空间

功能描述：

减少vector在动态扩展容量时的扩展次数（如果不reserve，全部动态内存，那么可能需要扩容的次数大）

函数原型：

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

示例：

#include 

void test01()
{
    vector v;
    
    //预留空间
    v.reserve(100000);          //capacity    如果预知自己会需要100000空间
    
    int num = 0;
    int* p = NULL;
    for (int i = 0; i < 100000; i++) {
        v.push_back(i);
        if (p != &v[0]) {
            p = &v[0];
            num++;
        }
    }
    
    cout << "num:" << num << endl;
}

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

总结：如果数据量较大，可以一开始利用reserve预留空间

3.3.9 总

#include 
#include 

using namespace std;

int main()
{
//    vector v = {1,2,3};
//    for(int i :v)
//    {
//        cout << i << endl;
//    }
    // 创建一个长度为5的int向量
    vector vec(5);
    vec[0] = 1;
    vec[1] = 2;
    vec[2] = 3;
    vec[3] = 4;
    vec.at(4) = 5;

    cout <<"size =" <

 
   
   
   
   
   
   
   
   
   
  3.4 deque容器 
   
   
   
   
   
  3.4.1 deque容器基本概念 
   
  功能： 
   
   
   双端队列，可以对头端和尾端进行插入删除操作 
   
   
  deque与vector区别： 
   
   
   vector对于头部的插入删除效率低，数据量越大，效率越低（都往后移动，头插法） 
   
   
   deque相对而言，对头部的插入删除速度回比vector快 
   
   
   vector访问元素时的速度会比deque快,这和两者内部实现有关（不同的缓冲区，每一个都需要根据中控器记录的地址来找） 
   
   
   
   
   
  deque内部工作原理: 
   
  deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据 
   
  中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间 
   
   
   
   
   
   deque容器的迭代器也是支持随机访问的（可以跳跃） 
   
   
  3.4.2 deque构造函数 
   
  功能描述： 
   
   
   deque容器构造 
   
   
  函数原型： 
   
   
   deque deqT;                      //默认构造形式 
   
   
   deque(beg, end);                  //构造函数将[beg, end)区间中的元素拷贝给本身。 
   
   
   deque(n, elem);                    //构造函数将n个elem拷贝给本身。 
   
   
   deque(const deque &deq);   //拷贝构造函数 
   
   
  示例： 
   
  #include 

void printDeque(const deque& d) 
{
	for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//deque构造
void test01() {

	deque d1; //无参构造函数
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	deque d2(d1.begin(),d1.end());
	printDeque(d2);

	dequed3(10,100);
	printDeque(d3);

	dequed4 = d3;
	printDeque(d4);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：deque容器和vector容器的构造方式几乎一致，灵活使用即可 
   
  3.4.3 deque赋值操作 
   
  功能描述： 
   
   
   给deque容器进行赋值 
   
   
  函数原型： 
   
   
   deque& operator=(const deque &deq);         //重载等号操作符 
   
   
   assign(beg, end);                                           //将[beg, end)区间中的数据拷贝赋值给本身。 
   
   
   assign(n, elem);                                             //将n个elem拷贝赋值给本身。 
   
   
  示例： 
   
  #include 

void printDeque(const deque& d) 
{
	for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//赋值操作
void test01()
{
	deque d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	dequed2;
	d2 = d1;
	printDeque(d2);

	dequed3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	dequed4;
	d4.assign(10, 100);
	printDeque(d4);

}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：deque赋值操作也与vector相同，需熟练掌握 
   
  3.4.4 deque大小操作 
   
  功能描述： 
   
   
   对deque容器的大小进行操作 
   
   
  函数原型： 
   
   
   deque.empty();                       //判断容器是否为空 
   
   
   deque.size();                         //返回容器中元素的个数 
   
   
   deque.resize(num);                //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
                             //如果容器变短，则末尾超出容器长度的元素被删除。 
   
   
   deque.resize(num, elem);     //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
                                                     //如果容器变短，则末尾超出容器长度的元素被删除。 
   
   
  示例： 
   
  #include 

void printDeque(const deque& d) 
{
	for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

//大小操作
void test01()
{
	deque d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	//判断容器是否为空
	if (d1.empty()) {
		cout << "d1为空!" << endl;
	}
	else {
		cout << "d1不为空!" << endl;
		//统计大小
		cout << "d1的大小为：" << d1.size() << endl;
	}

	//重新指定大小
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   deque没有容量的概念（可以无限） 
   
   
   判断是否为空   --- empty 
   
   
   返回元素个数   --- size 
   
   
   重新指定个数   --- resize 
   
   
  3.4.5 deque 插入和删除 
   
  功能描述： 
   
   
   向deque容器中插入和删除数据 
   
   
  函数原型： 
   
  两端插入操作： 
   
   
   push_back(elem);          //在容器尾部添加一个数据 
   
   
   push_front(elem);        //在容器头部插入一个数据 
   
   
   pop_back();                   //删除容器最后一个数据 
   
   
   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位置的数据，返回下一个数据的位置。
   
   
   
  示例： 
   
  #include 

void printDeque(const deque& d) 
{
    for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
        cout << *it << " ";
        
    }
    cout << endl;
}
//两端操作
void test01()
{
    deque d;
    //尾插
    d.push_back(10);
    d.push_back(20);
    //头插
    d.push_front(100);
    d.push_front(200);
    
    printDeque(d);
    
    //尾删
    d.pop_back();
    //头删
    d.pop_front();
    printDeque(d);
}

//插入
void test02()
{
    deque d;
    d.push_back(10);
    d.push_back(20);
    d.push_front(100);
    d.push_front(200);
    printDeque(d);
    
    d.insert(d.begin(), 1000);
    printDeque(d);
    
    d.insert(d.begin(), 2,10000);
    printDeque(d);
    
    dequed2;
    d2.push_back(1);
    d2.push_back(2);
    d2.push_back(3);
    
    d.insert(d.begin(), d2.begin(), d2.end());
    printDeque(d);
    
}

//删除
void test03()
{
    deque d;
    d.push_back(10);
    d.push_back(20);
    d.push_front(100);
    d.push_front(200);
    printDeque(d);
    
    d.erase(d.begin());
    printDeque(d);
    
    d.erase(d.begin(), d.end());
    d.clear();
    printDeque(d);
}

int main() {
    
    //test01();
    
    //test02();
    
    test03();
    
    system("pause");
    
    return 0;
} 
   
  总结： 
   
   
   插入和删除提供的位置是迭代器！ 
   
   
   尾插   ---  push_back 
   
   
   尾删   ---  pop_back 
   
   
   头插   ---  push_front 
   
   
   头删   ---  pop_front 
   
   
  3.4.6 deque 数据存取 
   
  功能描述： 
   
   
   对deque 中的数据的存取操作 
   
   
  函数原型： 
   
   
   at(int idx);     //返回索引idx所指的数据 
   
   
   operator[];      //返回索引idx所指的数据 
   
   
   front();            //返回容器中第一个数据元素 
   
   
   back();              //返回容器中最后一个数据元素 
   
   
  示例： 
   
  #include 

void printDeque(const deque& d) 
{
	for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

//数据存取
void test01()
{

	deque d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	for (int i = 0; i < d.size(); i++) {        #
		cout << d[i] << " ";
	}
	cout << endl;


	for (int i = 0; i < d.size(); i++) {
		cout << d.at(i) << " ";
	}
	cout << endl;

	cout << "front:" << d.front() << endl;

	cout << "back:" << d.back() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   除了用迭代器获取deque容器中元素，[ ]和at也可以 
   
   
   front返回容器第一个元素 
   
   
   back返回容器最后一个元素 
   
   
  3.4.7  deque 排序 
   
  功能描述： 
   
   
   利用算法实现对deque容器进行排序 
   
   
  算法： 
   
   
   sort(iterator beg, iterator end)  //对beg和end区间内元素进行排序 
   
   
  示例： 
   
  #include 
#include 

void printDeque(const deque& d) 
{
	for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

void test01()
{

	deque d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	printDeque(d);
	sort(d.begin(), d.end());
	printDeque(d);

}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：sort算法非常实用，使用时包含头文件 algorithm即可 
   
  3.4.5 总 
  #include 
#include 

using namespace std;

int main()
{
//    deque v = {1,2,3};
//    for(int i :v)
//    {
//        cout << i << endl;
//    }
    // 创建一个长度为5的int向量
    deque deq(5);
    deq[0] = 1;
    deq[1] = 2;
    deq[2] = 3;
    deq[3] = 4;
    deq.at(4) = 5;

    cout <<"size =" <
 
   
  3.5 stack容器（下面的几个不能随机访问，不能遍历，不能用全局函数） 
   
   
   
   
  3.5.1 stack 基本概念 
   
   
  不许遍历(vector可以遍历) 
  empty（有没有push过就知道了） 
  size（push的时候记录） 
   
   
   
   
  概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口 
   
   
   
   
  栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为 
   
  栈中进入数据称为  --- 入栈  push 
   
  栈中弹出数据称为  --- 出栈  pop 
   
   
  3.5.2 stack 常用接口 
   
  功能描述：栈容器常用的对外接口 
   
  构造函数： 
   
   
   stack stk;                                 //stack采用模板类实现， stack对象的默认构造形式 
   
   
   stack(const stack &stk);            //拷贝构造函数 
   
   
  赋值操作： 
   
   
   stack& operator=(const stack &stk);           //重载等号操作符 
   
   
  数据存取： 
   
   
   push(elem);      //向栈顶添加元素 
   
   
   pop();                //从栈顶移除第一个元素 
   
   
   top();                //返回栈顶元素 
   
   
  大小操作： 
   
   
   empty();            //判断堆栈是否为空 
   
   
   size();              //返回栈的大小 
   
   
  示例： 
   
  #include 

//栈容器常用接口
void test01()
{
	//创建栈容器 栈容器必须符合先进后出
	stack s;

	//向栈中添加元素，叫做 压栈 入栈
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) {
		//输出栈顶元素
		cout << "栈顶元素为： " << s.top() << endl;
		//弹出栈顶元素
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   入栈   --- push 
   
   
   出栈   --- pop 
   
   
   返回栈顶   --- top 
   
   
   判断栈是否为空   --- empty 
   
   
   返回栈大小   --- size 
   
   
  3.6 queue 容器（队列） 
   
   
  3.6.1 queue 基本概念 
  元素优先级排序的功能 
   
  概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口 
   
   
   
   
  队列容器允许从一端新增元素，从另一端移除元素（区别于deque，deque可以头和尾都可以拿数据和出数据） 
   
  队列通常有个方向 
   
  队列中只有队头和队尾才可以被外界使用（看到），因此队列不允许有遍历行为 : []和at 
   
  队列中进数据称为 --- 入队    push 
   
  队列中出数据称为 --- 出队    pop 
   
   
  3.6.2 queue 常用接口 
   
  功能描述：栈容器常用的对外接口 
   
  构造函数： 
   
   
   queue que;                                 //queue采用模板类实现，queue对象的默认构造形式 
   
   
   queue(const queue &que);            //拷贝构造函数 
   
   
  赋值操作： 
   
   
   queue& operator=(const queue &que);           //重载等号操作符 
   
   
  数据存取： 
   
   
   push(elem);                             //往队尾添加元素 
   
   
   pop();                                      //从队头移除第一个元素 
   
   
   back();                                    //返回最后一个元素 
   
   
   front();                                  //返回第一个元素 
   
   
  大小操作： 
   
   
   empty();            //判断堆栈是否为空 
   
   
   size();              //返回栈的大小 
   
   
  示例： 
   
  #include 
#include 
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void test01() {

	//创建队列
	queue q;

	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);

	//向队列中添加元素  入队操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//队列不提供迭代器，更不支持随机访问	
	while (!q.empty()) {
		//输出队头元素
		cout << "队头元素-- 姓名： " << q.front().m_Name 
              << " 年龄： "<< q.front().m_Age << endl;
        
		cout << "队尾元素-- 姓名： " << q.back().m_Name  
              << " 年龄： " << q.back().m_Age << endl;
        
		cout << endl;
		//弹出队头元素
		q.pop();
	}

	cout << "队列大小为：" << q.size() << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   入队   --- push 
   
   
   出队   --- pop 
   
   
   返回队头元素   --- front 
   
   
   返回队尾元素   --- back 
   
   
   判断队是否为空   --- empty 
   
   
   返回队列大小   --- size 
   
   
  3.7 list容器（双向链表） 
   
  （和vector这样的数组的区别是list里面地址是非连续） 
  list内部由双向循环链表实现，内存空间不连续。不支持下标。可以高效的删除和添加操作。不适合随机改、查。 
   
   
  3.7.1 list基本概念 
   
  功能：将数据进行链式存储 
   
  链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 
   
  链表的组成：链表由一系列结点组成(头尾结点) 
   
  结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 
   
  STL中的链表是一个双向循环链表 
   
   
  由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器 
   
  list的优点：（相比于vector数组） 
   
   
   采用动态存储分配，不会造成内存浪费和溢出（这个和deque类似） 
   
   
   链表执行插入和删除操作十分方便，修改指针即可，可以对任意位置进行快速的插入和删除元素，不需要移动大量元素 
   
   
  list的缺点： 
   
   
   链表灵活，但是空间(多了一个指针域) 和 时间（遍历和deque一样，通过指针寻找时间慢）额外耗费较大 
   
  List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。 
   
   
   
   
  总结：STL中List和vector是两个最常被使用的容器，各有优缺点 
   
   
  3.7.2  list构造函数 
   
  功能描述： 
   
   
   创建list容器 
   
   
  函数原型： 
   
   
   list lst;                               //list采用采用模板类实现,对象的默认构造形式： 
   
   
   list(beg,end);                           //构造函数将[beg, end)区间中的元素拷贝给本身。 
   
   
   list(n,elem);                             //构造函数将n个elem拷贝给本身。 
   
   
   list(const list &lst);            //拷贝构造函数。 
   
   
  示例： 
   
  #include 

void printList(const list& L) {

	for (list::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	listL1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	listL2(L1.begin(),L1.end());
	printList(L2);

	listL3(L2);
	printList(L3);

	listL4(10, 1000);
	printList(L4);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：list构造方式同其他几个STL常用容器，熟练掌握即可 
   
  3.7.3 list 赋值和交换 
   
  功能描述： 
   
   
   给list容器进行赋值，以及交换list容器 
   
   
  函数原型： 
   
   
   assign(beg, end);            //将[beg, end)区间中的数据拷贝赋值给本身。 
   
   
   assign(n, elem);              //将n个elem拷贝赋值给本身。 
   
   
   list& operator=(const list &lst);         //重载等号操作符 
   
   
   swap(lst);                         //将lst与本身的元素互换。 
   
   
  示例： 
   
  #include 

void printList(const list& L) {

	for (list::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//赋值和交换
void test01()
{
	listL1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);

	//赋值
	listL2;
	L2 = L1;
	printList(L2);

	listL3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);

	listL4;
	L4.assign(10, 100);
	printList(L4);

}

//交换
void test02()
{

	listL1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	listL2;
	L2.assign(10, 100);

	cout << "交换前： " << endl;
	printList(L1);
	printList(L2);

	cout << endl;

	L1.swap(L2);

	cout << "交换后： " << endl;
	printList(L1);
	printList(L2);

}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
} 
   
  总结：list赋值和交换操作能够灵活运用即可 
   
  3.7.4 list 大小操作 
   
  功能描述： 
   
   
   对list容器的大小进行操作 
   
   
  函数原型： 
   
   
   size();                             //返回容器中元素的个数 
   
   
   empty();                           //判断容器是否为空 
   
   
   resize(num);                   //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
    //如果容器变短，则末尾超出容器长度的元素被删除。 
   
   
   resize(num, elem);       //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。 
   
   
   
   
  示例： 
   
  #include 

void printList(const list& L) {

	for (list::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//大小操作
void test01()
{
	listL1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	if (L1.empty())
	{
		cout << "L1为空" << endl;
	}
	else
	{
		cout << "L1不为空" << endl;
		cout << "L1的大小为： " << L1.size() << endl;
	}

	//重新指定大小
	L1.resize(10);
	printList(L1);

	L1.resize(2);
	printList(L1);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   判断是否为空   --- empty 
   
   
   返回元素个数   --- size 
   
   
   重新指定个数   --- resize 
   
   
  3.7.5 list 插入和删除 
   
  功能描述： 
   
   
   对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值匹配的元素。（上面都是需要迭代器，这个链表不需要迭代器） 
   
   
  示例： 
   
  #include 

void printList(const list& L) {

	for (list::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//插入和删除
void test01()
{
	list L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);

	printList(L);

	//尾删
	L.pop_back();
	printList(L);

	//头删
	L.pop_front();
	printList(L);

	//插入
	list::iterator it = L.begin();
	L.insert(++it, 1000);
	printList(L);

	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);

	//移除
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	printList(L);
	L.remove(10000);
	printList(L);
    
    //清空
	L.clear();
	printList(L);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   尾插   --- push_back 
   
   
   尾删   --- pop_back 
   
   
   头插   --- push_front 
   
   
   头删   --- pop_front 
   
   
   插入   --- insert 
   
   
   删除   --- erase 
   
   
   移除   --- remove 
   
   
   清空   --- clear 
   
   
  3.7.6 list 数据存取 
   
  功能描述： 
   
   
   对list容器中数据进行存取 
   
   
  函数原型： 
   
   
   front();        //返回第一个元素。 
   
   
   back();         //返回最后一个元素。 
   
   
  示例： 
   
  #include 

//数据存取
void test01()
{
	listL1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	
	//cout << L1.at(0) << endl;//错误 不支持at访问数据
	//cout << L1[0] << endl; //错误  不支持[]方式访问数据
	cout << "第一个元素为： " << L1.front() << endl;
	cout << "最后一个元素为： " << L1.back() << endl;

	//list容器的迭代器是双向迭代器，不支持随机访问
	list::iterator it = L1.begin();
	//it = it + 1;//错误，不可以跳跃访问，即使是+1
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   list容器中不可以通过[]或者at方式访问数据 
   
   
   返回第一个元素   --- front 
   
   
   返回最后一个元素   --- back 
   
   
  3.7.7 list 反转和排序 
   
  功能描述： 
   
   
   将容器中的元素反转，以及将容器中的数据进行排序 
   
   
  函数原型： 
   
   
   reverse();   //反转链表 
   
   
   sort();        //链表排序，和deque不同，deque是可以随机访问，可以sort（d.begin(),d.end()），而这里不能用全局函数（头文件里面的），只能用成员函数，所以说L.sort()【注：不支持随机访问的容器里会提供相应的 成员函数】 
   
   
  L.sort(myCompare); //指定规则，从大到小（仿函数）（记住，暂时不需要深究仿函数） 
   
  示例： 
   
  void printList(const list& L) {

	for (list::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

bool myCompare(int val1 , int val2)
{
	return val1 > val2;
}

//反转和排序
void test01()
{
	list L;
	L.push_back(90);
	L.push_back(30);
	L.push_back(20);
	L.push_back(70);
	printList(L);

	//反转容器的元素
	L.reverse();
	printList(L);

	//排序
	L.sort(); //默认的排序规则 从小到大    ！！！！！这里用sort(L.begin(),L.end())不可以
	printList(L);

	L.sort(myCompare); //指定规则，从大到小      ！！！！制定规则，仿函数 
	printList(L);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   反转   --- reverse 
   
   
   排序   --- sort （成员函数） 
   
   
  3.7.8 排序案例 
   
  案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高 
   
  排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序 
   
  示例： 
   
  #include 
#include 
class Person {
    public:
    Person(string name, int age , int height) {
        m_Name = name;
        m_Age = age;
        m_Height = height;
    }
    
    public:
    string m_Name;  //姓名
    int m_Age;      //年龄
    int m_Height;   //身高
};


bool ComparePerson(Person& p1, Person& p2) {
    
    if (p1.m_Age == p2.m_Age) {
        return p1.m_Height  > p2.m_Height;
    }
    else
    {
        return  p1.m_Age < p2.m_Age;
    }
    
}

void test01() {
    
    list L;
    
    Person p1("刘备", 35 , 175);
    Person p2("曹操", 45 , 180);
    Person p3("孙权", 40 , 170);
    Person p4("赵云", 25 , 190);
    Person p5("张飞", 35 , 160);
    Person p6("关羽", 35 , 200);
    
    L.push_back(p1);
    L.push_back(p2);
    L.push_back(p3);
    L.push_back(p4);
    L.push_back(p5);
    L.push_back(p6);
    
    for (list::iterator it = L.begin(); it != L.end(); it++) {
        cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age 
            << " 身高： " << it->m_Height << endl;
    }
    
    cout << "---------------------------------" << endl;
    L.sort(ComparePerson); //排序
    
    for (list::iterator it = L.begin(); it != L.end(); it++) {
        cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age 
            << " 身高： " << it->m_Height << endl;
    }
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结： 
   
   
   对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序 
   
   
   高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂 
   
   
  3.7.9 总 
  #include 
#include 

using namespace std;

int main()
{
    // 创建一个默认无数值的list
    list lis1;

    // 创建一个长度为2的列表，第一个元素是hello，第二个元素是world
//    list lis2{"hello","world"};

//    for(string s:lis2)
//    {
//        cout << s << endl;
//    }
    // 创建一个长度为5的列表，每个元素都是“hello”
    listlis(5,"hello");

    // 增，向后追加元素
    lis.push_back("world");
    lis.push_front("hahaha"); // 向前追加单元素
    lis.insert(++lis.begin(),"222"); // 在第二个位置插入“222”

    // 删除
//    lis.pop_back(); // 删除最后 元素
    lis.pop_front(); // 删除第一个元素

    // 保存迭代器指针
    list::iterator iter = lis.begin();
    advance(iter,1); // 移动迭代器指针到固定位置
    lis.insert(iter,"333");

    iter = lis.end();
//    iter--;
//    lis.erase(iter);
//    advance(iter,-1);
//    lis.erase(iter);

//    iter = lis.end();
//    lis.erase(iter);

    // 返回第一个元素的引用
//    cout << lis.front() << endl;
    // 返回最后一个元素的引用
//    cout << lis.back() << endl;

    // 更改
    iter = lis.begin();
    advance(iter,2);
    *iter = "666";

    cout << "---" << *iter << endl;


    for(string s:lis)
    {
        cout << s << endl;
    }

    // 清空
    lis.clear();
    cout << lis.size() << endl;

    // 迭代器循环，后边写

    return 0;
}
 
   
  3.8 set/ multiset 容器 
   
   
  这个和下面的map： 
   
   erase可以相当于上面list的remove直接去掉某个值得元素 
   自动排序 
   需要用insert插入数据 
   如果遍历需要for那种。目前不知道是否可以用for_each 
   
   
   
   
   
   
  3.8.1 set基本概念 
   
  简介： 
   
   
   所有元素都会在插入时自动被排序 
   
   
  本质： 
   
   
   set/multiset属于关联式容器，底层结构是用二叉树实现。 
   
   
  set和multiset区别： 
   
   
   set不允许容器中有重复的元素 
   
   
   multiset允许容器中有重复的元素（二者都会自动排序） 
   
   
  3.8.2 set构造和赋值 
   
  功能描述：创建set容器以及赋值 
   
  构造： 
   
   
   set st;                        //默认构造函数： 
   
   
   set(const set &st);       //拷贝构造函数 
   
   
  赋值： 
   
   
   set& operator=(const set &st);    //重载等号操作符 
   
   
  示例： 
   
  #include 

void printSet(set & s)
{
	for (set::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//构造和赋值
void test01()
{
	set s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);

	//拷贝构造
	sets2(s1);
	printSet(s2);

	//赋值
	sets3;
	s3 = s2;
	printSet(s3);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   set容器插入数据时用insert 
   
   
   set容器插入数据的数据会自动排序 
   
   
  3.8.3 set大小和交换 
   
  功能描述： 
   
   
   统计set容器大小以及交换set容器 
   
   
  函数原型： 
   
   
   size();          //返回容器中元素的数目 
   
   
   empty();        //判断容器是否为空 
   
   
   swap(st);      //交换两个集合容器 
   
   
  示例： 
   
  #include 

void printSet(set & s)
{
	for (set::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//大小
void test01()
{

	set s1;
	
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	if (s1.empty())
	{
		cout << "s1为空" << endl;
	}
	else
	{
		cout << "s1不为空" << endl;
		cout << "s1的大小为： " << s1.size() << endl;
	}

}

//交换
void test02()
{
	set s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set s2;

	s2.insert(100);
	s2.insert(300);
	s2.insert(200);
	s2.insert(400);

	cout << "交换前" << endl;
	printSet(s1);
	printSet(s2);
	cout << endl;

	cout << "交换后" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   统计大小   --- size 
   
   
   判断是否为空   --- empty 
   
   
   交换容器   --- swap 
   
   
  3.8.4 set插入和删除 
   
  功能描述： 
   
   
   set容器进行插入数据和删除数据 
   
   
  函数原型： 
   
   
   insert(elem);           //在容器中插入元素。 
   
   
   clear();                    //清除所有元素 
   
   
   erase(pos);              //删除pos迭代器所指的元素，返回下一个元素的迭代器。 
   
   
   erase(beg, end);    //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。 
   
   
   erase(elem);            //删除容器中值为elem的元素。 
   
   
  示例： 
   
  #include 

void printSet(set & s)
{
	for (set::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//插入和删除
void test01()
{
	set s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);

	//删除
	s1.erase(s1.begin());
	printSet(s1);

	s1.erase(30);
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   插入   --- insert 
   
   
   删除   --- erase 
   
   
   清空   --- clear 
   
   
  3.8.5 set查找和统计 
   
  功能描述： 
   
   
   对set容器进行查找数据以及统计数据 
   
   
  函数原型： 
   
   
   find(key);                  //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end(); 
   
   
   count(key);                //统计key的元素个数 
   
   
  示例： 
   
  #include 

//查找和统计
void test01()
{
	set s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	
	//查找
	set::iterator pos = s1.find(30);   需要用迭代器去接受

	if (pos != s1.end())                 如果有“有没有可能查的那个正好在最后”这个疑问，需要注意
                                         end其实指向的最后一个元素的下一个。
	{
		cout << "找到了元素 ： " << *pos << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	//统计
	int num = s1.count(30);
	cout << "num = " << num << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   查找   ---  find    （返回的是迭代器） 
   
   
   统计   ---  count  （对于set，结果为0或者1） 
   
   
  3.8.6 set和multiset区别 
   
  学习目标： 
   
   
   掌握set和multiset的区别 
   
   
  区别： 
   
   
   set不可以插入重复数据，而multiset可以 
   
   
   set插入数据的同时会返回插入结果，表示插入是否成功 
   
   
   multiset不会检测数据，因此可以插入重复数据 
   
   
  示例： 
   
  #include 

//set和multiset区别
void test01()
{
	set s;
	pair::iterator, bool>  ret = s.insert(10);
	if (ret.second) {
		cout << "第一次插入成功!" << endl;
	}
	else {
		cout << "第一次插入失败!" << endl;
	}

	ret = s.insert(10);       ret的second其实就是true或false
	if (ret.second) {
		cout << "第二次插入成功!" << endl;
	}
	else {
		cout << "第二次插入失败!" << endl;
	}
    
	//multiset
	multiset ms;
	ms.insert(10);
	ms.insert(10);

	for (multiset::iterator it = ms.begin(); it != ms.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   如果不允许插入重复数据可以利用set 
   
   
   如果需要插入重复数据利用multiset 
   
   
  3.8.7 pair对组创建 
   
  功能描述： 
   
   
   成对出现的数据，利用对组可以返回return两个数据 
   不需头文件 
   
   
   
  2种创建方式： 
   
   
   pair p ( value1, value2 ); 
   
   
   pair p = make_pair( value1, value2 ); 
   
   
  p.first 
  p.second 
   
  示例： 
   
  #include 

//对组创建
void test01()
{
	pair p(string("Tom"), 20);
	cout << "姓名： " <<  p.first << " 年龄： " << p.second << endl;

	pair p2 = make_pair("Jerry", 10);
	cout << "姓名： " << p2.first << " 年龄： " << p2.second << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
  两种方式都可以创建对组，记住一种即可 
   
  3.8.8 set容器排序 
   
  学习目标： 
   
   
   set容器默认排序规则为从小到大，掌握如何改变排序规则 
   
   
  主要技术点： 
   
   
   利用仿函数，可以改变排序规则 
   
   
  示例一   set存放内置数据类型时的排序（set里面是int） 
   
  #include 

class MyCompare 
{
    public:
    bool operator()(int v1, int v2) {
        return v1 > v2;
    }
};
void test01() 
{    
    set s1;
    s1.insert(10);
    s1.insert(40);
    s1.insert(20);
    s1.insert(30);
    s1.insert(50);
    
    //默认从小到大
    for (set::iterator it = s1.begin(); it != s1.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    //指定排序规则
    set s2;     //注意插入之前需要指定好，因为insert之后无法改变了。
    s2.insert(10);
    s2.insert(40);
    s2.insert(20);
    s2.insert(30);
    s2.insert(50);
    
    for (set::iterator it = s2.begin(); it != s2.end(); it++) {
        cout << *it << " ";            
    }                              
    cout << endl;
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结：利用仿函数可以指定set容器的排序规则，//这里遍历的时候用Mycompare，前面list是sort里用Mycompare 
   
  示例二  set存放自定义数据类型时的排序（set里面是对象） 
   
  #include 
#include 

class Person
{
    public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    
    string m_Name;
    int m_Age;
    
};
class comparePerson
{
    public:
    bool operator()(const Person& p1, const Person &p2)
    {
        //按照年龄进行排序  降序
        return p1.m_Age > p2.m_Age;
    }
};

void test01()
{
    set s; 
    
    Person p1("刘备", 23);
    Person p2("关羽", 27);
    Person p3("张飞", 25);
    Person p4("赵云", 21);
    
    s.insert(p1);    //difference
    s.insert(p2);
    s.insert(p3);
    s.insert(p4);
    
    for (set::iterator it = s.begin(); it != s.end(); it++)
    {
        cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << endl;
    }
}
int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结： 
   
  对于自定义数据类型，set必须指定排序规则才可以插入数据，也就是说如果不是类似int和double的，例如是对象或对象的指针，set的自动排序的功能不会发挥作用，而是必须要指定一个顺序。 
   
  3.9 map/ multimap容器 
   
   
   
   
  3.9.1 map基本概念 
   
  简介： 
   
   
   map中所有元素都是pair 
   
   
   pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值） 
   
   
   所有元素都会根据元素的键值自动排序 
   
   
  本质： 
   
   
   map/multimap属于关联式容器，底层结构是用二叉树实现。 
   
   
  优点： 
   
   
   可以根据key值快速找到value值 
   
   
  map和multimap区别： 
   
   
   map不允许容器中有重复key值元素 
   
   
   multimap允许容器中有重复key值元素（也会自动排序） 
   
   
  3.9.2  map构造和赋值 
   
  功能描述： 
   
   
   对map容器进行构造和赋值操作 
   
   
  函数原型： 
   
  构造： 
   
   
   map mp;                     //map默认构造函数: 
   
   
   map(const map &mp);             //拷贝构造函数 
   
   
  赋值： 
   
   
   map& operator=(const map &mp);    //重载等号操作符 
   
   
  示例： 
   
  #include 

void printMap(map&m)
{
	for (map::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	mapm; //默认构造
	m.insert(pair(1, 10));
	m.insert(pair(2, 20));
	m.insert(pair(3, 30));
	printMap(m);

	mapm2(m); //拷贝构造
	printMap(m2);

	mapm3;
	m3 = m2; //赋值
	printMap(m3);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：map中所有元素都是成对出现，插入数据时候要使用对组pair（pair不需要头文件） 
   
  3.9.3 map大小和交换 
   
  功能描述： 
   
   
   统计map容器大小以及交换map容器 
   
   
  函数原型： 
   
   
   size();          //返回容器中元素的数目 
   
   
   empty();        //判断容器是否为空 
   
   
   swap(st);      //交换两个集合容器 
   
   
  示例： 
   
  #include 

void printMap(map&m)
{
	for (map::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	mapm;
	m.insert(pair(1, 10));
	m.insert(pair(2, 20));
	m.insert(pair(3, 30));

	if (m.empty())
	{
		cout << "m为空" << endl;
	}
	else
	{
		cout << "m不为空" << endl;
		cout << "m的大小为： " << m.size() << endl;
	}
}


//交换
void test02()
{
	mapm;
	m.insert(pair(1, 10));
	m.insert(pair(2, 20));
	m.insert(pair(3, 30));

	mapm2;
	m2.insert(pair(4, 100));
	m2.insert(pair(5, 200));
	m2.insert(pair(6, 300));

	cout << "交换前" << endl;
	printMap(m);
	printMap(m2);

	cout << "交换后" << endl;
	m.swap(m2);
	printMap(m);
	printMap(m2);
}

int main() {

	test01();

	test02();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   统计大小   --- size 
   
   
   判断是否为空   --- empty 
   
   
   交换容器   --- swap 
   
   
  3.9.4 map插入和删除 
   
  功能描述： 
   
   
   map容器进行插入数据和删除数据 
   
   
  函数原型： 
   
   
   insert(elem);           //在容器中插入元素。 
   
   
   clear();                    //清除所有元素 
   
   
   erase(pos);              //删除pos迭代器所指的元素，返回下一个元素的迭代器。 
   
   
   erase(beg, end);    //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。 
   
   
   erase(key);            //删除容器中值为key的元素。 
   
   
  示例： 
   
  #include 

void printMap(map&m)
{
	for (map::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	//插入
	map m;
	//第一种插入方式
	m.insert(pair(1, 10));
	//第二种插入方式
	m.insert(make_pair(2, 20));
	//第三种插入方式
	m.insert(map::value_type(3, 30));
	//第四种插入方式
	m[4] = 40; 
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);
	printMap(m);

	//清空
	m.erase(m.begin(),m.end());
	m.clear();
	printMap(m);
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   map插入方式很多，记住其一即可 
   
   
   
   插入   --- insert 
   
   
   删除   --- erase 
   
   
   清空   --- clear 
   
   
  3.9.5 map查找和统计 
   
  功能描述： 
   
   
   对map容器进行查找数据以及统计数据 
   
   
  函数原型： 
   
   
   find(key);                  //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end(); 
   
   
   count(key);                //统计key的元素个数 
   
   
  示例： 
   
  #include 

//查找和统计
void test01()
{
	mapm; 
	m.insert(pair(1, 10));
	m.insert(pair(2, 20));
	m.insert(pair(3, 30));

	//查找
	map::iterator pos = m.find(3);

	if (pos != m.end())
	{
		cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	//统计
	int num = m.count(3);
	cout << "num = " << num << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   查找   ---  find    （返回的是迭代器） 
   
   
   统计   ---  count  （对于map，结果为0或者1） 
   
   
  3.9.6 map容器排序 
   
  学习目标： 
   
   
   map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则 
   
   
  主要技术点: 
   
   
   利用仿函数，可以改变排序规则 
   
   
  示例： 
   
  #include 

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

void test01() 
{
	//默认从小到大排序
	//利用仿函数实现从大到小排序
	map m;

	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

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

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   利用仿函数可以指定map容器的排序规则 
   
   
   对于自定义数据类型，map必须要指定排序规则,同set容器 
   
   
  3.9.7 总 
  #include 
#include 

using namespace std;

int main()
{
    mapma1 = {{"年龄:",23},{"身高:",150}};
    cout << ma1.size() << endl; // 2

    // 创建一个元素为0的键值对对象
    mapma;
    cout << ma.size() << endl;

    // 插入
    ma["身高"]  = 150;
    ma.insert(pair("年龄",23)); // 插入元素

    cout << ma["年龄"] << endl;


    // 改
    ma["身高"] = 180;
    cout << ma["身高"] << endl;
    // 删除
    //    int re = ma.erase("身高"); // 删除返回值，1删除成功，0失败
    //    cout << re << endl;

    if(ma.find("身高") == ma.end()) // find从头开始查找，如果没找到就会返回end()
    {
        cout << "没有找到身高元素" << endl;
    }
    else
    {
        cout << ma["身高"] << endl;
    }
    int re = ma.erase("月薪"); // 删除返回值，1删除成功，0失败
    cout << re << endl;

    ma.clear();
    cout << ma.size() << endl;
    // 迭代器遍历，后面写
    return 0;
}


 
  3.10 案例-员工分组 
   
  3.10.1 案例描述 
   
   
   公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作 
   
   
   员工信息有: 姓名  工资组成；部门分为：策划、美术、研发 
   
   
   随机给10名员工分配部门和工资 
   
   
   通过multimap进行信息的插入  key(部门编号) value(员工) 
   
   
   分部门显示员工信息 
   
   
  3.10.2 实现步骤 
   
   
   创建10名员工，放到vector中 
   
   
   遍历vector容器，取出每个员工，进行随机分组 
   
   
   分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中 
   
   
   分部门显示员工信息 
   
   
  案例代码： 
   
  #include
using namespace std;
#include 
#include 
#include 
#include 

/*
- 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
- 员工信息有: 姓名  工资组成；部门分为：策划、美术、研发
- 随机给10名员工分配部门和工资
- 通过multimap进行信息的插入  key(部门编号) value(员工)
- 分部门显示员工信息
*/

#define CEHUA  0
#define MEISHU 1
#define YANFA  2

class Worker
{
public:
	string m_Name;
	int m_Salary;
};

void createWorker(vector&v)
{
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++)
	{
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name += nameSeed[i];

		worker.m_Salary = rand() % 10000 + 10000; // 10000 ~ 19999
		//将员工放入到容器中
		v.push_back(worker);
	}
}

//员工分组
void setGroup(vector&v,multimap&m)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		//产生随机部门编号
		int deptId = rand() % 3; // 0 1 2 

		//将员工插入到分组中
		//key部门编号，value具体员工
		m.insert(make_pair(deptId, *it));
	}
}

void showWorkerByGourp(multimap&m)
{
	// 0  A  B  C   1  D  E   2  F G ...
	cout << "策划部门：" << endl;

	multimap::iterator pos = m.find(CEHUA);
	int count = m.count(CEHUA); // 统计具体人数
	int index = 0;
	for (; pos != m.end() && index < count; pos++ , index++)
	{
		cout << "姓名： " << pos->second.m_Name << " 工资： " << pos->second.m_Salary << endl;
	}

	cout << "----------------------" << endl;
	cout << "美术部门： " << endl;
	pos = m.find(MEISHU);
	count = m.count(MEISHU); // 统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名： " << pos->second.m_Name << " 工资： " << pos->second.m_Salary << endl;
	}

	cout << "----------------------" << endl;
	cout << "研发部门： " << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA); // 统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名： " << pos->second.m_Name << " 工资： " << pos->second.m_Salary << endl;
	}

}

int main() {

	srand((unsigned int)time(NULL));

	//1、创建员工
	vectorvWorker;
	createWorker(vWorker);

	//2、员工分组
	multimapmWorker;
	setGroup(vWorker, mWorker);


	//3、分组显示员工
	showWorkerByGourp(mWorker);

	测试
	//for (vector::iterator it = vWorker.begin(); it != vWorker.end(); it++)
	//{
	//	cout << "姓名： " << it->m_Name << " 工资： " << it->m_Salary << endl;
	//}

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   当数据以键值对形式存在，可以考虑用map 或 multimap 
   
  3.11 案例-评委打分 
   
  3.11.1 案例描述 
   
  有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。 
   
  3.11.2 实现步骤 
   
   
   创建五名选手，放到vector中 
   遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中 
   sort算法对deque容器中分数排序，去除最高和最低分 
   deque容器遍历一遍，累加总分 
   获取平均分 
   
   
  示例代码： 
   
  //选手类
class Person
{
public:
    Person(string name, int score)
    {
        this->m_Name = name;
        this->m_Score = score;
    }
    
    string m_Name; //姓名
    int m_Score;  //平均分
};

void createPerson(vector&v)
{
    string nameSeed = "ABCDE";
    for (int i = 0; i < 5; i++)
        {
            string name = "选手";
            name += nameSeed[i];

            int score = 0;

            Person p(name, score);

            //将创建的person对象 放入到容器中
            v.push_back(p);
        }
}

//打分
void setScore(vector&v)
{
    for (vector::iterator it = v.begin(); it != v.end(); it++)
        {
            //将评委的分数 放入到deque容器中
            dequed;
            for (int i = 0; i < 10; i++)
                {
                    int score = rand() % 41 + 60;  // 60 ~ 100
                    d.push_back(score);
                }

            //cout << "选手： " << it->m_Name << " 打分： " << endl;
            //for (deque::iterator dit = d.begin(); dit != d.end(); dit++)
            //{
            //	cout << *dit << " ";
            //}
            //cout << endl;

            //排序
            sort(d.begin(), d.end());

            //去除最高和最低分
            d.pop_back();
            d.pop_front();

            //取平均分
            int sum = 0;
            for (deque::iterator dit = d.begin(); dit != d.end(); dit++)
                {
                    sum += *dit; //累加每个评委的分数
                }

            int avg = sum / d.size();

            //将平均分 赋值给选手身上
            it->m_Score = avg;
        }

}

void showScore(vector&v)
{
    for (vector::iterator it = v.begin(); it != v.end(); it++)
        {
            cout << "姓名： " << it->m_Name << " 平均分： " << it->m_Score << endl;
        }
}

int main() {

    //随机数种子
    srand((unsigned int)time(NULL));

    //1、创建5名选手
    vectorv;  //存放选手容器
    createPerson(v);

    //测试
    //for (vector::iterator it = v.begin(); it != v.end(); it++)
    //{
    //	cout << "姓名： " << (*it).m_Name << " 分数： " << (*it).m_Score << endl;
    //}

    //2、给5名选手打分
    setScore(v);

    //3、显示最后得分
    showScore(v);

    system("pause");

    return 0;
} 
   
  总结： 选取不同的容器操作数据，可以提升代码的效率 
   
  4 STL- 函数对象（仿函数）（注意是一个类或结构体） 
   
  4.1 函数对象 
   
  4.1.1 函数对象概念 
   
  概念： 
   
   
   本质是重载和类 
   
   
   重载函数调用操作符的类，（重载的是（））其对象常称为函数对象 
   
   
   函数对象使用重载的()时，行为类似函数调用，也叫仿函数（和函数对象一个事情） 
   函数对象(仿函数)是一个类，不是一个函数（使用时：可以像普通函数那样调用,可以有参数，可以有返回值） 
   都不需要生成对象，直接用类或struct名字即可 
   
   
  4.1.2  函数对象使用 
   
  特点： 
   
   
   函数对象超出普通函数的概念，函数对象可以有自己的状态（区别普通函数） 
   
   
   函数对象可以作为参数传递 
   
   
  示例: 
   
  #include 

//1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
class MyAdd
{
    public :
    int operator()(int v1,int v2)
    {
        return v1 + v2;         //很像函数
    }
};

void test01()
{
    MyAdd myAdd;
    cout << myAdd(10, 10) << endl;      //使用的时候和普通函数像
}

//2、函数对象可以有自己的状态
class MyPrint
{
    public:
    MyPrint()        //构造函数
    {
        count = 0;    //或this->count
    }
    void operator()(string test)
    {
        cout << test << endl;
        count++; //统计使用次数    //或this->count++;
    }
    
    int count; //内部自己的状态      ，这个时候不用全局变量和类里的static了
};
void test02()
{
    MyPrint myPrint;
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");
    cout << "myPrint调用次数为： " << myPrint.count << endl;
}

//3、函数对象可以作为参数传递
void doPrint(MyPrint &mp , string test)
{
    mp(test);
}

void test03()
{
    MyPrint myPrint;
    doPrint(myPrint, "Hello C++");
}

int main() {
    
    //test01();
    //test02();
    test03();
    
    system("pause");
    
    return 0;
} 
   
  总结： 
   
   
   仿函数写法非常灵活，可以作为参数进行传递。 
   
   
  4.2  谓词（返回bool的仿函数） 
   
  4.2.1 谓词概念 
   
  概念： 
   
   
   返回bool类型的仿函数称为谓词 
   
   
   如果operator()接受一个参数，那么叫做一元谓词 
   
   
   如果operator()接受两个参数，那么叫做二元谓词 
   
   
  4.2.2 一元谓词 
   
  示例： 
   
  #include 
#include 

//1.一元谓词
struct GreaterFive{              //class和struct都可以
    bool operator()(int val) {
        return val > 5;
    }
};

void test01() {
    
    vector v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    
    vector::iterator it = find_if(v.begin(), v.end(), GreaterFive());
                              //find_if算法+仿函数，例如这里利用仿函数找大于五的数
                              //看源码可以知道，find_if返回的是一个指针（迭代器），
                              //也就是只返回第一个大于五的数的指针
    if (it == v.end()) {
        cout << "没找到!" << endl;
    }
    else {
        cout << "找到:" << *it << endl;
    }
    
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结：参数只有一个的谓词，称为一元谓词 
   
  4.2.3 二元谓词 
   
  示例： 
   
  #include 
#include 
//二元谓词
class MyCompare
{
    public:
    bool operator()(int num1, int num2)
    {
        return num1 > num2;
    }
};

void test01()
{
    vector v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    
    //默认从小到大
    sort(v.begin(), v.end());
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    cout << "----------------------------" << endl;
    
    //使用函数对象改变算法策略，排序从大到小
    sort(v.begin(), v.end(), MyCompare());
    for (vector::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结：参数只有两个的谓词，称为二元谓词 
   
  4.3 内建函数对象 
   
  4.3.1 内建函数对象意义 
   
  概念： 
   
   
   STL内建了一些函数对象 
   
   
  分类: 
   
   
   算术仿函数 
   
   
   关系仿函数 （大于小于） 
   
   
   逻辑仿函数 （与或非） 
   
   
  用法： 
   
   
   这些仿函数所产生的对象，用法和一般函数完全相同 
   
   
   使用内建函数对象，需要引入头文件 #include 
   
   
  4.3.2 算术仿函数（用的少）（int、double） 
   
   
   
  功能描述： 
   
   
   实现四则运算 
   
   
   其中negate是一元运算，其他都是二元运算 
   
   
  仿函数原型： 
   
   
   template T plus                //加法仿函数 
   
   
   template T minus              //减法仿函数 
   
   
   template T multiplies    //乘法仿函数 
   
   
   template T divides         //除法仿函数 
   
   
   template T modulus         //取模仿函数 
   
   
   template T negate           //取反仿函数（一元运算） 
   
   
  示例： 
   
  #include 
//negate
void test01()
{
    negate n;
    cout << n(50) << endl;      //-50
    }

//plus
void test02()
{
    plus p;                        //这里需要注意一下一个int即可，默认两个数同类型
    cout << p(10, 20) << endl;
}

int main() {
    
    test01();
    test02();
    
    system("pause");
    
    return 0;
} 
   
  总结：使用内建函数对象时，需要引入头文件 #include  
  plus p; //这里需要注意一下一个int即可，默认两个数同类型 
   
  4.3.3 关系仿函数（好）（bool）（sort规则） 
   
  功能描述： 
   
   
   实现关系对比 
   
   
  仿函数原型： 
   
   
   template bool equal_to                    //等于 
   
   
   template bool not_equal_to            //不等于 
   
   
   template bool greater                      //大于 
   
   
   template bool greater_equal          //大于等于 
   
   
   template bool less                           //小于 
   
   
   template bool less_equal               //小于等于 
   
   
  示例： 
   
  #include 
#include 
#include 

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


void test01()
{
	vector v;
	
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(40);
	v.push_back(20);
	
	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
	
	//自己实现仿函数
	//sort(v.begin(), v.end(), MyCompare());            //方法一
	//STL内建仿函数  大于仿函数
	sort(v.begin(), v.end(), greater());           //方法二（好）
	
	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	
	test01();
	
	system("pause");
	
	return 0;
} 
   
  总结：关系仿函数中最常用的就是greater<>大于 
   
  4.3.4 逻辑仿函数（基本不用）（bool） 
   
  功能描述： 
   
   
   实现逻辑运算 
   
   
  函数原型： 
   
   
   template bool logical_and              //逻辑与 
   
   
   template bool logical_or                //逻辑或 
   
   
   template bool logical_not              //逻辑非 
   
   
  示例： 
   
  #include 
#include 
#include 
void test01()
{
	vector v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	
	for (vector::iterator it = v.begin();it!= v.end();it++)
	{       
		cout << *it << " ";    
	}
	cout << endl;
	
	//逻辑非  将v容器搬运到v2中，并执行逻辑非运算
	vector v2;
	v2.resize(v.size());                         //resize作用是开辟空间       
	transform(v.begin(), v.end(),  v2.begin(), logical_not());
	for (vector::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	
	test01();
	
	system("pause");
	
	return 0;
} 
   
  总结：逻辑仿函数实际应用较少，了解即可 
   
  5 STL- 常用算法（） 
   
   有的需要仿函数，和谓词（普通函数放函数名，仿函数别忘了小括号）： 
   
  for_search/transform/find/find_if/count/cout_if/replace_if/sort/ 
   
   有的需要类相等重写==：find/count 
   有的需要内置数据类型和自定数据类型：find/count 
   有的需要有序序列:binary_search/merge/set_intersection/set_union/set_difference 
   有的需要开辟空间：transform/copy/merge/fill 
   有的需要随机种子：random_shuffle 
   
   
   
   
   
  概述: 
   
   
   算法主要是由头文件  组成。 
   
   
   是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等 
   
   
   体积很小，只包括几个在序列上面进行简单数学运算的模板函数 
   
   
   定义了一些模板类,用以声明函数对象。 
   
   
  5.1 常用遍历算法 
   
  学习目标： 
   
   
   掌握常用的遍历算法 
   
   
  算法简介： 
   
   
   for_each     //遍历容器 
   
   
   transform   //搬运容器到另一个容器中 
   
   
  5.1.1 for_each 
   
  功能描述： 
   
   
   实现遍历容器 
   
   
  函数原型： 
   
  for_each(iterator beg, iterator end, _func);
 // 遍历算法 遍历容器元素
 // beg 开始迭代器
 // end 结束迭代器
 // 普通函数或者仿函数 
   
  示例： 
   
  #include 
#include 

//普通函数
void print01(int val) 
{
	cout << val << " ";
}
//函数对象
class print02 
{
 public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};

//for_each算法基本用法
void test01() {

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

	//遍历算法
	for_each(v.begin(), v.end(), print01);     普通函数放函数名
	cout << endl;

	for_each(v.begin(), v.end(), print02());    仿函数别忘了小括号
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：for_each在实际开发中是最常用遍历算法，需要熟练掌握 
   
  5.1.2 transform 
   
  功能描述： 
   
   
   搬运容器到另一个容器中，和copy的区别是这个可以搬得时候+或-（例如） 
   
   
  函数原型： 
   
   
   transform(iterator beg1, iterator end1, iterator beg2, _func); 
   
   
  //beg1 源容器开始迭代器（） 
   
  //end1 源容器结束迭代器 
   
  //beg2 目标容器开始迭代器 
   
  //普通函数或者函数对象(例如可以加减乘除之后在搬) 
   
  示例： 
   
  #include
#include

//常用遍历算法  搬运 transform

class TransForm
{
    public:
    int operator()(int val)
    {
        return val+100;
    }
    
};

class MyPrint
{
    public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vectorv;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    
    vectorvTarget; //目标容器
    
    vTarget.resize(v.size()); // 目标容器需要提前开辟空间
    
    transform(v.begin(), v.end(), vTarget.begin(), TransForm());
    
    for_each(vTarget.begin(), vTarget.end(), MyPrint());
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结： 搬运的目标容器必须要提前开辟空间，否则无法正常搬运 
   
  5.2 常用查找算法（内置数据类型和自定数据类型） 
  注意都是return迭代器，需要用一个迭代器接受 
   
  学习目标： 
   
   
   掌握常用的查找算法 
   
   
  算法简介： 
   
   
   find                     //查找元素 
   
   
   find_if               //按条件查找元素 
   
   
   adjacent_find    //查找相邻重复元素 
   
   
   binary_search    //二分查找法（快，但是有限制） 
   
   
   count                   //统计元素个数 
   
   
   count_if             //按条件统计元素个数 
   
   
  5.2.1 find 
   
  功能描述： 
   
   
   查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()（注意end在最后一个数之后） 
   
   
  函数原型： 
   
   
   find(iterator beg, iterator end, value);
 // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
 // beg 开始迭代器
 // end 结束迭代器
 // value 查找的元素 
   
   
  没有仿函数 
  自定义类型时，例如找类，需要重载== 
   
  示例： 
   
  #include 
#include 
#include 
void test01() {          
    
    vector v;                                        //基本操作
    for (int i = 0; i < 10; i++) {
        v.push_back(i + 1);
    }
    //查找容器中是否有 5 这个元素
    vector::iterator it = find(v.begin(), v.end(), 5);
    if (it == v.end()) 
    {
        cout << "没有找到!" << endl;
    }
    else 
    {
        cout << "找到:" << *it << endl;
    }
}

class Person {                          
    public:
    Person(string name, int age) 
    {
        this->m_Name = name;
        this->m_Age = age;
    }
                                    
    bool operator==(const Person& p)   //重载==
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) 
        {
            return true;
        }
        return false;
    }
    
    public:
    string m_Name;
    int m_Age;
};

void test02() {
    
    vector 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::iterator it = find(v.begin(), v.end(), p2);
    if (it == v.end()) 
    {
        cout << "没有找到!" << endl;
    }
    else 
    {
        cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
    }
} 
   
  总结： 利用find可以在容器中找指定的元素，返回值是迭代器 
   
  5.2.2 find_if 
   
  功能描述： 
   
   
   按条件查找元素，不大需要重写==了 
   
   
  函数原型： 
   
   
   find_if(iterator beg, iterator end, _Pred);
 // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
 // beg 开始迭代器
 // end 结束迭代器
 // _Pred：返回bool类型的仿函数或者谓词 
   
   
  示例： 
   
  #include 
#include 
#include 

//内置数据类型
class GreaterFive
{
    public:
    bool operator()(int val)
    {
        return val > 5;
    }
};

void test01() {
    
    vector v;
    for (int i = 0; i < 10; i++) {
        v.push_back(i + 1);
    }
    
    vector::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    if (it == v.end()) {
        cout << "没有找到!" << endl;
    }
    else {
        cout << "找到大于5的数字:" << *it << endl;
    }
}

//自定义数据类型
class Person {
    public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    public:
    string m_Name;
    int m_Age;
};

class Greater20
{
    public:
    bool operator()(Person &p)
    {
        return p.m_Age > 20;
    }
    
};

void test02() {
    
    vector 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::iterator it = find_if(v.begin(), v.end(), Greater20());
    if (it == v.end())
    {
        cout << "没有找到!" << endl;
    }
    else
    {
        cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
    }
}

int main() {
    
    //test01();
    
    test02();
    
    system("pause");
    
    return 0;
} 
   
  总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略 
   
  5.2.3 adjacent_find 
   
  功能描述： 
   
   
   查找相邻重复元素 
   
   
  函数原型： 
   
   
   adjacent_find(iterator beg, iterator end);
 // 查找相邻重复元素,返回相邻元素的第一个位置的迭代器
 // beg 开始迭代器
 // end 结束迭代器 
   
   
  示例： 
   
  #include 
#include 

void test01()
{
    vector v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(5);
    v.push_back(2);
    v.push_back(4);
    v.push_back(4);
    v.push_back(3);
    
    //查找相邻重复元素
    vector::iterator it = adjacent_find(v.begin(), v.end());
    if (it == v.end()) {
        cout << "找不到!" << endl;
    }
    else {
        cout << "找到相邻重复元素为:" << *it << endl;
    }
} 
   
  总结：面试题中如果出现查找相邻重复元素，记得用STL中的adjacent_find算法 
   
  5.2.4 binary_search 
   
  功能描述： 
   
   
   查找指定元素是否存在 
   
   
  函数原型： 
   
   
   bool binary_search(iterator beg, iterator end, value);
 // 查找指定的元素，查到 返回true  否则false
 // 注意: 在无序序列中不可用
 // beg 开始迭代器
 // end 结束迭代器
 // value 查找的元素 
   
   
  示例： 
   
  #include 
#include 

void test01()
{
	vectorv;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//二分查找
	bool ret = binary_search(v.begin(), v.end(),2);
	if (ret)
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列 
   
  5.2.5 count 
   
  功能描述： 
   
   
   统计元素个数 
   
   
  函数原型： 
   
   
   count(iterator beg, iterator end, value);
 // 统计元素出现次数
 // beg 开始迭代器
 // end 结束迭代器
 // value 统计的元素 
   
   
  示例： 
   
  #include 
#include 

//内置数据类型
void test01()
{
    vector v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);
    v.push_back(5);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);
    
    int num = count(v.begin(), v.end(), 4);
    
    cout << "4的个数为： " << num << endl;
}

//自定义数据类型
class Person
{
    public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    bool operator==(const Person & p)
    {
        if (this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    int m_Age;
};

void test02()
{
    vector v;
    
    Person p1("刘备", 35);
    Person p2("关羽", 35);
    Person p3("张飞", 35);
    Person p4("赵云", 30);
    Person p5("曹操", 25);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);
    
    Person p("诸葛亮",35);
    
    int num = count(v.begin(), v.end(), p);
    cout << "num = " << num << endl;
}
int main() {
    
    //test01();
    
    test02();
    
    system("pause");
    
    return 0;
} 
   
  总结： 统计自定义数据类型时候，需要配合重载 operator== 
   
  5.2.6 count_if 
   
  功能描述： 
   
   
   按条件统计元素个数 
   
   
  函数原型： 
   
   
   count_if(iterator beg, iterator end, _Pred);
 // 按条件统计元素出现次数
 // beg 开始迭代器
 // end 结束迭代器
 // _Pred 谓词 
   
   
  示例： 
   
  #include 
#include 

class Greater4
{
public:
	bool operator()(int val)
	{
		return val >= 4;
	}
};

//内置数据类型
void test01()
{
	vector v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(4);
	v.push_back(5);
	v.push_back(3);
	v.push_back(4);
	v.push_back(4);

	int num = count_if(v.begin(), v.end(), Greater4());

	cout << "大于4的个数为： " << num << endl;
}

//自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

class AgeLess35
{
public:
	bool operator()(const Person &p)
	{
		return p.m_Age < 35;
	}
};
void test02()
{
	vector v;

	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 25);

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

	int num = count_if(v.begin(), v.end(), AgeLess35());
	cout << "小于35岁的个数：" << num << endl;
}


int main() {

	//test01();

	test02();

	system("pause");

	return 0;
} 
   
  总结：按值统计用count，按条件统计用count_if 
   
  5.3 常用排序算法 
   
  学习目标： 
   
   
   掌握常用的排序算法 
   
   
  算法简介： 
   
   
   sort             //对容器内元素进行排序 
   
   
   random_shuffle   //洗牌   指定范围内的元素随机调整次序 
   
   
   merge           // 容器元素合并，并存储到另一容器中 
   
   
   reverse       // 反转指定范围的元素 
   
   
  5.3.1 sort 
   
  功能描述： 
   
   
   对容器内元素进行排序 
   
   
  函数原型： 
   
   
   sort(iterator beg, iterator end, _Pred);
 // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
 //  beg    开始迭代器
 //  end    结束迭代器
 // _Pred  谓词（仿函数） 
   
   
  示例： 
   
  #include 
#include 

void myPrint(int val)
{
	cout << val << " ";
}

void test01() {
	vector v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	//sort默认从小到大排序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	//从大到小排序
	sort(v.begin(), v.end(), greater());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：sort属于开发中最常用的算法之一，需熟练掌握 
   
  5.3.2 random_shuffle 
   
  功能描述： 
   
   
   洗牌   指定范围内的元素随机调整次序 
   
   
  函数原型： 
   
   
   random_shuffle(iterator beg, iterator end);
 // 指定范围内的元素随机调整次序
 // beg 开始迭代器
 // end 结束迭代器 
   
   
  示例： 
   
  #include 
#include 
#include 

class myPrint     //用仿函数或者是一般函数
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	srand((unsigned int)time(NULL));       //  种子
	vector v;
	for(int i = 0 ; i < 10;i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//打乱顺序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：random_shuffle洗牌算法比较实用，在运行还是这些数，就不在打乱了，使用时记得加随机数种子 
  srand((unsigned int)time(NULL));  
  5.3.3 merge 
   
  功能描述： 
   
   
   两个容器元素合并，并存储到另一容器中 
   
   
  函数原型： 
   
   
   merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
 // 容器元素合并，并存储到另一容器中
 // 注意: 两个容器必须是有序的
 // beg1   容器1开始迭代器
 // end1   容器1结束迭代器
 // beg2   容器2开始迭代器
 // end2   容器2结束迭代器
 // dest    目标容器开始迭代器 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
    public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector v1;
    vector v2;
    for (int i = 0; i < 10 ; i++) 
    {
        v1.push_back(i);
        v2.push_back(i + 1);
    }
    
    vector vtarget;
    //目标容器需要提前开辟空间
    vtarget.resize(v1.size() + v2.size());
    //合并  需要两个有序序列
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
    for_each(vtarget.begin(), vtarget.end(), myPrint());
    cout << endl;
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结：merge合并的两个容器必须的有序序列，注意目标容器需要提前开辟空间 
   
  5.3.4 reverse 
   
  功能描述： 
   
   
   将容器内元素进行反转 
   
   
  函数原型： 
   
   
   reverse(iterator beg, iterator end);
 // 反转指定范围的元素
 // beg 开始迭代器
 // end 结束迭代器 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	cout << "反转前： " << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	cout << "反转后： " << endl;

	reverse(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：reverse反转区间内元素，面试题可能涉及到 
   
  5.4 常用拷贝和替换算法 
   
  学习目标： 
   
   
   掌握常用的拷贝和替换算法 
   
   
  算法简介： 
   
   
   copy                      // 容器内指定范围的元素拷贝到另一容器中 
   
   
   replace                // 将容器内指定范围的旧元素修改为新元素 
   
   
   replace_if          // 容器内指定范围满足条件的元素替换为新元素 
   
   
   swap                     // 互换两个容器的元素 
   
   
  5.4.1 copy 
   
  功能描述： 
   
   
   容器内指定范围的元素拷贝到另一容器中 
   
   
  函数原型： 
   
   
   copy(iterator beg, iterator end, iterator dest);
 // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
 // beg  开始迭代器
 // end  结束迭代器
 // dest 目标起始迭代器 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i + 1);
	}
	vector v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());

	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：利用copy算法在拷贝时，目标容器记得提前开辟空间 
   
  5.4.2 replace 
   
  功能描述： 
   
   
   将容器内指定范围的旧元素修改为新元素 
   
   
  函数原型： 
   
   
   replace(iterator beg, iterator end, oldvalue, newvalue);
 // 将区间内旧元素 替换成 新元素
 // beg 开始迭代器
 // end 结束迭代器
 // oldvalue 旧元素
 // newvalue 新元素 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(50);
	v.push_back(10);
	v.push_back(20);

	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//将容器中的20 替换成 2000
	cout << "替换后：" << endl;
	replace(v.begin(), v.end(), 20,2000);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：replace会替换区间内满足条件的元素 
   
  5.4.3 replace_if 
   
  功能描述: 
   
   
   将区间内满足条件的元素，替换成指定元素 
   
   
  函数原型： 
   
   
   replace_if(iterator beg, iterator end, _pred, newvalue);
 // 按条件替换元素，满足条件的替换成指定元素
 // beg 开始迭代器
 // end 结束迭代器
 // _pred 谓词
 // newvalue 替换的新元素 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
    public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

class ReplaceGreater30
{
    public:
    bool operator()(int val)
    {
        return val >= 30;
    }
    
};

void test01()
{
    vector v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(20);
    v.push_back(40);
    v.push_back(50);
    v.push_back(10);
    v.push_back(20);
    
    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
    
    //将容器中大于等于的30 替换成 3000
    cout << "替换后：" << endl;
    replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结：replace_if按条件查找，可以利用仿函数灵活筛选满足的条件 
   
  5.4.4 swap 
   
  功能描述： 
   
   
   互换两个容器的元素 
   
   
  函数原型： 
   
   
   swap(container c1, container c2);
 // 互换两个容器的元素
 // c1容器1
 // c2容器2 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector v1;
	vector v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+100);
	}

	cout << "交换前： " << endl;
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;

	cout << "交换后： " << endl;
	swap(v1, v2);
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：swap交换容器时，注意交换的容器要同种类型 
   
  5.5 常用算术生成算法 
   
  学习目标： 
   
   
   掌握常用的算术生成算法 
   
   
  注意： 
   
   
   算术生成算法属于小型算法，使用时包含的头文件为 #include  
   
   
  算法简介： 
   
   
   accumulate      // 计算容器元素累计总和 
   
   
   fill                 // 向容器中添加元素 
   
   
  5.5.1 accumulate 
   
  功能描述： 
   
   
   计算区间内 容器元素累计总和 
   
   
  函数原型： 
   
   
   accumulate(iterator beg, iterator end, value);
 // 计算容器元素累计总和
 // beg 开始迭代器
 // end 结束迭代器
 // value 起始值 ，一般是0，相等于总和+的值，可以理解为偏置 
   
   
  示例： 
   
  #include 
#include 
void test01()
{
	vector v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}

	int total = accumulate(v.begin(), v.end(), 0);

	cout << "total = " << total << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：accumulate使用时头文件注意是 numeric，这个算法很实用 
   
  5.5.2 fill 
   
  功能描述： 
   
   
   向容器中填充指定的元素 
   
   
  函数原型： 
   
   
   fill(iterator beg, iterator end, value);
 // 向容器中填充元素
 // beg 开始迭代器
 // end 结束迭代器
 // value 填充的值 
   
   
  示例： 
   
  #include 
#include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{

	vector v;
	v.resize(10);
	//填充
	fill(v.begin(), v.end(), 100);           //这个可以再建立vector的时候就填充上了

	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结：利用fill可以将容器区间内元素填充为 指定的值 
   
  5.6 常用集合算法 
   
  学习目标： 
   
   
   掌握常用的集合算法 
   
   
  算法简介： 
   
   
   set_intersection          // 求两个容器的交集 
   
   
   set_union                       // 求两个容器的并集 
   
   
   set_difference              // 求两个容器的差集 
   
   
  5.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 
#include 

class myPrint
{
    public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector v1;
    vector v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i+5);
    }
    
    vector vTarget;
    //取两个里面较小的值给目标容器开辟空间
    vTarget.resize(min(v1.size(), v2.size()));
    
    //返回目标容器的最后一个元素的迭代器地址
    vector::iterator itEnd = 
        set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    
    for_each(vTarget.begin(), itEnd, myPrint());     /注意是itEnd而不能是vTarget.end()
    cout << endl;
}

int main() {
    
    test01();
    
    system("pause");
    
    return 0;
} 
   
  总结： 
   
   
   求交集的两个集合必须的有序序列 
   
   
   目标容器开辟空间需要从两个容器中取小值 
   
   
   set_intersection返回值既是交集中最后一个元素的位置 
   
   
  5.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 目标容器开始迭代器 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector v1;
	vector v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}

	vector vTarget;
	//取两个容器的和给目标容器开辟空间
	vTarget.resize(v1.size() + v2.size());

	//返回目标容器的最后一个元素的迭代器地址
	vector::iterator itEnd = 
        set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   求并集的两个集合必须的有序序列 
   
   
   目标容器开辟空间需要两个容器相加 
   
   
   set_union返回值既是并集中最后一个元素的位置 
   
   
  5.6.3  set_difference 
   
  功能描述： 
   
   
   求两个集合的差集 
   
   
  函数原型： 
   
   
   set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
 // 求两个集合的差集
 // 注意:两个集合必须是有序序列
 // beg1 容器1开始迭代器
 // end1 容器1结束迭代器
 // beg2 容器2开始迭代器
 // end2 容器2结束迭代器
 // dest 目标容器开始迭代器 
   
   
  示例： 
   
  #include 
#include 

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector v1;
	vector v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}

	vector vTarget;
	//取两个里面较大的值给目标容器开辟空间
	vTarget.resize( max(v1.size() , v2.size()));

	//返回目标容器的最后一个元素的迭代器地址
	cout << "v1与v2的差集为： " << endl;
	vector::iterator itEnd = 
        set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;


	cout << "v2与v1的差集为： " << endl;
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
} 
   
  总结： 
   
   
   求差集的两个集合必须的有序序列 
   
   
   目标容器开辟空间需要从两个容器取较大值 
   
   
   set_difference返回值既是差集中最后一个元素的位置 
   
   
   
  6 其他函数 
  6.1 数学函数汇总 
   
  注意 
  此处为语雀内容卡片，点击链接查看：https://www.yuque.com/huanlema-duwrx/znr4qo/iu01wf#qMBrb 
   
  算术仿函数 
  https://www.yuque.com/huanlema-duwrx/znr4qo/tyrnpb#6a1d7662 
   
   
   
  6.2 未归类函数 
  char数组那些 
  函数 memcpy() 用来复制内存到另一个位置。 
  push_back：string里可以用append，vector就用的是push_back 
  begin( ) 函数返回一个指向向量开头的迭代器。 
  end( ) 函数返回一个指向向量末尾的迭代器 
  swap（） 
   
   
  几个长度： 
  数组[]：sizeof/sizeof（数组长度：sizeof(int array[] = {0,1,2,5,8}) / sizeof(例如int)） 
  字符串数组：strlen（c++中，length ()只是用来获取字符串的长度 
  在获取字符串长度时，size ()函数与length ()函数作用相同） 
  string：size 
  容器:size