迭代器和函数对象

c++STL的泛型算法，参数为什么接收的都是迭代器？
泛型算法：模板写的，全局的，针对所有容器使用的，不管泛型算法实现什么功能操作，首先要获取或者遍历容器所有元素
	  因此泛型算法，必须找到一种统一的方式：用相同的方式可以遍历所有的容器，访问容器元素
	  operator[]只能访问数组类容器
	  所以使用容器迭代器的原因：用迭代器访问任何容器，其代码形式时一模一样的！！！
	  但是底层遍历不同容器，遍历方式是不同的，但这个差异都被封装在迭代器的运算符重载函数中

泛型算法= 模板 + 迭代器 + 函数对象，如sort，通过改变函数对象可以做到升降序的排序
	  因为每一种容器都有自己的数据结构，数据遍历方式不同，所以迭代器都实现成容器类的嵌套类iterator
class string
{
public:
	
	class iterator
	{
		//operator！=   operator++   operator*
	private：
		char *mp
	}
	iterator begin()//返回容器首元素的迭代器表示
	iterator end()//返回容器末尾元素后继位置的迭代器表示

private:// 你看到的是迭代器iterator迭代String对象
	// 底层就是mp在遍历容器的mpstr字符串数组！！！
	char *mpstr;
}





//vector增加删除, insert(it,val)  erase(it)
//写代码：把vec容器中所有的偶数进行删除，再打印vec
容器迭代器失效问题：
当我们使用迭代器向vector中添加数据问题时，由于vector在扩容时会重新开辟空间，导致原来的内存的迭代器失效
当我们删除时，vec.erase(it);由于通过迭代器删除数据，导致当前这个迭代器也会失效

解决的办法是，insert和erase都返回了iterator类型
insert：返回增加后的新的元素的迭代器
erase：返回了删除后的新的迭代器
所以每次使用后都需要再次接收新的迭代器
vector<int> vec2;
	vector<int>::iterator it2 = vec2.begin();
	for (int i = 0; i < 10; i++)
	{
		it2=vec2.insert(it2, i);
	}

	for (auto it3=vec2.begin(); it3 != vec2.end(); )
	{
		if (*it3 % 2 == 0)
		{
			it3 = vec2.erase(it3);
			continue;
		}
		it3++;
	}
	for (int val : vec2)
	{
		cout << val << " ";
	}









下面是泛型算法和模板以及迭代器和函数对象的使用：
#include <iostream>
#include <vector>
#include <functional>//包含了所有的函数对象
#include <algorithm>//泛型算法的头文件

using namespace std;

template<typename T,typename Comp>
void sort(T arr[], int size, Comp comp)
{
	for (int i = 0; i < size - 1; i++)
	{
		for (int j = 0; j < size - 1 - i; j++)
		{
			if (comp(arr[j], arr[j+1]))
			{
				swap(arr[j], arr[j+1]);
			}
		}
	}
}
template<class T>
class Cppgreater
{
public:
	Cppgreater(){}
	~Cppgreater(){}
	bool operator()(T a, T b)
	{
		return a > b;
	}
};

template<class E>
class Cppless
{
public:
	Cppless(){}
	~Cppless(){}
	bool operator()(E a, E b)
	{
		return a < b;
	}
};

int main()
{
	int arr[5] = { 12, 45, 23, 64, 12 };
	sort<int>(arr, 5, Cppless<int>());
	for (auto val : arr)
	{
		cout << val << " ";
	}
	cout << endl;
	return 0;
}







template<typename Container>
void show(Container &con)
{
	auto it = con.begin();
	for (; it != con.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	vector<int> vec;
	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);
	}
	show(vec);

	sort(vec.begin(), vec.end());
	show(vec);

	sort(vec.begin(), vec.end(), [](int a, int b)->bool{ return a > b; });
	show(vec);
	//函数对象在c++11以后的替代品，就是lambda表达式
	//lambda表达式=》函数对象，它不关注函数对象的类型是什么，不关注它的名字叫什么，
	//只关注函数对象的operate()运算符重载函数怎么写
	/*
	bool operator()(参数列表)
	{
	代码
	}
	[](参数列表)->bool{代码}
	*/
	// 
	reverse(vec.begin(),vec.end());
	show(vec);

	/*auto it = find_if(vec.begin(), vec.end(), [](int a)->bool {return a > 5; });
	cout << *it << endl;*/

	auto it = find_if(vec.begin(), vec.end(), [](int a)->bool{ return a > 7; });
	vec.insert(it, 7);
	show(vec);

	for_each(vec.begin(), vec.end(), [](int a) { cout << a << " "; });
	cout << endl;

	
	return 0;
}