STL：函数对象、泛型算法

1.不同类型的迭代器

const_iterator begin()const;//只读
const_iterator end()const;


reverse_iterator rbegin();//反向
reverse_iterator rend();

const_reverse_iterator rbegin()const;
const_reverse_iterator rend()const;

2.C++ STL：标准模板器：容器、迭代器、泛型算法

泛型算法：template +  容器的迭代器+函数对象（函数指针）（lambda表达式）

3.函数对象（仿函数）：有运算符重载的对象，只应用在泛型算法zhong，能够进行内联，节省函数调用的开销。

库里面全是二元函数对象， 二元函数对象+绑定器可以得到一元函数对象。

template<typename T>
class Sum
{
	public:
		int operator()(T a,T b)//()的重载
		{
			return a+b;
		}
};
Sum sum;
int ret =sum(10,20);

4.lambda表达式（可以代替函数对象）（底层是函数对象）

[捕获列表](形参列表)->返回类型{函数体}

int data = 100;
auto func=[&]()->void {data = 200; };
func();
cout << "data=" << data << endl;
//会打印出data的值为200

5.c++11新标准

1）auto 自动类型

2）nullptr 代替NULL；

3）foreach语句

4）lambda表达式

6.泛型算法和函数对象的头文件

# include<algorithm>//泛型算法
# include<functional> //c++STL函数对象 

7.sort算法的实现

template<typename Iterator,typename compa>
void mysort(Iterator first, Iterator last,compa com)
{
	typename Iterator::value_type value;
	int size = last - first;
	int i, j;
	for (i = 0; i < size - 1; ++i)
	{
		for (j = 0; j < size - 1 - i; ++j)
		{
		
			if (com(*(first + j) , *(first + j + 1)))
			{
				value = *(first + j);
				*(first + j) = *(first + j + 1);
				*(first + j + 1) = value;
			}
		}
	}
}		

可以通过以下几种方法来定义和使用

1）函数指针（是不能进行内联的）

template<typename T>
 bool compare_greater(T a, T b)//减少系统函数调用，设置为inline   通过函数指针调用函数是永远不 可能内联的 
{
	return a > b;
}

mysort(vec.begin(),vec.end(),compare_greater<int>);

2)函数对象

template<typename T>
class Greater
{
    public:
        bool operator()(T a,T b)
        {
            return a>b;
         }
};
mysort(vec.begin(),vec.end(),Greater<T>());

3)lambda表达式

mysort(vec.begin(),vec.end(),[](int a,int b)->bool{return a>b;});

8.实列（将一个元素插入到容器之中）

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