2020-03-28 19:23 已编辑 SHEIN_资深Java开发工程师

关注

C++重载运算符和标准模板库（STL）

一、重载运算符

在C++中，不只是函数可以重载，某些运算符也是可以重载的，即可以自定义运算符的功能，可以重载的运算符如下：

运算符	名称	类型
`,`	逗号	二进制
`!`	逻辑“非”	一元
`!=`	不相等	二进制
`%`	取模	二进制
`%=`	取模赋值	二进制
`&`	按位“与”	二进制
`&`	address-of	一元
`&&`	逻辑“与”	二进制
`&=`	按位“与”赋值	二进制
`( )`	函数调用	—
`( )`	强制转换运算符	一元
`*`	乘法	二进制
`*`	指针取消引用	一元
`*=`	乘法赋值	二进制
`+`	添加	二进制
`+`	一元加	一元
`++`	递增1	一元
`+=`	加法赋值	二进制
`-`	减法	二进制
`-`	一元求反	一元
`--`	递减1	一元
`-=`	减法赋值	二进制
`->`	成员选择	二进制
`->*`	指向成员的指针选定内容	二进制
`/`	除法	二进制
`/=`	除法赋值	二进制
`<`	小于	二进制
`<<`	左移	二进制
`<<=`	左移赋值	二进制
`<=`	小于或等于	二进制
`=`	赋值	二进制
`==`	相等	二进制
`>`	大于	二进制
`>=`	大于或等于	二进制
`>>`	右移	二进制
`>>=`	右移赋值	二进制
`[ ]`	数组下标	—
`^`	异或	二进制
`^=`	异或赋值	二进制
`\|`	按位“与或”	二进制
`\|=`	按位“与或”赋值	二进制
`\|\|`	逻辑“或”	二进制
`~`	二进制反码	一元
`delete`	`Delete`	—
`new`	`New`	—
`conversion operators`	转换运算符	一元

不可重载的运算符：

`Operator`	`Name`
`.`	成员选择
`.*`	指向成员的指针选定内容
`::`	范围解析
`? :`	条件运算
`#`	预处理器转换为字符串
`##`	预处理器串联

在将这些运算符重载之后，运算符就被赋予了的新的功能，重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表：

Complex operator+(const Complex&, const Complex&);//重载+运算符 实现两个复数相加

部分运算符实例如下，实现过程见注释：
①：二元运算符重载

#include <iostream>
using namespace std;

class Complex {//复数类
public:
   double re, im;//实部 虚部
   Complex(){//无参构造函数
   }
   Complex(double x,double y){//含参构造函数
       re=x;
       im=y;
   }
   Complex operator+( Complex &x );//重载+运算符  实现复数相加
   void Display( ) {   cout << re << ", " << im << endl; }
};

Complex Complex::operator+( Complex &x ) {
   return Complex( re + x.re, im + x.im );
}

int main() {
   Complex a = Complex( 1.2, 3.4 );
   Complex b = Complex( 5.6, 7.8 );
   Complex c = Complex( 0.0, 0.0 );
   c = a + b;
   c.Display();
}

②：关系运算符重载

#include<bits/stdc++.h> using namespace std; class Time//时间类 { private: int month; int day; int hour; int minute; public: Time(int mon,int d,int h,int m){//含参构造函数 month=mon; day=d; hour=h; minute=m;} Time(){month=day=hour=minute=0;//无参构造函数 } //重载<操作符 实现时间大小的比较 bool operator<(const Time &x){//如果时间t1<t2 return 1 else return 0 if(month<x.month){return true;} else if(month==x.month){ if(day<x.day){return true;} else if(day==x.day){ if(hour<x.hour){return true;} else if(hour==x.hour){ if(minute<=x.minute){return true;} else return false; } else return false; } else return false; } else return false; } }; int main() { Time x(8,20,19,19); Time y(5,20,19,19); if(x<y) cout<<"True"; else cout<<"False"; return 0; }

③：输入/输出运算符重载

#include<bits/stdc++.h>
using namespace std;
class Time//时间类
{
private:
    int month;
    int day;
    int hour;
    int minute;
public:
    Time(int mon,int d,int h,int m){//含参构造函数
        month=mon;
        day=d;
        hour=h;
        minute=m;}
    Time(){month=day=hour=minute=0;//无参构造函数
    }
    //重载<<操作符
     friend ostream &operator<<(ostream &out,const Time &t){
            out<<t.month<<"月"<<t.day<<"日"<<t.hour<<"时"<<t.minute<<"分";
            return out;
     }
     //重载>>操作符
     friend istream &operator>>(istream &in,Time &t){
            in>>t.month>>t.day>>t.hour>>t.minute;
            return in;
     }
};
int main()
{
    Time x(8,8,8,8);
    Time y;
    cout<<x<<endl;
    cin>>y;
    cout<<y;
    return 0;
}

④：递增（++）递减（--）运算符重载

#include <iostream>
using namespace std;
class Time
{
   private:
      int hours;             // 0 到 23
      int minutes;           // 0 到 59
   public:
      // 所需的构造函数
      Time(){
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m){
         hours = h;
         minutes = m;
      }
      // 显示时间的方法
      void displayTime()
      {
         cout << hours << "点" << minutes <<"分"<<endl;
      }
      // 重载前缀递增运算符（ ++ ）
      Time operator++ ()
      {
         ++minutes;          // 对象加 1
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      // 重载后缀递增运算符（ ++ ）
      Time operator++( int )//int 用于区分前加和后加
      {
         // 创建临时对象，保存原始值
         Time T(hours, minutes);
         // 对象加 1
         ++minutes;
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         // 返回旧的原始值
         return T;
      }
      /*重载前加和后加的区别:
      *++i 直接把该对象的值+1 然后return该对象
      *i++ 先创建临时对象Temp 把原始值赋值给Temp 然后对Temp的数据+1 return Temp
      *两种加法产生的效果一样
      *后加会添加一个形参int 用于区分前加还是后加 并无实际作用 operator++( int )
      */
};
int main()
{
   Time T1(11, 59), T2(10,40);

   ++T1;                    // T1 加 1
   T1.displayTime();        // 显示 T1
   ++T1;                    // T1 再加 1
   T1.displayTime();        // 显示 T1

   T2++;                    // T2 加 1
   T2.displayTime();        // 显示 T2
   T2++;                    // T2 再加 1
   T2.displayTime();        // 显示 T2
   return 0;
}
/*当上面的代码被编译和执行时，它会产生下列结果：
*12点0分
*12点1分
*10点41分
*10点42分
*/

⑤：赋值运算符重载

#include<bits/stdc++.h>
using namespace std;
class Time//时间类
{
private:
    int month;
    int day;
    int hour;
    int minute;
public:
    Time(int mon,int d,int h,int m){//含参构造函数
        month=mon;
        day=d;
        hour=h;
        minute=m;}
    Time(){month=day=hour=minute=0;//无参构造函数
    }
    void display(){
        cout<<month<<"月"<<day<<"日"<<hour<<"时"<<minute<<"分"<<endl;
    }
    //重载=操作符  实现两个时间对象的赋值
    void operator=(const Time &x){
        month=x.month;
        day=x.day;
        hour=x.hour;
        minute=x.minute;
    }
};
int main()
{
    Time x(5,21,13,14);
    Time y;
    cout<<"Time x:"<<endl;
    x.display();
    y=x;
    cout<<"Time y:"<<endl;
    y.display();
    return 0;
}

⑥：函数调用运算符() 下标运算符 [] 重载【只能用成员函数重载不能用友元函数重载】

#include <iostream>
using namespace std;

class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 重载函数调用运算符
      Distance operator()(int a, int b, int c)
      {
         Distance D;
         // 进行随机计算
         D.feet = a + c + 10;
         D.inches = b + c + 10 ;
         return D;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }

};
int main()
{
   Distance D1(11, 10), D2;

   cout << "First Distance : ";
   D1.displayDistance();

   D2 = D1(10, 10, 10); // invoke operator()
   cout << "Second Distance :";
   D2.displayDistance();

   return 0;
}
/*当上面的代码被编译和执行时，它会产生下列结果：

First Distance : F: 11 I:10
Second Distance :F: 30 I:30*/

//重载[]运算符

#include <iostream>
using namespace std;
const int SIZE = 10;

class safearay
{
   private:
      int arr[SIZE];
   public:
      safearay() 
      {
         register int i;
         for(i = 0; i < SIZE; i++)
         {
           arr[i] = i;
         }
      }
      int& operator[](int i)
      {
          if( i > SIZE )
          {
              cout << "索引超过最大值" <<endl; 
              // 返回第一个元素
              return arr[0];
          }
          return arr[i];
      }
};
int main()
{
   safearay A;

   cout << "A[2] 的值为 : " << A[2] <<endl;
   cout << "A[5] 的值为 : " << A[5]<<endl;
   cout << "A[12] 的值为 : " << A[12]<<endl;

   return 0;
}
/*
A[2] 的值为 : 2
A[5] 的值为 : 5
A[12] 的值为 : 索引超过最大值
0
*/

二、标准模板库（Standard Template Library）

在C++中，有时候我们不需要重复的“造轮子”，在前人的基础上，已经开发了许多功能丰富的库，我们直接用就就行，比如说标准模板库，在这里只是简单的介绍一下常用类型，如果要详细的介绍STL,完全可以写一本书了。STL包含了丰富的功能，它主要分为三个部分：

组件	描述
容器（Containers）	容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
算法（Algorithms）	算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
迭代器（iterators）	迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。

①：容器【序列容器、关联容器、容器适配器】

序列容器：

vector容器：

    vector容器的行为类似于数组，但可以根据要求自动增长。它可以随机访问、连续存储，长度也非常灵活。基于上述和其他原因，vector是多数应用程序的首选序列容器。若不确定要使用哪种序列容器，请首先使用vector容器！
        vector允许在序列末尾插入和删除常量事件。若要在矢量中间插入或删除元素，则需要线性时间。就在序列开头和末尾进行插入和删除而言，deque 类容器的性能更胜一筹。就在序列任何位置进行插入和删除而言，list 类容器更胜一筹。
        当成员函数必须将vector对象中所含序列增加到超过其当前存储容量时，将进行vector重新分配。其他的插入和删除均可能改变序列中的各个存储地址。在所有此类情况下，指向序列更改部分的迭代器或引用将变为无效。如果未进行重新分配，则只有插入/删除点前的迭代器和引用保持有效。
        vector<bool> 类是一种模板类矢量的完全专用化，针对类型 bool 的元素，且带有专用化所使用的基础类型的分配器。

vector<bool> reference 类是一个嵌套类，其对象能够提供对 vector<bool> 对象内的元素（单个位）的引用。

vector容器的成员函数：

assign 清除矢量并将指定的元素复制到该空矢量。
at         返回对矢量中指定位置的元素的引用。
back 返回对向量中最后一个元素的引用。
begin 对该向量中第一个元素返回随机访问迭代器。
capacity 返回在不分配更多的存储的情况下向量可以包含的元素数。
cbegin 返回指向向量中第一个元素的随机访问常量迭代器。
cend 返回一个随机访问常量迭代器，它指向刚超过矢量末尾的位置。
crbegin 返回一个指向反向矢量中第一个元素的常量迭代器。
crend 返回一个指向反向矢量末尾的常量迭代器。
clear 清除向量的元素。
data         返回指向向量中第一个元素的指针。
emplace 将就地构造的元素插入到指定位置的向量中。
emplace_back 将一个就地构造的元素添加到向量末尾。
empty 测试矢量容器是否为空。
end         返回指向矢量末尾的随机访问迭代器。
erase 从指定位置删除向量中的一个元素或一系列元素。
front 返回对向量中第一个元素的引用。
get_allocator 将对象返回到矢量使用的 allocator 类。
insert 将一个元素或多个元素插入到指定位置的向量中。
max_size 返回向量的最大长度。
pop_back删除矢量末尾处的元素。
push_back在矢量末尾处添加一个元素。
rbegin 返回指向反向向量中第一个元素的迭代器。
rend         返回一个指向反向矢量末尾的迭代器。
reserve 保留向量对象的最小存储长度。
resize 为矢量指定新的大小。
shrink_to_fit 放弃额外容量。
size         返回向量中的元素数量。
swap 交换两个向量的元素。

array容器：具备 vector的某些优点，但长度不够灵活。

deque(双端队列)：支持在容器的起点和终点进行快速插入和删除。它享有vector随机访问和长度灵活的优点，但是不具备连续性。

list容器：是双向链表，在容器内的任意位置启用了双向访问、快速插入和快速删除，但是你不能随机访问此容器中的元素。

forward_list容器：是单独链表，list的向前访问版本。

关联容器：

在关联容器中，按照预定义的顺序插入元素，例如按升序排序。无序的关联容器也可用。关联容器可分为两个子集：map和set

map：有时称为字典，包含键/值对。键用于对序列排序，值与该键关联。例如，map可能包含许多键（代表文本中每个独特的单词）和相应的值（代表每个单词在文本中出现的次数）。 map的无序版本是 unordered_map。

用于存储和检索集合中的数据，此集合中的每个元素均为包含数据值和排序键的元素对。键的值是唯一的，用于自动排序数据。可以直接更改映射中的元素值。键值是常量，不能更改。必须先删除与旧元素关联的键值，才能为新元素插入新键值。

注：

大小可变的关联容器，基于关联键值高效检索元素值。
可逆，因为它提供双向迭代器来访问其元素。
有序，因为它的元素根据指定的比较函数按键值排序。
唯一。因为它的每个元素必须具有唯一键。
关联容器对，因为它的元素数据值与其键值不同。
模板类，因为它提供的功能是一般性的功能，与元素或键类型无关。用于元素和键的数据类型作为类模板以及比较函数和分配器中的参数指定。

map成员函数：

at         查找具有指定键值的元素。
begin 返回一个迭代器，此迭代器指向映射中的第一个元素。
cbegin 返回一个常量迭代器，此迭代器指向映射中的第一个元素。
cend 返回一个超过末尾常量迭代器。
clear 清除映射的所有元素。
count 返回映射中其键与参数中指定的键匹配的元素数量。
crbegin 返回一个常量迭代器，此迭代器指向反向映射中的第一个元素。
crend 返回一个常量迭代器，此迭代器指向反向映射中最后一个元素之后的位置。
emplace 将就地构造的元素插入到映射。
emplace_hint 将就地构造的元素插入到映射，附带位置提示。
empty 如果映射为空，则返回 true。
end         返回超过末尾迭代器。
equal_range 返回一对迭代器。此迭代器对中的第一个迭代器指向 map 中其键大于指定键的第一个元素。此迭代器对中的第二个迭代器指向 map 中其键等于或大于指定键的第一个元素。
erase 从指定位置移除映射中的元素或元素范围。
find         返回一个迭代器，此迭代器指向映射中其键与指定键相等的元素的位置。
get_allocator 返回用于构造映射的 allocator 对象的副本。
insert 将元素或元素范围插入到映射中的指定位置。
key_comp 返回用于对映射中的键进行排序的比较对象副本。
lower_bound 返回一个迭代器，此迭代器指向映射中其键值等于或大于指定键的键值的第一个元素。
max_size 返回映射的最大长度。
rbegin 返回一个迭代器，此迭代器指向反向映射中的第一个元素。
rend         返回一个迭代器，此迭代器指向反向映射中最后一个元素之后的位置。
size         返回映射中的元素数量。
swap 交换两个映射的元素。
upper_bound 返回一个迭代器，此迭代器指向映射中其键值大于指定键的键值的第一个元素。

value_comp 检索用于对映射中的元素值进行排序的比较对象副本。

#include <bits/stdc++.h>
using namespace std;
struct T1{
    int v;
    bool operator<(const T1 &a)const{
        return (v < a.v);
    }
};
struct T2{
    int v;
};
struct cmp{
    const bool operator()(const T2 &a, const T2 &b){
        return (a.v < b.v);
    }
};
int main(){
    map<T1, int>mt1;
    map<T2, int, cmp>mt2;
    map<string, int> m2;
    map<string, int>::iterator m2i, p1, p2;
    m2["abd"] = 2;
    m2["abc"] = 1;
    m2["cba"] = 2;
    m2.insert(make_pair("aaa", 9));
    m2["abf"] = 4;
    m2["abe"] = 2;
    cout << m2["abc"] << endl;
    m2i = m2.find("cba");
    if(m2i != m2.end()){
        cout << m2i->first << ": " << m2i->second << endl;
    }else{
        cout << "find nothing" << endl;
    }
    cout << "Iterate" << endl;
    for(m2i = m2.begin(); m2i != m2.end(); m2i++){
        cout << m2i->first << ": " << m2i->second << endl;
    }
    return 0;
}

set：仅是按升序排列每个元素的容器，值也是键。 set的无序版本是 unordered_set。
map 和 set 都仅允许将键或元素的一个实例插入容器中。如果需要元素的多个实例，请使用multimap或multiset。无序版本是 unordered_multimap 和 unordered_multiset。有序的map和set支持双向迭代器，其未排序副本支持向前迭代器。

容器适配器：

容器适配器是序列容器或关联容器的变体，为了简单明确起见，它对接口进行限制。容器适配器不支持迭代器。

queue容器：
        遵循 FIFO（先进先出）语义。第一个推送（即插入队列中）的元素将第一个弹出（即从队列中删除）。
priority_queue容器：
        也是如此组织，因此具有最高值的元素始终排在队列的第一位。
stack容器：
        遵循 LIFO（后进先出）语义。堆栈上最后推送的元素将第一个弹出。
        【由于容器适配器不支持迭代器，因此无法与 C++ 标准库容器算法一起使用】

②：迭代器

迭代器是一个对象，可以循环访问 C++ 标准库容器中的元素，并提供对各个元素的访问。 C++ 标准库容器全都提供迭代器，以便算法可以采用标准方式访问其元素，而不必考虑用于存储元素的容器类型。可以通过使用成员和全局函数（如 begin() 和 end()）以及运算符（如 ++ 和 -- ）向前或向后移动，来显式使用迭代器。还可以通过范围 for 循环或（对于某些迭代器类型）下标运算符 []，来隐式使用迭代器。在 C++ 标准库中，序列或范围的开头是第一个元素。序列或范围的末尾始终定义为最后一个元素的下一个位置。全局函数的开始和结束会将迭代器返回到指定容器。
有五种类别的迭代器。这些类别如下所示（按功能逐渐增强的顺序）：
输出：输出迭代器 X 可以使用 ++ 运算符向前循环访问序列，并且可以使用 * 运算符将元素仅写入一次。
输入：输入迭代器 X 可以使用 ++ 运算符向前循环访问序列，并且可以使用 * 运算符读取元素任意次数。可以使用 ++ 和 != 运算符比较输入迭代器。递增输入迭代器的任何副本之后，没有其他任何副本可以安全地进行比较、取消引用或递增。
向前：向前迭代器 X 可以使用 ++ 运算符向前循环访问序列，并且可以使用 * 运算符读取任意元素或写入非常量元素任意次数。可以使用 -> 运算符访问元素成员，并使用 == 和 != 运算符比较向前迭代器。可以创建向前迭代器的多个副本，其中每个副本都可以独立地取消引用和递增。未使用对任何容器的引用进行初始化的向前迭代器称为 null 向前迭代器。 Null 向前迭代器的比较结果始终是相等的。
双向：双向迭代器 X 可以替代向前迭代器。但是，还可以递减双向迭代器，如 --X、X-- 或 (V = *X--)。可以采用与向前迭代器相同的方式访问元素成员和比较双向迭代器。

随机访问：随即访问迭代器 X 可以替代双向迭代器。借助随机访问迭代器，可以使用下标运算符 [] 访问元素。可以使用 +、-、+= 和 -= 运算符向前或向后移动指定数量的元素以及计算迭代器之间的距离。可以使用 ==、!=、<、>、<= 和 >= 比较双向迭代器。

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> a;
    for (int i = 1; i <= 5; ++i){
        a.push_back(i);
    }
    vector<int>::iterator it;//声明一个迭代器
    for (it=a.begin(); it!=a.end(); ++it){//迭代器指向容器开始 并不断+1
        cout<<*it<<endl;
    }
    return 0;
}

③：算法

算法是 C++ 标准库的基础部分。算法不与容器本身一起使用，而与迭代器一起使用。因此，大多数（如果不是全部）C++ 标准库容器都可以使用相同的算法。

adjacent_find 搜索相等或满足指定条件的两个相邻元素。
all_of 当给定范围中的每个元素均满足条件时返回 true。
any_of 当指定元素范围中至少有一个元素满足条件时返回 true。
binary_search 测试已排序的范围中是否有等于指定值的元素，或在二元谓词指定的意义上与指定值等效的元素。
copy 将一个源范围中的元素值分配到目标范围，循环访问元素的源序列并将它们分配在一个向前方向的新位置。
copy_backward 将一个源范围中的元素值分配到目标范围，循环访问元素的源序列并将它们分配在一个向后方向的新位置。
copy_if 复制给定范围中对于指定条件为 true 的所有元素。
copy_n 复制指定数量的元素。
count 返回范围中其值与指定值匹配的元素的数量。
count_if 返回范围中其值与指定条件匹配的元素的数量。
equal 逐个元素比较两个范围是否相等或是否在二元谓词指定的意义上等效。
equal_range 在排序的范围中查找符合以下条件的位置对：第一个位置小于或等效于指定元素的位置，第二个位置大于此元素位置，等效意义或用于在序列中建立位置的排序可通过二元谓词指定。
fill         将相同的新值分配给指定范围中的每个元素。
fill_n         将新值分配给以特定元素开始的范围中的指定数量的元素。
find         在范围中找到具有指定值的元素的第一个匹配项位置。
find_end 在范围中查找与指定序列相同的最后一个序列，或在二元谓词指定的意义上等效的最后一个序列。
find_first_of 在目标范围中搜索若干值中任意值的第一个匹配项，或搜索在二元谓词指定的意义上等效于指定元素集的若干元素中任意元素的第一个匹配项。
find_if 在范围中找到满足指定条件的元素的第一个匹配项位置。
find_if_not 返回指示的范围中不满足条件的第一个元素。
for_each 将指定的函数对象按向前顺序应用于范围中的每个元素并返回此函数对象。
generate 将函数对象生成的值分配给范围中的每个元素。
generate_n 将函数对象生成的值分配给范围中指定数量的元素，并返回到超出最后一个分配值的下一位置。
includes 测试一个排序的范围是否包含另一排序范围中的所有元素，其中元素之间的排序或等效条件可通过二元谓词指定。
inplace_merge 将两个连续的排序范围中的元素合并为一个排序范围，其中排序条件可通过二元谓词指定。
is_heap 如果指定范围中的元素形成堆，则返回 true。
is_heap_until 如果指定范围形成直到最后一个元素的堆，则返回 true。
is_partitioned 如果给定范围中对某个条件测试为 true 的所有元素在测试为 true 的所有元素之前，则返回 false。
is_permutation 确定给定范围的元素是否形成有效排列。
is_sorted 如果指定范围中的元素按顺序排序，则返回 true。
is_sorted_until 如果指定范围中的元素按顺序排序，则返回 true。
iter_swap 交换由一对指定迭代器引用的两个值。
lexicographical_compare 逐个元素比较两个序列以确定其中的较小序列。
lower_bound 在排序的范围中查找其值大于或等效于指定值的第一个元素的位置，其中排序条件可通过二元谓词指定。
make_heap 将指定范围中的元素转换到第一个元素是最大元素的堆中，其中排序条件可通过二元谓词指定。
max             比较两个对象并返回较大对象，其中排序条件可通过二元谓词指定。
max_element 在指定范围中查找最大元素的第一个匹配项，其中排序条件可通过二元谓词指定。
merge       将两个排序的源范围中的所有元素合并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
min                 比较两个对象并返回较小对象，其中排序条件可通过二元谓词指定。
min_element 在指定范围中查找最小元素的第一个匹配项，其中排序条件可通过二元谓词指定。
minmax     比较两个输入参数，并按最小到最大的顺序将它们作为参数对返回。
minmax_element 在一次调用中执行 min_element 和 max_element 执行的操作。
mismatch 逐个元素比较两个范围是否相等或是否在二元谓词指定的意义上等效，并找到出现不同的第一个位置。
<alg> move 移动与指定范围关联的元素。
move_backward 将一个迭代器的元素移动到另一迭代器。移动从指定范围的最后一个元素开始，并在此范围的第一个元素结束。
next_permutation 重新排序范围中的元素，以便使用按字典顺序的下一个更大排列（如果有）替换原有排序，其中“下一个”的意义可通过二元谓词指定。
none_of 当给定范围中没有元素满足条件时返回 true。
nth_element 对范围内的元素分区，正确找到范围中序列的第 n 个元素，以使序列中位于此元素之前的所有元素小于或等于此元素，位于此元素之后的所有元素大于或等于此元素。
partial_sort 将范围中指定数量的较小元素按非降序顺序排列，或根据二元谓词指定的排序条件排列。
partial_sort_copy 将源范围中的元素复制到目标范围，其中源元素按降序或二元谓词指定的其他顺序排序。
partition 将范围中的元素分为两个不相交的集，满足一元谓词的元素在不满足一元谓词的元素之前。
partition_copy 将条件为 true 的元素复制到一个目标，将条件为 false 的元素复制到另一目标。元素必须来自于指定范围。
partition_point 返回给定范围中不满足条件的第一个元素。元素经过排序，满足条件的元素在不满足条件的元素之前。
pop_heap 移除从堆顶到范围中倒数第二个位置之间的最大元素，然后将剩余元素形成新堆。
prev_permutation 重新排序范围中的元素，以便使用按字典顺序的下一个更大排列（如果有）替换原有排序，其中“下一个”的意义可通过二元谓词指定。
push_heap 将范围末尾的元素添加到包括范围中前面元素的现有堆中。
random_shuffle 将范围中 N 个元素的序列重新排序为随机 N! 种序列中的可能排列之一。
remove 从给定范围中消除指定值，而不影响剩余元素的顺序，并返回不包含指定值的新范围的末尾。
remove_copy 将源范围中的元素复制到目标范围（不复制具有指定值的元素），而不影响剩余元素的顺序，并返回新目标范围的末尾。
remove_copy_if 将源范围中的元素复制到目标范围（不复制满足谓词的元素），而不影响剩余元素的顺序，并返回新目标范围的末尾。
remove_if 从给定范围中消除满足谓词的元素，而不影响剩余元素的顺序，并返回不包含指定值的新范围的末尾。
replace 检查范围中的每个元素，并替换与指定值匹配的元素。
replace_copy 检查源范围中的每个元素，并替换与指定值匹配的元素，同时将结果复制到新的目标范围。
replace_copy_if 检查源范围中的每个元素，并替换满足指定谓词的元素，同时将结果复制到新的目标范围。
replace_if 检查范围中的每个元素，并替换满足指定谓词的元素。
reverse 反转范围中元素的顺序。
reverse_copy 反转源范围中元素的顺序，同时将这些元素复制到目标范围
rotate 交换两个相邻范围中的元素。
rotate_copy 交换源范围中两个相邻范围内的元素，并将结果复制到目标范围。
search 在目标范围中搜索其元素与给定序列中的元素相等或在二元谓词指定的意义上等效于给定序列中的元素的序列的第一个匹配项。
search_n 在范围中搜索具有特定值或按二元谓词的指定与此值相关的指定数量的元素。
set_difference 将属于一个排序的源范围、但不属于另一排序的源范围的所有元素相并到一个排序的目标范围，其中排序条件可通过二元谓词指定。
set_intersection 将属于两个排序的源范围的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
set_symmetric_difference 将属于一个而不是两个排序的源范围的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
set_union 将至少属于两个排序的源范围之一的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
sort 将指定范围中的元素按非降序顺序排列，或根据二元谓词指定的排序条件排列。
shuffle 使用随机数生成器重新排列给定范围中的元素。
sort_heap 将堆转换为排序的范围。
stable_partition 将范围中的元素分为两个不相交的集，满足一元谓词的元素在不满足一元谓词的元素之前，并保留等效元素的相对顺序。
stable_sort 将指定范围中的元素按非降序顺序排列，或根据二元谓词指定的排序条件排列，并保留等效元素的相对顺序。
swap 在两种类型的对象之间交换元素值，将第一个对象的内容分配给第二个对象，将第二个对象的内容分配给第一个对象。
swap_ranges 将一个范围中的元素与另一大小相等的范围中的元素交换。
transform 将指定的函数对象应用于源范围中的每个元素或两个源范围中的元素对，并将函数对象的返回值复制到目标范围。
unique 移除指定范围中彼此相邻的重复元素。
unique_copy 将源范围中的元素复制到目标范围，彼此相邻的重复元素除外。

upper_bound 在排序的范围中查找其值大于指定值的第一个元素的位置，其中排序条件可通过二元谓词指定。

三、学习心得

对于重载运算符来说，并不是很难理解，就像之前的函数重载一样，运算符重载就是给运算符赋予新的定义，使其对对应的对象实现特定的操作，方便了功能的实现，只要是谨记各种重载运算符的语法及注意事项就可以，比如说输入输出流重载，需要使用友元函数的方式。

C++标准库中的内容是非常丰富的，库其实就是一些函数模板，这个模板适用于任何类型的数据，现在这个阶段的我们不需要去深究其实现过程，只需要记住每个模板的使用方法、语法规范和功能实现就行，要在不断的使用过程中慢慢去理解各个类型的区别，比如map和multimap的区别。在今后的学习中，要多运用模板库中的内容，这样能避免重复开发，节约了开发时间，提高了开发效率。