C++ 模版与容器

chincch

已于 2024-07-14 13:08:04 修改

阅读量602

点赞数 26

分类专栏： C++ 文章标签： c++

于 2024-07-07 21:56:32 首次发布

本文链接：https://blog.csdn.net/weixin_44095857/article/details/140253203

版权

C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 模板

1.1 概念

模板 - 通用模具，大大提高复用性

模板不可以直接使用，它只是一个框架
模板的通用并不是万能的

1.2 函数模板

C++另一种编程思想称为泛型编程，主要利用的技术就是模板；
C++提供两种模板机制：函数模板和类模板。

1.2.1 函数模板

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

template<typename T>
函数声明或定义

template — 声明创建模板；

typename — 表面其后面的符号是一种数据类型，可以用class代替；

T — 通用的数据类型，名称可以替换，通常为大写字母；

template<typename T>
void func_swap(T& a, T& b) {
  T temp = a;
  a = b;
  b = temp;
}

int a = 20; int b = 10;
swap(a, b);  // 自动类型推导
swap<int>(a, b);  // 显式指定类型

自动类型推导，必须推导出一致的数据类型T，才可以使用；
模板必须要确定出T的数据类型并且能推导出一致的类型才可以使用；

template<typename T>
void func() {
  cout << "func" << endl;
}
func<void>();  // 必须确定T的类型

1.2.2 普通函数与函数模板

区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）；
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；
如果利用显示指定类型（推荐）的方式，可以发生隐式类型转换；

调用规则：

如果函数模板和普通函数都可以实现，优先调用普通函数；
可以通过空模板参数列表func<>(...)来强制调用函数模板；
函数模板也可以发生重载，不过，既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性；
如果函数模板可以产生更好的匹配，优先调用函数模板；

1.2.3 模板的局限性

如果T的数据类型传入的是自定义数据类型，将无法正常运行；

为了解决该问题，C++提供模板的重载，为特定类型提供具体化的模板：

template<typename T>
bool compareFunc(T& a, T& b) {
  if (a == b) {return true;}
  else {return false;}}
  
template<> bool compareFunc(Person& p1, Person& p2) {
  if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age) {  return true;}
  else {return false;}}

1.3 类模板

1.3.1 类模板语法

类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。

template<typename T>
类

template — 声明创建模板；
typename — 表面其后面的符号是一种数据类型，可以用class代替；
T — 通用的数据类型，名称可以替换，通常为大写字母；

template<class NameType, class AgeType>
class Person {
public:
  Person(NameType name, AgeType age) {
    this->m_Name = name;
    this->m_Age = age;}
  NameType m_Name;
  AgeType m_Age;};

与函数模板的区别：

类模板没有自动类型推导的使用方式，只能显式指定；
类模板在模板参数列表中可以有默认参数template<class NameType, class AgeType = int>；

1.3.2 类模板中成员函数创建时机

普通类中的成员函数一开始就可以创建，类模板中的成员函数在调用时才创建。

1.3.3 类模板对象做函数参数

指定传入的类型 — 直接显示对象的数据类型Person<string, int>&p；
参数模板化 — 将对象中的参数变为模板进行传递

template<class T1, class T2>
void printPerson2(Person<T1, T2>&p) {
  p.showPerson();
  cout << "type of T1 = " << typeid(T1).name() << endl;
  cout << "type of T2 = " << typeid(T2).name() << endl;}

整个类模板化 — 将这个对象类型模板化进行传递

template<typename T>
void printPerson3(T& p) {
  p.showPerson();
  cout << "type of T = " << typeid(T).name() << endl;}

1.3.4 类模板与继承

当子类继承的父类是一个类模板时，子类声明时要指定出父类中T的类型；
如果不指定，编译器无法给子类分配内存；
如果想灵活指定出父类中T的类型，子类也需变为类模板；

template<class T>
class Base {
  T m;
};
  
class Son : public Base<int> {};

template<class T1, class T2>
class Son2 : public Base<T2> {
public:
  Son2() {
    cout << "type of T1:" << typeid(T1).name() << endl;
    cout << "type of T2:" << typeid(T2).name() << endl;
  }
  T1 obj;
};

1.3.5 类模板成员函数类外实现

类模板中成员函数类外实现时，需要加上模板参数列表。

template <class T1, class T2>
Person<T1,T2>::Person(T1 name, T2 age) {
  this->m_Name = name;
  this->m_Age = age;
}

template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
  cout << "name = " << this->m_Name << ", age = " << this->m_Age << endl;
}

1.3.6 类模板分文件编写

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

直接包含.cpp源文件；
将声明和实现写到同一个文件中，并更改后缀名为.hpp（hpp是约定的名称，并不是强制）。

1.3.7 类模板与友元

全局函数的类内实现 — 直接在类内声明友元即可；（推荐）
全局函数的类外实现 — 需要提前让编译器知道全局函数的存在；

// 类的声明
template<class T1, class T2>
class Person;

// 函数模板的实现，写在最前面，提前让编译器知道函数存在（前面要有类的声明）
template<class T1, class T2>
void printPerson2(Person<T1, T2>& p) {
  cout << "name = " << p.m_Name << ", age = " << p.m_Age << endl;
}

2 STL初识

2.?.1 STL（Standard Template Library，标准模板库）基本概念

从广义上分为容器（container）、算法（algorithm）、 迭代器（iterator）；
容器和算法之间通过迭代器进行无缝连接。
STL 几乎所有的代码都采用了模板类或者模板函数

2.?.2 六大组件

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

2.?.3 容器

容器： 将运用最广泛的一些数据结构实现出来；

常用的数据结构有数组、链表、树、栈、队列、集合和映射表等，具体可分为序列式容器和关联式容器两种：

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

2.?.4 算法

算法： 用有限的步骤解决逻辑或数学上的问题，可分为质变算法和非质变算法。

质变算法：运算过程中会更改区间内元素内容，如拷贝，替换，删除等；
非质变算法：是指运算过程中不会更改区间内元素内容，如查找、计数、遍历、寻找极值等。

2.?.5 迭代器

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

每个容器都有自己专属的迭代器，迭代器使用非常类似于指针。

种类：

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

2.1 初识

2.1.1 vector遍历

  // 1. 
  vector<int>::iterator itBegin = v.begin();  // 起始迭代器，指向第一个元素的位置
  vector<int>::iterator itEnd = v.end();  // 起始迭代器，指向最后一个元素的下一个位置

  while (itBegin != itEnd) {
    cout << *itBegin << endl;
    itBegin++;}

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

  // 3. 利用stl中提供的遍历算法
  for_each(v.begin(), v.end(), myPrint);

  // vector< vector<int> > v;

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

3 STL常用容器

3.1 string容器

3.1.1 string基本概念

string和char * 区别：

char * 是一个指针
string是C++风格的字符串，本质上是一个类，类内部封装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初始化

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

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

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

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比较

3.1.7 string单个字符存取

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

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

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

3.1.9 string子串

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

3.2 vector容器

3.2.1 vector基本概念

vector数据结构和数组非常相似，也称为单端数组，不同之处在于数组是静态空间，而vector可以动态扩展（找更大的内存空间，然后将原数据拷贝新空间，释放原空间）。

vector容器的迭代器是支持随机访问（跳跃式访问）的迭代器。

3.2.2 vector构造函数

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

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

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

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

3.2.3 vector赋值操作

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

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

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

3.2.4 vector容量和大小

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

capacity(); // 容器的容量

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

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

resize(int num, elem); // 重新指定容器的长度为num，若容器变长，以elem值填充新位置

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

3.2.6 vector数据存取

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

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

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

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

3.2.7 vector互换容器

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

3.2.8 vector预留空间

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

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

3.3 deque容器

3.3.1 deque容器基本概念

vector对于头部的插入删除效率低，数据量越大，效率越低；
deque对头部的插入删除速度回比vector快；
vector访问元素时的速度会比deque快；

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据，中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。

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

3.3.2 deque构造函数

deque<T> deqT; // 默认构造形式

deque(beg, end); // 构造函数将[beg, end)区间中的元素拷贝给本身。

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

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

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

3.3.3 deque赋值操作

deque& operator=(const deque &deq); // 重载等号操作符

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

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

3.3.4 deque大小操作

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

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

deque.resize(num); // 重新指定容器的长度为num，容器变长时以默认值填充。
// 容器变短时末尾超出容器长度的元素被删除。

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

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

3.3.6 deque 数据存取

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

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

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

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

3.3.7 deque 排序

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

3.4 stack容器

3.4.1 stack 基本概念

stack是一种先进后出（First In Last Out，FILO）的数据结构，它只有一个出口

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。

3.4.2 stack 常用接口

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

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

赋值操作：

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

数据存取：

push(elem); // 向栈顶添加元素

pop(); // 从栈顶移除第一个元素

top(); // 返回栈顶元素

大小操作：

empty(); // 判断堆栈是否为空

size(); // 返回栈的大小

3.5 queue 容器

3.5.1 queue 基本概念

Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

队列容器允许从一端新增元素，从另一端移除元素；

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。

3.5.2 queue 常用接口

构造函数：

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

queue(const queue &que); // 拷贝构造函数

赋值操作：

queue& operator=(const queue &que); // 重载等号操作符

数据存取：

push(elem); // 往队尾添加元素

pop(); // 从队头移除第一个元素

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

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

大小操作：

empty(); // 判断堆栈是否为空

size(); // 返回栈的大小

3.6 list容器

3.6.1 list基本概念

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

链表由一系列结点组成，每个节点包含存储数据元素的数据域和存储下一个结点地址的指针域。

优点：

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

缺点：

链表灵活，但是空间(指针域) 和时间（遍历）额外耗费较大。

STL中的链表是一个双向循环链表，由于链表的存储方式并不是连续的内存空间，因此链表中的迭代器只支持前移和后移，属于双向迭代器。

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

3.6.2 list构造函数

list<T> lst; // 默认构造形式

list(beg,end); // 构造函数将[beg, end)区间中的元素拷贝给本身

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

list(const list &lst); // 拷贝构造函数

3.6.3 list 赋值和交换

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

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

list& operator=(const list &lst); // 重载等号操作符

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

3.6.4 list 大小操作

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

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

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

resize(num, elem); // 重新指定容器长度为num，容器变长时以elem值填充新位置。

3.6.5 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值匹配的元素。

3.6.6 list 数据存取

front(); // 返回第一个元素。

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

list容器中不可以通过[]或者at方式访问数据，不支持随机访问

3.6.7 list 反转和排序

reverse(); // 反转链表

sort(); // 链表排序

不支持随机访问的容器不可以使用sort(l.begin(), l.end())进行排序。

bool MyCompare(Person &p1, Person &p2) {
  // 按照年龄做升序
  if (p1.m_Age == p2.m_Age)
  {
    return p1.m_Height > p2.m_Height;
  }
  return p1.m_Age < p2.m_Age;
}
l.sort(MyCompare);

3.7 set/multiset 容器

3.7.1 set基本概念

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

3.7.2 set构造和赋值

构造：

set<T> st; // 默认构造函数：

set(const set &st); // 拷贝构造函数

赋值：

set& operator=(const set &st); // 重载等号操作符

set大小和交换

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

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

swap(st); // 交换两个集合容器

3.7.3 set插入和删除

insert(elem); // 在容器中插入元素。

clear(); // 清除所有元素

erase(pos); // 删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg, end); // 删除区间[beg,end)的所有元素，返回下一个元素的迭代器。

erase(elem); // 删除容器中值为elem的元素。

3.7.4 set查找和统计

find(key); // 查找key是否存在，存在时返回该键的元素的迭代器，反之返回set.end();

count(key); // 统计key的元素个数

set<int>:: iterator pos = s.find(30);
if(pos!=s.end())
{
    cout << *pos <<endl;
}

3.7.5 set和multiset区别

set不可以插入重复数据，而multiset可以；
set插入数据的同时会返回插入结果，表示插入是否成功；multiset不会检测数据，因此可以插入重复数据。

3.7.6 pair对组创建

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

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

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

pair<set<int>::iterator, bool> ret = s.insert(10);
if(ret.second){cout << "insert successfully" <<endl;}

3.7.7 set容器排序

利用仿函数，可以改变排序规则

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

int main()
{
  set<int, MyCompare> s;  // set要在插入数据前改变排序规则
  s.insert(40);
  s.insert(10);
  s.insert(20);

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

3.8 map/multimap容器

3.8.1 map基本概念

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

map不允许容器中有重复key值元素，multimap允许容器中有重复key值元素。

3.8.2 map构造和赋值

构造：

map<T1, T2> mp; // map默认构造函数:

map(const map &mp); // 拷贝构造函数

赋值：

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

3.8.3 map大小和交换

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

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

swap(st); // 交换两个集合容器

3.8.4 map插入和删除

insert(elem); // 在容器中插入对组元素pair<T1, T2>(data1, data2) | make_pair(data1, data2) | map<T1,T2>::value_type(3,30)

clear(); // 清除所有元素

erase(pos); // 删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg, end); // 删除区间[beg,end)的所有元素，返回下一个元素的迭代器。

erase(key); // 删除容器中值为key的元素。

3.8.5 map查找和统计

find(key); //查找key是否存在，存在时返回该键的元素的迭代器，反之返回set.end()；
count(key); //统计key的元素个数，对于map来说，结果为0或1。

4 STL- 函数对象

4.1 函数对象

4.1.1 函数对象概念

重载函数调用操作符的类，其对象常称为函数对象；
函数对象使用重载的()时，行为类似函数调用，也叫仿函数；

4.1.2 函数对象使用

特点：

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

4.2 谓词

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

4.3 内建函数对象

STL内建了一些函数对象，这些仿函数所产生的对象，用法和一般函数完全相同；使用内建函数对象，需要引入头文件 #include<functional>。

4.3.1 算术仿函数

template<class T> T plus<T> // 加法仿函数

template<class T> T minus<T> // 减法仿函数

template<class T> T multiplies<T> // 乘法仿函数

template<class T> T divides<T> // 除法仿函数

template<class T> T modulus<T> // 取模仿函数

template<class T> T negate<T> // 取反仿函数

4.3.2 关系仿函数

template<class T> bool equal_to<T> // 等于

template<class T> bool not_equal_to<T> // 不等于

template<class T> bool greater<T> // 大于

template<class T> bool greater_equal<T> // 大于等于

template<class T> bool less<T> // 小于

template<class T> bool less_equal<T> // 小于等于

4.3.3 逻辑仿函数

template<class T> bool logical_and<T> // 逻辑与

template<class T> bool logical_or<T> // 逻辑或

template<class T> bool logical_not<T> // 逻辑非

5 STL常用算法

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

5.1 常用遍历算法

5.1.1 for_each

for_each(iterator beg, iterator end, _func);
// 遍历算法 遍历容器元素
// beg 开始迭代器
// end 结束迭代器
// _func 函数或者函数对象

5.1.2 transform

transform(iterator beg1, iterator end1, iterator beg2, _func);
// beg1 源容器开始迭代器
// end1 源容器结束迭代器
// beg2 目标容器开始迭代器
// _func 函数或者函数对象

☆ 搬运的目标容器必须要提前开辟空间，否则无法正常搬运。

5.2 常用查找算法

5.2.1 find

find(iterator beg, iterator end, value);  
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素

5.2.2 find_if

find_if(iterator beg, iterator end, _Pred);  
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 函数或者谓词（返回bool类型的仿函数）

5.2.3 adjacent_find

adjacent_find(iterator beg, iterator end);  
// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器
// beg 开始迭代器
// end 结束迭代器

5.2.4 binary_search

bool binary_search(iterator beg, iterator end, value);  
// 查找指定的元素，查到 返回true  否则false
// 注意: 在**无序序列中不可用**
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素

5.2.5 count

count(iterator beg, iterator end, value);  
// 统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// value 统计的元素

统计自定义数据类型时候，需要配合重载 operator==；

5.2.6 count_if

count_if(iterator beg, iterator end, _Pred);  
// 按条件统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词

5.3 常用排序算法

5.3.1 sort

sort(iterator beg, iterator end, _Pred);  
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
//  beg    开始迭代器
//  end    结束迭代器
// _Pred  谓词

5.3.2 random_shuffle

random_shuffle(iterator beg, iterator end);  
// 指定范围内的元素随机调整次序
// beg 开始迭代器
// end 结束迭代器

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   目标容器开始迭代器

5.3.4 reverse

reverse(iterator beg, iterator end);  
// 反转指定范围的元素
// beg 开始迭代器
// end 结束迭代器

5.4 常用拷贝和替换算法

5.4.1 copy

copy(iterator beg, iterator end, iterator dest);  
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg  开始迭代器
// end  结束迭代器
// dest 目标起始迭代器（需提前开辟空间）

5.4.2 replace

replace(iterator beg, iterator end, oldvalue, newvalue);  
// 将区间内旧元素替换成新元素
// beg 开始迭代器
// end 结束迭代器
// oldvalue 旧元素
// newvalue 新元素

5.4.3 replace_if

replace_if(iterator beg, iterator end, _pred, newvalue);  
// 按条件替换元素，满足条件的替换成指定元素
// beg 开始迭代器
// end 结束迭代器
// _pred 谓词
// newvalue 替换的新元素

5.4.4 swap

swap(container c1, container c2);  
// 互换两个容器的元素
// c1容器1
// c2容器2

5.5 常用算术生成算法

算术生成算法属于小型算法，使用时包含的头文件为 #include <numeric>。

5.5.1 accumulate

accumulate(iterator beg, iterator end, value);  
// 计算容器元素累计总和
// beg 开始迭代器
// end 结束迭代器
// value 起始值

5.5.2 fill

fill(iterator beg, iterator end, value);  
// 向容器中填充元素
// beg 开始迭代器
// end 结束迭代器
// value 填充的值

5.6 常用集合算法

5.6.1 set_intersection

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);  
// 求两个集合的交集，**返回交集中最后一个元素位置itEnd；**
// 再遍历交集容器时迭代器从begin()到itEnd
// 注意：**两个集合必须是有序序列**
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器（开辟空间取两个容器尺寸最小值）

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 目标容器开始迭代器（开辟空间取两个容器尺寸和）

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 目标容器开始迭代器（开辟空间取两个容器尺寸最大值）