STL（Standard Template Library，标准

STL六大组件

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

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

迭代器种类：数组, 链表,树, 栈, 队列, 集合, 映射表

种类	功能	支持运算
string 字符串	赋值, 拼接, 查找和替换, 比较, 存取, 插入与删除	=, assign, +=, append, find, rfind, replace, compare, [], at, insert, erase
vector 单端数组	赋值, 容量和大小, 插入和删除, 存取, 元素互换, 预留空间	=, assign, empty, capacity, size, resize, push_back, pop_back, insert, erase, clear, at, [], front, back, swap, reverse
deque 双端数组	赋值, 大小操作, 插入与删除, 数据存取, 排序	=, assign, empty, size, resize, push_back, push_front, pop_back, pop_front, insert, clear, erase, at, [], front, back, sort
stack 栈	赋值, 存取, 大小	=, push, pop, top, empty, size
queue 队列	赋值, 存取, 大小	=, push, pop, back, front, empty, size
list 链表	赋值和交换, 大小操作, 插入与删除, 存取, 反转, 排序	=, assign, swap, empty, size, resize, push_back, pop_back, push_front, pop_front, insert, clear, erase, remove, front, back, reverse, sort
set/multiset 集合	赋值, 大小和交换, 插入与删除, 查找与统计, 队组创建, 排序(默认从小到大)	=, empty, size, swap, insert, clear, erase, find, count, pair
map/multimap 映射表	赋值, 大小和交换, 插入与删除, 查找与统计, 排序(默认从小到大)	=, empty, size, swap, insert, clear, erase, find, count

字符串赋值

• 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赋给当前字符串

字符串拼接

• 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个字符连接到字符串结尾

字符串查找与拼接

• 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

字符串比较

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

字符串存取

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

字符串插入与删除

• 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个字符

字符串字串

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

vector数组赋值

• vector& operator=(const vector &vec);//重载等号操作符
• assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
• assign(n, elem); //将n个elem拷贝赋值给本身。

vector容量和大小

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

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(); //删除容器中所有元素

vector数据存取

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

vector互换容器

• swap(vec); // 将vec与本身的元素互换，swap可以使两个容器互换，可以达到实用的收缩内存效果

vector预留空间

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

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

deque赋值操作

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

deque大小操作

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

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位置的数据，返回下一个数据的位置。

deque 数据存取

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

deque 排序

• sort(iterator beg, iterator end) //对beg和end区间内元素进行排序

stack栈

构造函数：

• stack<T> stk; //stack采用模板类实现， stack对象的默认构造形式
• stack(const stack &stk); //拷贝构造函数
  赋值操作：
• stack& operator=(const stack &stk); //重载等号操作符
  数据存取：
• push(elem); //向栈顶添加元素
• pop(); //从栈顶移除第一个元素
• top(); //返回栈顶元素
  大小操作：
• empty(); //判断堆栈是否为空
• size(); //返回栈的大小

queue队列

构造函数：

• queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
• queue(const queue &que); //拷贝构造函数
  赋值操作：
• queue& operator=(const queue &que); //重载等号操作符
  数据存取：
• push(elem); //往队尾添加元素
• pop(); //从队头移除第一个元素
• back(); //返回最后一个元素
• front(); //返回第一个元素
  大小操作：
• empty(); //判断堆栈是否为空
• size(); //返回栈的大小

list链表

函数原型：

• list<T> lst; //list采用采用模板类实现,对象的默认构造形式：
• list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。
• list(n,elem); //构造函数将n个elem拷贝给本身。
• list(const list &lst); //拷贝构造函数。
  赋值和交换
• assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
• assign(n, elem); //将n个elem拷贝赋值给本身。
• list& operator=(const list &lst); //重载等号操作符
• swap(lst); //将lst与本身的元素互换。
  大小操作
• size(); //返回容器中元素的个数
• empty(); //判断容器是否为空
• resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
• resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
  插入与删除
• 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值匹配的元素。
  list存取
• front(); //返回第一个元素。
• back(); //返回最后一个元素。

list反转和排序

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

set/multiset 集合-底层使用二叉树实现

• set不允许容器中有重复的元素
• multiset允许容器中有重复的元素
• set不可以插入重复数据，而multiset可以
• set插入数据的同时会返回插入结果，表示插入是否成功
• multiset不会检测数据，因此可以插入重复数据
  构造和赋值
• set<T> st; //默认构造函数：
• set(const set &st); //拷贝构造函数
  赋值：
• set& operator=(const set &st); //重载等号操作符
  大小和交换
• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器
  插入与删除
• insert(elem); //在容器中插入元素。
• clear(); //清除所有元素
• erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
• erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
• erase(elem); //删除容器中值为elem的元素。
  查找与统计
• find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
• count(key); //统计key的元素个数
  pair对组创建
• pair<type, type> p ( value1, value2 );
• pair<type, type> p = make_pair( value1, value2 );
  set排序
• set容器默认排序规则为从小到大，掌握如何改变排序规则
  主要技术点：
• 利用仿函数，可以改变排序规则

map/multimap映射表

构造和赋值
构造：

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

赋值：

• map& operator=(const map &mp); //重载等号操作符
  大小和交换

• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器
  插入与删除
• insert(elem); //在容器中插入元素。m.insert(pair<int, int>(1, 10));以对组的形式插入新元素
• clear(); //清除所有元素
• erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
• erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
• erase(key); //删除容器中值为key的元素。
  查找与统计
• find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
• count(key); //统计key的元素个数

二重排序-使用仿函数

案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

#include <list>
#include <string>
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<Person> 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<Person>::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<Person>::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;
}