STL迭代器和函数对象

• • 一、迭代器
  • 二、函数对象

iterator（普通的正向迭代器，可读可写）和const_iterator（常量的正向迭代器，可读不可写）
reverse_iterator和const_reverse_iterator

	vector vec;
	vector::const_iterator it1 = vec.begin(); // 可读不可写，子类
	vector::iterator it1 = vec.begin();       // 可读可写，派生类

	vector::const_reverse_iterator r_beg = vec.rbegin();  
	vector::reverse_iterator r_beg = vec.rbegin();  // 返回最后一个元素的反向迭代器表示

	vector::const_reverse_iterator r_end = vec.rend();
	vector::reverse_iterator r_end = vec.rend();      // 返回首元素前驱的反向迭代器表示

函数对象类似C的函数指针，但是相比之下没有函数调用开销，C的函数指针有函数调用开销
greater和less

#include
using namespace std;

template
bool my_greater(const T& a, const T& b) 
{
	return a > b;
}

template
bool my_less(const T& a, const T& b)
{
	return a < b;
}

template
bool compare(const T& a, const T& b, Compare comp) 
{
	// 函数指针调用，有函数开销，无法内联，效率很低
	// 编译过程中，看到函数指针comp，无法知道调用的是哪个函数，所以无法写死，只能动态地从函数地址取出函数	
	return comp(a, b);
}
int main() 
{
	cout << compare(10, 20, my_greater);
	return 0;
}

把有operator()运算符重载函数的对象，称作函数对象，也叫仿函数。可以确定调用函数， 完全可以内联，省去函数调用开销

因为函数对象是用类生成的，所以可以添加相关的成员变量，用来记录函数对象使用时更多的信息。

C++函数对象的版本实现

#include

using namespace std;

template
class my_greater 
{
public:
	bool operator()(const T& a, const T& b) //二元函数对象
	{
		return a > b;
	}
};

template
class my_less {
public:
	bool operator()(const T& a, const T& b) 
	{
		return a < b;
	}
};

template
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());
	return 0;
}

使用函数对象改变priority_queue的排序方式

int main() 
{
	// 降序，默认less
	priority_queue q1;
	// 升序
	// using MinQueue = priority_queue, greater>;
	priority_queue, greater> q2;
	
	// 升序，默认less
	set  s1;
	// 降序
	set> s2;
	return 0;
}