1 STL

1.1 STL的诞生

C++面向对象和泛型编程思想，目的是提高复用性。为了建立数据结构和算法的一套标注，STL孕育而生。

1.2 STL基本概念

STL(Standard Template Library 标准模版库)
STL从广义上分为：容器(container)、算法(algorithm)、迭代器(iterator)
容器和算法之间通过迭代器进行连接
STL几乎所有代码都采用了模版类和模版函数

1.3 STL六大部件

STL大体分为六大组件：容器、算法、迭代器、仿函数、适配器、空间配置器

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

1.4 容器概念

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

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

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

1.5 算法概念

算法分为：质变算法和非质变算法

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

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

1.6 迭代器概念

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

每个容器都有自己的专属迭代器，迭代器类似指针。

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

2 初识容器算法迭代器

2.1 vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector::iterator

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

void printfVector(int val){
    cout << val << " ";
}
/// 实现vector存放内置数据类型
void SaveInner(){
    //声明容器vector对象
    vector<int> zhangsan;
    //往容器内插入数据
    zhangsan.push_back(10);
    zhangsan.push_back(20);
    zhangsan.push_back(30);
    //通过迭代器访问容器中的数据
    //起始迭代器：begin()迭代器指向容器第一个元素
    vector<int>::iterator iBegin = zhangsan.begin();
    //结束迭代器：end()迭代器指向容器最后一个元素的下一个位置
    vector<int>::iterator iEnd = zhangsan.end();
    //方式一：遍历输出迭代器中所有内容
    while (iBegin != iEnd) {
        cout << *iBegin << " ";
        iBegin++;
    }
    cout << endl;

    //方式二：遍历输出迭代器中所有内容
    for(vector<int>::iterator it = zhangsan.begin();it != zhangsan.end();it++){
        cout << *it << " ";
    }
    cout << endl;

    //方式三：遍历输出迭代器中所有内容，for_each函数包含在algorithm头文件中
    //参数一：起始迭代器；参数二：结束迭代器；参数三：自定义处理函数
    for_each(zhangsan.begin(), zhangsan.end(), printfVector);
    cout << endl;
}

2.2 vector存放自定义数据类型

实现vector存放自定义数据类型

///实现vector存放自定义数据类型
void SaveOuter(){
    vector<Person> student;
    student.push_back(Person("张三",22));
    student.push_back(Person("李四",19));
    student.push_back(Person("王五",32));

    vector<Person>::iterator iBegin = student.begin();
    vector<Person>::iterator iEnd = student.end();
    //方式一
    while(iBegin != iEnd){
        cout << "name=" << iBegin->name << " " << "age=" << iBegin->age << endl;
        iBegin++;
    }
    //方式二
    for(vector<Person>::iterator it = student.begin(); it != student.end(); it++){
        //下述两种方式都可以
        cout << "name=" << it->name << " " << "age=" << it->age << endl;
        //cout << "name=" << (*it).name << " " << "age=" << (*it).age << endl;
    }
    //方式三
    for_each(student.begin(), student.end(), printfOuter);
}

实现vector存放自定义指针数据类型

下述声明的是Person 类型，当通过(it)取出当前vector内容，实际获取的是 Person *数据类型，所以后面接了一个->成员访问符；取出的就是声明的数据类型

///存放指针
void SaveOuterPointer(){
    vector<Person*> student;
    Person zhangsan("张三",22);
    Person lisi("李四",19);
    Person wangwu("王五",32);
    student.push_back(&zhangsan);
    student.push_back(&lisi);
    student.push_back(&wangwu);

    //其他两种方式，与上面类似
    for(vector<Person*>::iterator it = student.begin(); it != student.end();it++){
        cout << "name=" << (*it)->name << " " << "age=" << (*it)->age << endl;
    }
}

2.3 Vector容器嵌套

//遍历大vector容器内容
void printfVector(vector<int> v){
    //然后在通过一个for_each和lambda语法打印每个子vector中内容
    for_each(v.begin(), v.end(), [](int value) {
        cout << value << " ";
    });
    cout << endl;
}
//Vector容器嵌套
//Vector容器中在嵌套一个Vector
void NestVector(){
    //大vector容器
    vector<vector<int>> bigVector;
    //子vector容器
    vector<int> vector1;
    vector<int> vector2;
    //初始化子vector容器初始值
    for(int i=0; i<3; i++){
        vector1.push_back(i);
        vector2.push_back(i+1);
    }
    //将子vector容器使用尾插法插入大vector容器
    bigVector.push_back(vector1);
    bigVector.push_back(vector2);
    //使用alogrithm库中的for_each算法遍历大vector容器
    for_each(bigVector.begin(), bigVector.end(), printfVector);
}

3 string容器

本质：

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

string和char *的区别：

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

特点：

string类内部封装了大量成员函数
例如：查找find、拷贝copy、删除delete、替换replace、插入insert
string管理char *所分配的内存，不用担心复制越界和取值等，由类内部负责

3.1 string构造函数

string构造函数原型：

string(); //创建一个空的字符串；默认构造
string(const char *s); //使用字符串s进行初始化；有参构造
string(const string &str); //使用一个string对象初始化另一个string对象；拷贝构造
string(int n,char c); //使用n个字符c初始化c

void stringTest01(){
    //默认构造函数
    string zhangsan;

    //有参构造
    const char *s = "李四";
    string lisi(s);
    cout << lisi << endl;

    //拷贝构造函数
    string wangwu(lisi);
    cout << wangwu << endl;

    string zhaoer(5,'a');
    cout << zhaoer << endl;
}

3.2 string赋值操作

赋值函数原型：

string& operator =(const char s); //char s类型赋值给当前字符串
string& operator =(const string &s); //字符串s赋值给当前字符串
string& operator =(char c); //字符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 stringTest02(){
    //原型:string& operator =(const char *s);
    const char *hello = "hello";
    string str1 = hello;
    cout << str1 << endl;

    //原型:string& operator =(const string &s);
    string str2 = str1;
    cout << str2 << endl;

    //原型:string& operator =(char c);
    char c = 'a';
    string str3;
    str3 = c;
    cout << str3 << endl;

    //原型:string& assign (const char *s);
    string str4;
    str4.assign(hello);
    cout << str4 << endl;

    //原型:string& assign (const char *s,int n);
    string str5;
    str5.assign(hello,2);
    cout << str5 << endl;

    //原型:string& assign (const string &s);
    string str6;
    str6.assign(str5);
    cout << str6 << endl;

    //原型:string& assign (int n,char c);
    string str7;
    str7.assign(5,c);
    cout << str7 << endl;
}

3.3 string字符串拼接

拼接函数原型：

string& operator +=(const char *s);
string& operator +=(const char c);
string& operator +=(const string &s);
string& append(const char *s); //将字符串s拼接到当前字符串末尾
string& append(const string &s,int n); //将字符串s的前n个字符拼接到当前字符串末尾
string& append(const string &s,int pos,int n); //将字符串s第pos位置开始之后的n个字符拼接到当前字符串末尾

void stringTest03(){
    const char *hello = "hello";
    const char c = 'c';

    //原型：string& operator +=(const char *s);
    string str1("lisi");
    str1 += hello;
    cout << str1 << endl;

    //原型：string& operator +=(const char c);
    string str2("wangwu");
    str2 += c;
    cout << str2 << endl;

    //原型：string& operator +=(const string &s);
    string str3("zhaoer");
    str3 += str2;
    cout << str3 << endl;

    //原型：string& append(const char *s);
    string str4("start");
    str4.append(hello);
    cout << str4 << endl;

    //原型：string& append(const string &s,int n);
    string str5("start");
    str5.append(hello,2);
    cout << str5 << endl;

    //原型：string& append(const string &s,int pos,int n);
    string str6("start");
    str6.append(hello,2,2);
    cout << str6 << endl; //startll
}

3.4 string查找和替换

描述：

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

函数原型：

int find(const string &str,int pos = 0) const; //查找str第一次出现位置，从pos位置开始查找
int find(const char *s,int pos = 0) const; //查找r第一次出现位置，从pos位置开始查找
int find(const char *s,int pos,int n) const; //从pos位置查找字符串s的前n个字符第一次出现的位置
int find(const char c,int pos = 0) const; //查找字符c第一次出现位置，从pos位置开始查找
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最后一次出现位置，从pos位置开始查找
int replace(int pos,int n,const string &str); //将当前字符串的第pos位置开始的n个字符替换成字符串str
int replace(int pos,int n,const char *s);//将当前字符串的第pos位置开始的n个字符替换成字符串s

void stringTest04(){
    string str = "hello c++,I'm liszt";

    //原型：int find(const string &str,int pos = 0) const;
    string str1 = "c++";
    int pos1 = str.find(str1);
    cout << pos1 << endl;//6

    //原型：int find(const char *s,int pos = 0) const;
    const char *liszt = "liszt";
    int pos2 = str.find(liszt);
    cout << pos2 << endl;//14

    //原型：int find(const char *s,int pos,int n) const;
    int pos3 = str.find(liszt,0,1);
    cout << pos3 << endl;//2

    //原型：int replace(int pos,int n,const string &str);
    string str2 = "franz";
    str.replace(14, str2.size(), str2);//hello c++,I'm franz
    cout <<"替换:" << str << endl;

    //原型：int replace(int pos,int n,const char *s);
    const char *franz = "hhhhh";
    str.replace(0, strlen(franz), franz);
    cout <<"替换:" << str << endl;//hhhhh c++,I'm franz
}

3.5 string字符串比较

比较方式：

字符串比较是按字符ASIIC码进行对比

返回结果：

相等，返回0
大于，返回第一个相异字符的ASCII码值之差（正数）
小于，返回第一个相异字符的ASCII码值之差（负数）

函数原型：

int compare(const string &str) const;
int compare(const char *s) const;

void stringTest05(){
    string str1("bda");

    string str2("bx");
    int result1 = str1.compare(str2);
    cout << "result=" << result1 << endl; //-20,d的ASCII码值减x的ASCII码值

    const char *s = "ba";
    int result2 = str1.compare(s);
    cout << "result=" << result2 << endl; //3,d的ASCII码值减a的ASCII码值

    int result3 = str1.compare("bda");
    cout << "result=" << result3 << endl; //0
}

3.6 string字符存取

存取方式包括两种：

char& operator;
char & at(int n);

3.7 string插入和删除

函数原型：

string& insert(int pos,const char *s);
string& insert(int pos,const string &s);
string& insert(int pos,int n,char c);
string& erase(int pos,int n = npos); //删除从pos开始的n个字符

void stringTest06(){
    string str = "hello world!";
    string insertContent = "c++";
    //原型：string& insert(int pos,const char *s);
    str.insert(0,insertContent);
    cout << str << endl;

    //原型：string& insert(int pos,int n,char c);
    str.insert(8, 1,'x');
    cout << str << endl;

    //原型：string& erase(int pos,int n = npos);
    str.erase(8,1);
    cout << str << endl;
}

3.8 string子串

描述：从字符串中截取一部分子串并返回

函数原型：

string substr(int pos = 0,int n = npos); //返回从字符串第pos位置开始的n个字符

void stringTest07(){
    string str = "hello world!";

    string sub = str.substr(6,5);
    cout << sub << endl;//world
}

4 vector容器

4.1 vector概念

vector与数组非常类似，称为单端数组

与普通数组的区别：

不同之处在于数组是静态空间，而vector可以动态扩展
动态扩展：并不是在原空间之间继续扩展，而且寻找一片更大的内存空间，然后将原数据拷贝到新空间内，在释放原空间
vector容器迭代器是支持随机访问的迭代器

函数原型：

vector v;
vector v1(v.begin(),v.end()); //[begin,end),左闭右开区间内的元素拷贝给本身
vector v1(n,elem); //将n个elem拷贝给本身
vector v1(const vector &v); //拷贝构造函数

void vectorTest1(){
    //默认构造，原型：vector<T> v
    vector<int> v1;
    for(int i=0; i<5; i++) v1.push_back(i);
    printfVectorInt(v1);

    //通过区间内容进行构造，原型：vector(v.begin(),v.end());
    vector<int> v2(v1.begin(),v1.end());
    printfVectorInt(v2);

    //原型：vector(n,elem);
    vector<int> v3(5,v1[0]);
    printfVectorInt(v3);

    //拷贝构造,原型：vector v1(const vector &v);
    vector<int> v4(v3);
    printfVectorInt(v4);
}

4.2 vector赋值操作

函数原型：

vector& operator =(const vector &v);
assign(beg,end);//左闭右开区间内元素拷贝给自身
assign(n,elem); //将n个elem拷贝复制给本身

void vectorTest2(){
    vector<int> v1;
    for(int i=0; i<5; i++) v1.push_back(i);
    printfVectorInt(v1);

    //原型：vector& operator =(const vector &v);
    vector<int> v2 = v1;
    printfVectorInt(v2);

    //原型：assign(beg,end);
    vector<int> v3;
    v3.assign(v2.begin(), v2.end());
    printfVectorInt(v3);

    //原型：assign(n,elem);
    vector<int> v4;
    v4.assign(5,v3[0]);
    printfVectorInt(v4);
}

4.3 vector容量和大小

函数原型：

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

void vectorTest3(){
    vector<int> v1;
    for(int i=0; i<5; i++) v1.push_back(i);
    printfVectorInt(v1);

    //判断vector是否为空
    if(v1.empty()){
        cout << "vector为空" << endl;
    }else{
        cout << "vector容量=" << v1.capacity() << endl;
        cout << "vector元素个数=" << v1.size() << endl;
    }

    //容器变长,新位置插入默认值0，因为是int型
    v1.resize(7);
    printfVectorInt(v1);

    //容器变短，尾部超出vector长度，则删除默认元素
    v1.resize(3);
    printfVectorInt(v1);

    //容器变长，并新位置用插入5
    v1.resize(8,5);
    printfVectorInt(v1);
}

4.4 vector插入和删除

函数原型：

push_back(elem); //在尾部插入
pop_back(); //删除最后一个元素
insert(const_iterator pos,ele); //迭代器指向的位置pos插入元素ele,其余位置向后移动，空出一个位置
insert(const_iterator pos,int count,ele); //迭代器指向的位置pos插入n个元素ele
erase(const_iterator pos); //删除迭代器指向的pos位置元素
erase(const_iterator start,const_iterator end);//删除迭代器[start,end)区域的元素
clear(); //删除容器所有元素

4.5 vector数据存取

函数原型：

at(int index);
operator[index];
front(); //返回容器中第一个数据元素
back(); //返回容器中最好一个数据元素

4.6 vector互换容器

函刷原型：

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

当一个vector容器初始化的时候容量很大，但通过需求使用resize()将原空间大幅度缩减，但是容量并不会减少，就会产生空间浪费，此时可以使用swap创建一个匿名对象交换vector容器，交换后的容量将会与resize()缩减后的容量匹配；因为匿名对象处理完之后就会被回收，所以不必担心内存泄露。

vector (v).swap(v);

4.7 vector预留空间

描述：减少vector在动态扩展容量时的扩展次数

函数原型：

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

如果事先知道了需要的容量并且较大，则可以通过reserve进行预留空间
防止多次动态扩展空间，通过reserve预留空间之后，开辟次数则变为一次(量级匹配)

void vectorTest6(){
    vector<int> v1;
    v1.reserve(100);
    int *p = NULL;
    int count = 0;
    for(int i=0; i<100; i++) {
        v1.push_back(i);
        if(p != &v1[0]){
            p = &v1[0];
            count++;
        }
    }
    cout << "开辟了" << count << "次空间" << endl;
}

5 deque容器

5.1 deque容器基本概念

功能：双端数组，可以对头端进行插入删除操作

deque与vector的区别：

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

deque内部工作原理：

deque内部有一个中控器，维护每段缓冲区的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

deque容器的迭代器支持随机访问

5.2 deque构造函数

函数原型：

deque deq;
deque(beg,end);
deque(n,elem);
deque(const deque &deq);

void dequeTest1(){
    deque<int> deq1;
    //从头部添加数据
    for(int i=0; i<5;i++){
        deq1.push_front(i);
    }
    //从尾部添加数据
    for(int i=5; i<10;i++){
        deq1.push_back(i);
    }
    printf(deq1);//4,3,2,1,0,5,6,7,8,9,

    //区间元素赋值给deque容器本身
    deque<int> deq2(deq1.begin(),deq1.end());
    printf(deq2);//4,3,2,1,0,5,6,7,8,9,

    deque<int> deq3(deq1.size(),deq1[0]);
    printf(deq3);//4,4,4,4,4,4,4,4,4,4,

    //拷贝构造函数
    deque<int> deq4(deq3);
    printf(deq4);//4,4,4,4,4,4,4,4,4,4,
 }

5.3 deque赋值操作

函数原型：

deque operator =(const deque &deq);
assign(beg,end);
assign(n,elem);

5.4 deque大小操作

函数原型：

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

5.5 deque插入和删除

函数原型：

两端插入操作：
- push_back(elem);//尾法
- push_front(elem);//头插
- pop_back();//尾删
- pop_front();//头删
指定位置操作：
- insert(pos,elem);
- insert(pos,n,elem);
- insert(pos,beg,end);
- clear();
- erase(beg,end);
- erase(pos);

void dequeTest2(){
    deque<int> deq1;
    //从头部添加数据
    for(int i=5; i>0;i--){
        deq1.push_front(i);
    }
    //从尾部添加数据
    for(int i=6; i<=10;i++){
        deq1.push_back(i);
    }
    printf(deq1);//1,2,3,4,5,6,7,8,9,10,

    //头删
    deq1.pop_front();
    printf(deq1);//2,3,4,5,6,7,8,9,10,

    //尾删
    deq1.pop_back();
    printf(deq1);//2,3,4,5,6,7,8,9,

    //指定位置插入
    deq1.insert(deq1.begin(), 1);
    printf(deq1);//1,2,3,4,5,6,7,8,9,

    //在指定位置插入n次element元素
    deq1.insert(deq1.begin(),2,0);
    printf(deq1);//0,0,1,2,3,4,5,6,7,8,9,

    deque<int> deq2;
    deq2.push_back(10);
    deq2.push_back(11);

    //将deq2区间内元素通过尾插到deq1中
    deq1.insert(deq1.end(), deq2.begin(),deq2.end());
    printf(deq1);//0,0,1,2,3,4,5,6,7,8,9,10,11,

    deque<int>::iterator it = deq1.begin();
    //指针向下移动一个位置
    it++;
    //删除指定位置元素，需要迭代器作为参数
    deq1.erase(it);//删除之后，指针相当于向前移动一个位置
    printf(deq1);//0,1,2,3,4,5,6,7,8,9,10,11,


    //范围性删除，左闭右开
    deq1.erase(it,it+5);
    printf(deq1);//5,6,7,8,9,10,11,

    //清空容器内元素
    deq1.clear();
    printf(deq1);
}

5.6 deque 数据存取

函数原型：

at(int index);
operator [] (int indext);
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

5.7 deque排序

函数原型：

sort(iterator beg,iterator end); //默认排序是升序

6 stack容器

6.1 stack基本概念

概念：

stack是一种先进后出(First In Last Out)的数据结构
尾部称为栈底，头部称为栈顶；
stack是一种受限序列，只允许在栈顶进行插入和删除
栈内插入数据称为入栈，栈内删除数据称为出栈

6.2 stack常用接口

构造函数：
- stack stack;
- stack(const stack &s); //拷贝构造函数
赋值操作：
- stack& operator = (const stack &s);
数据存取：
- push(elem); //栈顶插入元素
- pop(); //栈顶删除元素
- top(); //返回栈顶元素
大小操作：
- empty(); //判断栈是否为空
- size(); //返回栈的大小

7 queue容器

7.1 queue 基本概念

概念：

queue是一种先进先出(First In First Out)的数据结构，允许在两端进行操作
queue只允许在队尾进行插入，队头进行删除
队内插入数据称为入队，队内删除数据称为出队

7.2 queue 常用接口

构造函数：
- queue que;
- queue(const queue &s); //拷贝构造函数
赋值操作：
- queue& operator = (const queue &q);
数据存取：
- push(elem); //队尾插入元素
- pop(); //队头删除元素
- back(); //返回队内第一个元素元素
- top(); //返回队内最后一个元素元素
大小操作：
- empty(); //判断队是否为空
- size(); //返回队的大小

8 list容器

8.1 list基本概念

描述：

使用链式存储
物理存储单元非连续，通过额外的指针记录元素之间的关系
一个数据结点由数据域和指针域组成
STL的链表是一个双向循环链表
链表的迭代器属于双向迭代器

插入和删除操作不会造成原有list迭代器的实效(在list中删除一个数据记录，非当前迭代器所指位置，则不会对迭代器造成影响)，这在vector不成立

优点：

采用动态存储分配，不会造成内存的浪费和溢出
链表对插入和删除操作十分便利

缺点：

空间（指针域）和时间（遍历）额外耗费较大

8.2 list构造函数

函数原型：

list list;
list;
list(n,elem);
list(const list &l);

8.3 list赋值和交换

函数原型：

assign(beg,end);
assign(n,elem);
list& operator = (const list &l);
swap(list);

8.4 list大小操作

函数原型：

size();
empty();
resize(num);
resize(num,elem);

8.5 list插入和删除

函数原型：

两端插入操作：
- push_back(elem);//尾法
- pop_back();//尾删
- push_front(elem);//头插
- pop_front();//头删
指定位置插入操作：
- insert(pos,elem);

insert(pos,n,elem);

insert(pos,beg,end);

删除操作：
- clear();

erase(beg,end);

erase(pos);
remove(elem); //删除容器中所有与elem匹配的元素

void listTest1(){
    list<int> l;
    for(int i=5; i<=10; i++) l.push_back(i);//尾插
    for(int i=4; i>=0; i--) l.push_front(i);//头插
    printfList(l);//0 1 2 3 4 5 6 7 8 9 10

    l.pop_front();//头删
    printfList(l);//1 2 3 4 5 6 7 8 9 10
    l.pop_back();//尾删
    printfList(l);//1 2 3 4 5 6 7 8 9

    list<int>::iterator it = l.begin();
    l.insert(it, 0);//在第一个元素位置插入一个0
    printfList(l);//0 1 2 3 4 5 6 7 8 9

    l.erase(it);//因为上述插入操作在第一个位置进行插入，完成后迭代器指针后移，所以此时删除的是第二个元素位置的内容
    printfList(l);//0 2 3 4 5 6 7 8 9

    l.remove(5); //删除容器内所有与elemnt匹配的元素
    printfList(l);//0 2 3 4 6 7 8 9

    l.clear(); //清空容器内所有元素
}

8.6 list数据存取

函数原型：

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

8.7 list反转和排序

函数原型：

reverse(); //反转链表
sort(); //链表排序

bool compare(int a,int b){
    return a>b;
}
void listTest3(){
    list<int> l;
    l.push_back(20);
    l.push_back(10);
    l.push_back(40);
    l.push_back(30);

    l.sort();//默认从小到大升序排序
    printfList(l);

    //自定义一个函数，在其中实现降序定义，例如第一个数大于第二个数为真，则为降序
    l.sort(compare);
    printfList(l);
}

对自定义数据类型进行排序

class Student{
    string name;
    int age;
public:
    Student(string name,int age){
        this->name = name;
        this->age = age;
    }

    string getName(){
        return this->name;
    }

    int getAge(){
        return this->age;
    }
};
void printfStudent(list<Student> &l){
    for_each(l.begin(), l.end(), [](Student stu){
        cout << "名字=" << stu.getName() << " " << "年龄=" << stu.getAge() << endl;
    });
    cout << endl;
}

//升序
bool StuCompare(Student &stu1,Student &stu2){
    return stu1.getAge() < stu2.getAge();
}

void listTest4(){
    list<Student> stus;
    stus.push_back(Student("张三",20));
    stus.push_back(Student("李四",40));
    stus.push_back(Student("王五",10));
    stus.push_back(Student("赵二",30));

    stus.sort(StuCompare);
    printfStudent(stus);
}

9 set 容器和multiset

9.1 简述

基本概念：

所有元素都会在插入时自动被排序
set/multiset属于关联式容器，底层结构是用二叉树实现

set/multiset的区别：

set不允许容器中有重复的元素，如果插入重复的元素，set会默认忽视此元素

multiset允许容器中有重复的元素

9.2 set构造和赋值

构造：

set st;
set(const set &st);

赋值:

set& operator =(const set &st);

void setTest1(){
    //默认构造函数
    set<int> s1;
    for(int i=0; i<50; i+=10){
        s1.insert(i);
    }
    printfSet(s1);//0 10 20 30 40

    ///set容器会对插入的元素进行默认排序且不允许出现重复元素
    ///如果插入的重复元素，set会自动忽视这个元素，则不进行插入
    set<int> s2;
    s2.insert(20);
    s2.insert(0);
    s2.insert(10);
    s2.insert(40);
    s2.insert(30);
    printfSet(s2);//0 10 20 30 40

    //拷贝构造函数
    set<int> s3(s2);
    printfSet(s3);//0 10 20 30 40

    //赋值
    set<int> s4 = s3;
    printfSet(s3);//0 10 20 30 40
}

int main(int argc, const char * argv[]) {
    setTest1();
    return 0;
}

9.3 set大小和交换

函数原型：

size();
empty();
swap(st);

9.4 set插入和删除

函数原型：

insert(elem);
clear();
erase(pos);
erase(beg,end);
erase(elem);

9.5 set查找和统计

find(key); //若key存在，则返回该key的元素迭代器；反之，返回end()迭代器
count(key);//统计key的元素个数，对于set容易不允许插入重复元素，故结果只在0和1之间

9.6 pair 对组容器

描述：

成对出现的数据，利用对组可以返回两个数据

创建方式：

pari p(value1,value2);
pair p = make_pair(value1,value2);

9.7 set容器排序

描述：

set默认插入排序规则是从小到大，可以通过仿函数进行改变排序规则

class MyCompare{
public:
    bool operator()(int a,int b){
        return a>b;
    }
};
...
void setTest2(){
    set<int> s1;
    //默认从小到大
    for(int i=0; i<50; i+=10){
        s1.insert(i);
    }
    printfSet(s1);

    //通过仿函数，改变排序规则，从大到小
    set<int,MyCompare> s2;
    for(int i=0; i<50; i+=10){
        s2.insert(i);
    }
    printfSet(s2);
}

9.8 改变自定义数据类型set排序规则

通过将自定义数据类型Student的进行排序，按其成员字段age从大到小进行降序排序

class Student{
public:
    string name;
    int age;

    Student(string name,int age){
        this->name = name;
        this->age = age;
    }
};
...
class MyCompare{
public:
    bool operator()(Student a,Student b){
        return a.age > b.age;
    }
};
...
void setTest3(){
    set<Student,MyCompare> s1;
    s1.insert(Student("张三",20));
    s1.insert(Student("李四",10));
    s1.insert(Student("王五",40));
    s1.insert(Student("赵二",30));

    printfSet(s1);
}

10 map和multimap容器

10.1 map基本概念

描述：

map的所以元素都是pair
pair中第一个元素为key-键值，起到索引作用；第二个元素为value-实值
所有元素都会根据元素的键值自动排序
map/multimap属于关联式容器，底层结果使用二叉树实现

优点：

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

map/multimap区别

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

10.2 map构造和赋值

函数原型：

构造：
- map mp;
- map(const map &mp);
赋值
- map & operator = (const map &mp);

10.3 map大小和交换

函数原型：

size();
empty();
swap(st);

10.4 map 插入和删除

函数原型：

insert(elem);
clear();
erase(pos);
erase(begin,end);
erase(key);

void printfMap(map<string,int> &m){
    for_each(m.begin(), m.end(), [](pair<string, int> value){
        cout << "name=" << value.first << " " << "age=" << value.second << endl;
    });
}
void mapTest1(){
    map<string,int> map1;
    ///下列四种方式都可以实现插入map数据
    ///默认通过key值进行升序排序
    map1.insert(pair<string, int>("peter",12));
    map1.insert(make_pair("jerry", 24));
    map1.insert(map<string,int>::value_type("liszt",30));
    //若执行map1["www"]；没有找到"www"所管理的值，则会默认创建一个以“www”为key值的默认数据类型值的数据
    map1["franz"] = 7;
    printfMap(map1);

    //通过key值进行删除
    map1.erase("jerry");
    printfMap(map1);
}

10.5 map查找和统计

函数原型：

find(key);
count(key);

10.6 map排序

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

class MyCompare{
public:
    bool operator()(string a, string b){
        return a > b;
    }
};

void printfMap(map<string,int,MyCompare> &m){
    for_each(m.begin(), m.end(), [](const pair<string, int> &value){
        cout << "name=" << value.first << " " << "age=" << value.second << endl;
    });
}

void mapTest2(){
    map<string,int,MyCompare> map1;
    map1.insert(make_pair("jack", 14));
    map1.insert(make_pair("jerry", 24));
    map1.insert(make_pair("liszt", 4));
    printfMap(map1);
}

int main(int argc, const char * argv[]) {
    mapTest2();
    return 0;
}

11 函数对象

11.1 函数对象

概念：

重载函数调用操作符的类,其对象称为函数对象
函数对象使用重载的()时，行为类似函数调用，也称为仿函数
函数对象(仿函数)是一个类，不是一个函数

特点：

函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递

class MyAdd{
public:
    int operator() (int a, int b){
        return a+b;
    }
};
///函数对象可以作为参数传递
void doAdd(MyAdd &add){
    cout << "result=" << add(20,20) << endl;
}
void test1(){
    //构建函数对象
    MyAdd add;
    cout << "result=" << add(10,20) << endl;
    doAdd(add);
}

11.2 谓词

概念：

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，称为一元谓词
如果operator()接受俩个参数，称为二元谓词

///一元谓词
bool FindNumber(int a){
    return a > 5;
}
void test2(){
    vector<int> v1;
    for(int i=0; i<10; i++){
        v1.push_back(i);
    }
    ///find_if如果条件成立，则返回元素迭代器位置；未找到，则返回end()迭代器
    vector<int>::iterator it = find_if(v1.begin(), v1.end(),FindNumber);

    if(it == v1.end()){
        cout << "没有大于5的数字" << endl;
    }else{
        cout << "result=" << *it << endl;
    }
}

11.3 内建函数对象

分类：

算术仿函数
关系仿函数
逻辑仿函数
引用时，需要导入#include

11.3.1 算术仿函数

功能描述：

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

仿函数原型：

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

///取反反函数
void test3(){
    negate<int> n;
    cout << "50的相反数=" << n(50) << endl;
 }

///加法仿函数
void test4(){
    plus<int> p1;

    cout << "10 + 20 = " << p1(10,20) << endl;
}

11.3.2 关系仿函数

仿函数原型：

template bool equal //等于
template bool not_equal //不等于
template bool greater //大于
template bool greater_equal //大于等于
template bool less //小于等于
template bool less_equal //小于等于

void test5(){
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(5);
    v1.push_back(20);

    //使用内置的greater仿函数，作为使用降序
    sort(v1.begin(), v1.end(), greater<int>());

    for_each(v1.begin(), v1.end(), [](int num){
        cout << num << " ";
    });
    cout << endl;
}

11.3.3 逻辑仿函数

仿函数原型：

template bool logical_and //逻辑与
template bool logical_or //逻辑或
template bool logical_not //逻辑非

void test01()
{
    vector<bool>v;
    v.push_back(true);
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);

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

    //利用逻辑非    将容器v搬运到    容器v2中，并执行取反操作
    vector<bool>v1;
    v1.resize(v.size());
    // transform  必须先开辟空间指定大小v1.resize(v.size()); 在执行搬运
    transform(v.begin(), v.end(), v1.begin(), logical_not<bool>());

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

12 常用算法

概述：

算法主要由头文件、、组成
是STL中头文包含最广的之一，涉及范围包括：比较、交换、查找、遍历、复制、修改等
包括几个在序列上进行简单运算的模版函数
包括函数对象等模版类

12.1 常用遍历算法

描述：

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

12.1.1 for_each

函数原型：

for_each(iterator beg,iterator end,_func);

12.1.2 transform

函数原型：

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

class MyTransform{
public:
    int operator()(int a){
        return a;
    }
};

void printf(vector<int> &v){
    for_each(v.begin(), v.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}
void test1(){
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);


    vector<int> v2;
    //需要给目标容器开辟空间
    v2.resize(v1.size());
    transform(v1.begin(), v1.end(), v2.begin(),MyTransform());
    printf(v2);
}

12.2 常用查找算法

描述：

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

12.2.1 find

函数原型：

find(iterator beg,iterator end,value);

查找内置数据类型：

void test2(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    //如果找到这个元素，则返回key的迭代器位置；否则，容器的end()迭代器
    vector<int>::iterator it =  find(v1.begin(), v1.end(),3);
    if(it != v1.end()){
        cout << "success" << endl;
    }else{
        cout << "failed" << endl;
    }
}

查找自定义数据类型：

class Student{

public:
    string name;
    int age;
    Student(string name,int age){
        this->name = name;
        this->age = age;
    }

    bool operator == (const Student &stu){
        return (this->name == stu.name) && (this->age == stu.age);
    }
};
...
void test3(){
    vector<Student> stus;
    Student zhangsan("张三",20);
    Student lisi("李四",30);
    Student wangwu("王五",40);
    stus.push_back(zhangsan);
    stus.push_back(lisi);
    stus.push_back(wangwu);

    ///对自定义数据类型进行遍历，需要重写操作法==
    vector<Student>::iterator it =  find(stus.begin(), stus.end(), Student("张三",20));
    if(it != stus.end()){
        cout << "success" << endl;
    }else{
        cout << "failed" << endl;
    }
}

12.2.2 find_if

函数原型：

find_if(iterator beg,iterator end,_pred);

条件查询内置数据类型：

///一元谓词
bool find_number(int num){
    return num >= 4;
}

void test4(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    vector<int>::iterator it = find_if(v1.begin(), v1.end(), find_number);
    if(it != v1.end()){
        cout << "success" << endl;
    }else{
        cout << "failed" << endl;
    }
}

条件查询自定义数据类型：

bool find_student(const Student &stu){
    return stu.age > 30;
}
void test5(){
    vector<Student> stus;
    Student zhangsan("张三",20);
    Student lisi("李四",30);
    Student wangwu("王五",40);
    stus.push_back(zhangsan);
    stus.push_back(lisi);
    stus.push_back(wangwu);

    ///对自定义数据类型进行遍历，需要重写操作法==
    vector<Student>::iterator it =  find_if(stus.begin(), stus.end(), find_student);
    if(it != stus.end()){
        cout << "success" << endl;
    }else{
        cout << "failed" << endl;
    }
}

12.2.3 adjacent_find

函数原型：

adjacent_find(iterator beg,iterator end); //查找相邻重复元素

返回第一个相邻元素的迭代器

void test6(){
    vector<int> v1;
    v1.push_back(1);
    v1.push_back(0);
    v1.push_back(1);
    v1.push_back(3);//和下一个3相邻且相邻，返回次元素迭代器
    v1.push_back(3);

    vector<int>::iterator it = adjacent_find(v1.begin(), v1.end());
    if(it != v1.end()){
        cout << "success" << endl;
    }else{
        cout << "failed" << endl;
    }
}

12.2.4 binary_search

函数原型：

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

需要查找序列有序，如果无序不会报逻辑错误，只是查找算法失效

void test7(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    bool result = binary_search(v1.begin(), v1.end(), 2);
    if(result){
        cout << "success" << endl;
    }else{
        cout << "failed" << endl;
    }
}

12.2.5 count

函数原型：

count(iterator beg,iterator end,value); //返回容器中与value相同的元素个数

统计内置数据类型：

void test8(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    v1.push_back(4);
    int num = count(v1.begin(), v1.end(),4 );
    cout << "容器中存在" << num << "个与数字4相同的数据" << endl;
}

统计自定义数据类型：

class Student{

public:
    string name;
    int age;
    Student(string name,int age){
        this->name = name;
        this->age = age;
    }

    bool operator == (const Student &stu){
        return this->age == stu.age;
    }

};
...
void test9(){
    vector<Student> stus;
    Student zhangsan("张三",20);
    Student lisi("李四",30);
    Student wangwu("王五",20);

    stus.push_back(zhangsan);
    stus.push_back(lisi);
    stus.push_back(wangwu);

    Student zhangsi("张三",20);

    int num = count(stus.begin(), stus.end(), zhangsan);
    cout << "容器中存在" << num << "个与年龄为20的人" << endl;
}

12.2.6 count_if

函数原型：

count_if(iterator beg,iterator end,_pred);

条件统计内置数据类型：

bool count_less_3(int num){
    return num < 3;
}
void test10(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    int num = count_if(v1.begin(), v1.end(), count_less_3);
    cout << "小于3的数据条数有：" << num << endl;
}

条件统计自定义数据类型：

bool count_age_pass_20(const Student &stu){
    return stu.age > 20;
}
void test11(){
    vector<Student> stus;
    Student zhangsan("张三",20);
    Student lisi("李四",30);
    Student wangwu("王五",20);
    Student zhaoer("赵二",50);

    stus.push_back(zhangsan);
    stus.push_back(lisi);
    stus.push_back(wangwu);
    stus.push_back(zhaoer);

    int num = count_if(stus.begin(), stus.end(), count_age_pass_20);
    cout << "年龄大于20的数据条数有：" << num << endl;
}

12.3 常用排序算法

描述：

sort
random_shuffle //将指定范围你的元素随机调整次序
merge //容器元素合并，并存储到另一容器中
reverse //反转指定范围的元素

12.3.1 sort

函数原型：

sort(iterator beg,iterator end,_pred);

bool sort_less(int a,int b){
    return a > b;
}
void test12(){
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(50);
    v1.push_back(30);
    v1.push_back(20);
    //默认升序
    sort(v1.begin(), v1.end());
    for_each(v1.begin(), v1.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
    //sort(v1.begin(), v1.end(),sort_less);
    //内置降序
    sort(v1.begin(), v1.end(),greater<int>());
    for_each(v1.begin(), v1.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.3.2 random_shuffle

函数原型：

random_shuffle(iterator beg,iterator end);

12.3.3 merge

函数原型：

两个容器必须是有序的，将俩个容器合并到另一容器

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

void test14(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }

    vector<int> v2;
    for(int i=5;i<10;i++){
        v2.push_back(i);
    }
    //给目标容器分配空间
    vector<int> v3;
    v3.resize(v1.size()+v2.size());
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());

    for_each(v3.begin(), v3.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.3.4 reverse

函数原型：

容器内元素反转

reverse(iterator beg,iterator end);

void test15(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    reverse(v1.begin(), v1.end());
    for_each(v1.begin(), v1.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.4 常用拷贝和替换算法

描述：

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

12.4.1 copy

函数原型：

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

void test16(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    vector<int> v2;
    v2.resize(v1.size());
    copy(v1.begin(), v1.end(), v2.begin());
    for_each(v2.begin(), v2.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.4.2 replace

函数原型：

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

void test17(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    //将容器内容为2的元素替换为0
    replace(v1.begin(), v1.end(), 2, 0);
    for_each(v1.begin(), v1.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.4.3 replace_if

函数原型：

replace_if(iterator beg,iterator end,_pred,newvalue);

bool replace_condition(int num){
    return num > 2;
}
void test18(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    //将容器大于2的元素替换为0
    replace_if(v1.begin(), v1.end(), replace_condition, 0);
    for_each(v1.begin(), v1.end(), [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.4.4 swap

函数原型:

swap(container c1,container c2);

void test19(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    vector<int> v2;
    for(int i=5;i<10;i++){
        v2.push_back(i);
    }
    cout << "before swap v1:";
    printf(v1);
    cout << "before swap v2:";
    printf(v2);
    swap(v1, v2);
    cout << "after swap v1:";
    printf(v1);
    cout << "after swap v2:";
    printf(v2);
}

12.5 常用算法生成算法

描述：

下列算法包含于#include头文件内
accumulate
fill

12.5.1 accumulate

函数原型：

计算容器内元素总和

accumulate(iterator beg,iterator end,value);

void test20(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(i);
    }
    //最后面那个0是初始值
    int sum = accumulate(v1.begin(), v1.end(), 0);
    cout << "result=" << sum << endl;
}

12.5.2 fill

函数原型：

向容器内填充指定的元素

fill(iterator beg,iterator end,value);

void test21(){
    vector<int> v1;
    for(int i=0;i<5;i++){
        v1.push_back(0);
    }
    //将容器内指定范围的元素填充为对应元素
    fill(v1.begin(), v1.end(), 1);
    printf(v1);
}

12.6 常用集合算法

描述：

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

12.6.1 set_intersection

函数原型：

set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

void test22(){
    vector<int> v1;
    for(int i=0;i<7;i++){
        v1.push_back(i);
    }

    vector<int> v2;
    for(int i=2;i<10;i++){
        v2.push_back(i);
    }
    vector<int> v3;
    int size = min(v1.size(), v2.size());
    v3.resize(size);
    //set_intersection会返回交集的最后一个迭代器位置
    vector<int>::iterator itEnd =  set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
    ///如果此处使用v3.end()作为结束迭代器，如果容器的空间大于交集元素，则会默认填充0(int)，则会导致遍历容器，非交集元素0也会被输出
    ///使用set_intersection返回的结束迭代器为最后一个交集元素的下一个位置，则不会输出0
    for_each(v3.begin(), itEnd, [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.6.2 set_union

函数原型：

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

void test23(){
    vector<int> v1;
    for(int i=0;i<7;i++){
        v1.push_back(i);
    }

    vector<int> v2;
    for(int i=2;i<10;i++){
        v2.push_back(i);
    }
    vector<int> v3;
    int size = max(v1.size(), v2.size());
    v3.resize(size);
    vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
    for_each(v3.begin(), itEnd, [](int value){
        cout << value << " ";
    });
    cout << endl;
}

12.6.3 set_different

差集：

不是交集的部分
分v1对v2和v2对v1两种情况
- 例如v1:1 2 3 4 5. v2: 3 4 5 6 7
- 则v1对v2的差集 = 1 2
- v2对v1的差集 = 6 7

函数原型：

set_different(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)

void test24(){
    vector<int> v1;
    for(int i=1;i<6;i++){
        v1.push_back(i);
    } //1 2 3 4 5

    vector<int> v2;
    for(int i=3;i<8;i++){
        v2.push_back(i);
    }//3 4 5 6 7
    vector<int> v3;
    int size = max(v1.size(), v2.size());
    v3.resize(size);
    //v1对v2的差集
    vector<int>::iterator itEnd1 = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
    for_each(v3.begin(), itEnd1, [](int value){
        cout << value << " ";
    });//1 2
    cout << endl;
    //v2对v1的差集
    vector<int>::iterator itEnd2 = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v3.begin());
    for_each(v3.begin(), itEnd2, [](int value){
        cout << value << " ";
    });//6 7
    cout << endl;
}

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++ STL篇

1 STL

1.1 STL的诞生

1.2 STL基本概念

1.3 STL六大部件

1.4 容器概念

1.5 算法概念

1.6 迭代器概念

2 初识容器算法迭代器

2.1 vector存放内置数据类型

2.2 vector存放自定义数据类型

2.3 Vector容器嵌套

3 string容器

3.1 string构造函数

3.2 string赋值操作

3.3 string字符串拼接

3.4 string查找和替换

3.5 string字符串比较

3.6 string字符存取

3.7 string插入和删除

3.8 string子串

4 vector容器

4.1 vector概念

4.2 vector赋值操作

4.3 vector容量和大小

4.4 vector插入和删除

4.5 vector数据存取

4.6 vector互换容器

4.7 vector预留空间

5 deque容器

5.1 deque容器基本概念

5.2 deque构造函数

5.3 deque赋值操作

5.4 deque大小操作

5.5 deque插入和删除

5.6 deque 数据存取

5.7 deque排序

6 stack容器

6.1 stack基本概念

6.2 stack常用接口

7 queue容器

7.1 queue 基本概念

7.2 queue 常用接口

8 list容器

8.1 list基本概念

8.2 list构造函数

8.3 list赋值和交换

8.4 list大小操作

8.5 list插入和删除

8.6 list数据存取

8.7 list反转和排序

9 set 容器和multiset

9.1 简述

9.2 set构造和赋值

9.3 set大小和交换

9.4 set插入和删除

9.5 set查找和统计

9.6 pair 对组容器

9.7 set容器排序

9.8 改变自定义数据类型set排序规则

10 map和multimap容器

10.1 map基本概念

10.2 map构造和赋值

10.3 map大小和交换

10.4 map 插入和删除

10.5 map查找和统计