一、迭代器
iterator（普通的正向迭代器，可读可写）和const_iterator（常量的正向迭代器，可读不可写）
reverse_iterator和const_reverse_iterator
vector<int> vec;
vector<int>::const_iterator it1 = vec.begin(); // 可读不可写，子类
vector<int>::iterator it1 = vec.begin(); // 可读可写，派生类
vector<int>::const_reverse_iterator r_beg = vec.rbegin();
vector<int>::reverse_iterator r_beg = vec.rbegin(); // 返回最后一个元素的反向迭代器表示
vector<int>::const_reverse_iterator r_end = vec.rend();
vector<int>::reverse_iterator r_end = vec.rend(); // 返回首元素前驱的反向迭代器表示
二、函数对象
函数对象类似C的函数指针，但是相比之下没有函数调用开销，C的函数指针有函数调用开销
greater和less
#include<iostream>
using namespace std;
template<typename T>
bool my_greater(const T& a, const T& b)
{
return a > b;
}
template<typename T>
bool my_less(const T& a, const T& b)
{
return a < b;
}
template<typename T, typename Compare>
bool compare(const T& a, const T& b, Compare comp)
{
// 函数指针调用，有函数开销，无法内联，效率很低
// 编译过程中，看到函数指针comp，无法知道调用的是哪个函数，所以无法写死，只能动态地从函数地址取出函数
return comp(a, b);
}
int main()
{
cout << compare(10, 20, my_greater<int>);
return 0;
}
把有operator()运算符重载函数的对象，称作函数对象，也叫仿函数。可以确定调用函数， 完全可以内联，省去函数调用开销
因为函数对象是用类生成的，所以可以添加相关的成员变量，用来记录函数对象使用时更多的信息。
C++函数对象的版本实现
#include<iostream>
using namespace std;
template<typename T>
class my_greater
{
public:
bool operator()(const T& a, const T& b) //二元函数对象
{
return a > b;
}
};
template<typename T>
class my_less {
public:
bool operator()(const T& a, const T& b)
{
return a < b;
}
};
template<typename T, typename Compare>
bool compare(const T& a, const T& b, Compare comp)
{
//可以确定调用函数， 完全可以内联，省去函数调用开销
return comp(a, b);//operator()(a,b)
}
int main()
{
cout << compare(10,20, my_greater<int>());
return 0;
}
使用函数对象改变priority_queue的排序方式
int main()
{
// 降序，默认less
priority_queue<int> q1;
// 升序
// using MinQueue = priority_queue<int, vector<int>, greater<int>>;
priority_queue<int, vector<int>, greater<int>> q2;
// 升序，默认less
set <int> s1;
// 降序
set<int, greater<int>> s2;
return 0;
}