泛型算法和函数对象

1.泛型算法：

泛型算法
copy
find
sort
find_if

1.1copy:

copy(v.begin(), v.end(), inserter(v2, v2.begin()));
//把v的begin---end区间拷贝到对象v2（从v2.begin开始）
//v.begin()和v.end()返回是临时量，具有常属性，传参是要传入const和&。

vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));//把区间拷贝给输出流，等于输出。
	vector<int> v2;
	cout << endl;
	copy(v.begin(), v.end(), inserter(v2, v2.begin()));
	//拷贝的实现等同于inserter。
	cout << endl;
	copy(v2.begin(), v2.end(), ostream_iterator<int>(cout, " "));

通过模板函数实现copy算法：

template <typename T,typename CON>
 void Mcopy(const T& first,const T& last, CON src)
 {
	 T tmp = first;
	 for (; tmp != last; tmp++)
	 {
		 *src = *tmp;
	 }
 }

int main() 
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
	vector<int> v2;
	Mcopy(v.begin(), v.end(), inserter(v2, v2.begin()));
	//通过模板函数实现copy
	cout << endl;
	copy(v2.begin(), v2.end(), ostream_iterator<int>(cout, " "));
	}

1.2：find

vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
vector<int>::iterator it = find(v.begin(), v.end(), 5);
//find的返回是与v.begin()相同的迭代器。
	if (it==v.end())
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it << endl;
	}

1.2.1：通过模板函数实现

template <typename IT,typename T>
IT mfind(const IT& first, const IT& last, const T& val)
{
	IT tmp = first;
	while (tmp != last)
	{
		if (*tmp == val)
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

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

	}
	copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
vector<int>::iterator it1=mfind(v.begin(), v.end(), 5);
}

1.3：sort(由小到大,使用的是优化后的快排）

vector<int> v1;
	for (int i = 10; i > 0; i--)
	{
		v1.push_back(i);
	}
	copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));
	cout << endl;
	sort(v1.begin(), v1.end());//由小到大排序
	copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));

1.3.1：通过模板函数实现：

通过选择排序实现:

template<typename T>
void mswap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
template <typename T>
void msort(T first, T last)
{
	for (T tmp1 = first; tmp1 < last; tmp1++)
	{
		for (T tmp2 = tmp1 + 1; tmp2 < last; tmp2++)
		{
			if (!(*tmp1 < *tmp2))
			{
				mswap(*tmp1, *tmp2);
			}
		}
	}
}

1.4:find_if

假如需要找到第一个小于10的数。
先在find中找到实现方式。

template <typename IT,typename T>
IT mfind(const IT& first, const IT& last, const T& val)
//删去 const T& val，重新传入对象
//mfind_if(v1.begin(), v1.end(),binder2nd<less<int>>(less<int>(),10));
//binder2nd<less<int>>(less<int>(),10));需要传入(less<int>(),10)，binder2nd可以把10绑在less<int>()的第二位。
传入T pre

{
	IT tmp = first;
	while (tmp != last)
	{
		if (*tmp == val)
		//find_if的实现需要（*tmp<val）,需要传入（*tmp<val）
		//1.需要<
		//2.需要10
		//3.需要确保输入的是（*tmp<10）,10需要放在后边。
		//通过less(*tmp,10)实现。
		if(pre(*tmp))
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

2.函数对象：

函数对象
less(<)
Mgreater(>)
binder1st
binder2nd

本质是对象，但是使用等同于函数（重载（）运算符）。
函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值。

2.1：less：<

template <typename T>
class Mless
{
public:
	bool operator ()(T a, T b)
	{
		return a < b;
	}
};
int main() 
{
	Mless<int> _less;
	_less(10, 20);
	}

2.2:Mgreater: >

template <typename T>
class Mgreater
{
public:
	bool operator ()(T a, T b)
	{
		return a > b;
	}
};

2.3:binder1st

绑定器，把一个数值绑定到第一个元素

template<typename PRE>
class Mbinder1st
{
public:
	Mbinder1st(PRE pre,typename PRE::TYPE_FIRST val)
		:_pre(pre),_val(val)
	{
	}
	typename PRE::TYPE_RET operator()(typename PRE::TYPE_SECOND tmp)
	{
		return _pre(_val,tmp);
	}

private:
	PRE _pre;
	typename PRE::TYPE_FIRST _val;
};
template<typename T>
class Mless
{
public:
	typedef T TYPE_FIRST;
	typedef T TYPE_SECOND;
	typedef bool TYPE_RET;
	bool operator()(T a, T b)
	{
		cout << "bool operator()(T a, T b)" << endl;
		return a < b;
	}
};

2.4:binder2nd

template<typename PRE>
class Mbinder2nd
{
public:
	Mbinder2nd(PRE pre,typename PRE::TYPE_SECOND val)
		:_pre(pre),_val(val)
	{
	}
	typename PRE::TYPE_RET operator()(typename PRE::TYPE_FIRST tmp)
	{
		return _pre(tmp,_val);
	}

private:
	PRE _pre;
	typename PRE::TYPE_SECOND _val;
};
template<typename T>
class Mless
{
public:
	typedef T TYPE_FIRST;
	typedef T TYPE_SECOND;
	typedef bool TYPE_RET;
	bool operator()(T a, T b)
	{
		cout << "bool operator()(T a, T b)" << endl;
		return a < b;
	}
};