C++泛型算法

copy()

作用：将某容器的区间数据拷贝到指定指定容器的指定位置

• 前两个参数是普通的顺序型迭代器
• 第三个参数是插入型迭代器

vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i + 1);
	}
	//将v1的迭代器区间拷贝给了输出流迭代器
	copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));
	cout << endl;

	vector<int>v2;
	//将v1的数据区间拷贝到v2指定位置
	copy(v1.begin(), v1.end(), inserter(v2, v2.begin()));
	copy(v2.begin(), v2.end(), ostream_iterator<int>(cout, " "));

源码：

自实现myCopy()

template<typename Back_INSERT_IT, typename IT>
void myCopy(const IT& first, const IT& last, Back_INSERT_IT b_insert_it)
{
	//IT =vector<int>::iterator 
	IT tmp = first;// vector<int>::iterator tmp=v1.begin()
	for (; tmp != last; tmp++)
	{
		*b_insert_it = *tmp;
	}
}
template<typename INSERT_IT, typename IT>
void myCopy1(IT first, IT last, INSERT_IT insert_it)
{
	while (first != last)
	{
		*insert_it = *first;
		first++;
	}
}
//由于v1.begin()返回的是临时量。函数构造局部对象，通过临时量返回局部对象。所以实参1和实参2都是临时量
// 通过引用接收一个临时量，而临时量具有常属性，因此临时量的引用也具有常属性，因此参数传递引用时需要加const
//myCopy1(v1.begin(), v1.end(), inserter(v2, v2.begin()));
template<typename INSERT_IT, typename IT>
void myCopy2(const IT& first, const IT& last, INSERT_IT insert_it)
{
	IT tmp = first;
	while (tmp != last)
	{
		*insert_it = *tmp;
		tmp++;
	}
}

find()

作用：在哪一个区间【 ）进行查找需要查找的值，如果没有找到it就和第二个参数相等

• 前两个参数是需要查找的迭代器区间 【 ）
• 第三个参数是需要查找的值，如果没有找到it就和第二个参数相等
• 返回值的类型和前两个参数的类型一致

//在哪一个区间【    ）进行查找，需要查找的值，如果没有找到it就和第二个参数相等
	vector<int>::iterator it = find(v1.begin(), v1.end(), 55);
	if (it == v1.end())//如果没有找到it就和第二个参数相等
	{
		cout << " not find " << endl;
	}
	else
	{
		cout << *it << endl;
	}

源码：

如何看源码：
按住Ctrl，鼠标放在相应函数名处，会出现一个小手，鼠标左键单击即可：

自实现myFind()

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

sort()

作用：对容器某区间进行排序。默认数据从小到大

• 两个参数时为容器的左右区间
• 三个参数时。前两个参数是容器的左右区间，第三个参数是排序规则

	sort(v1.begin(), v1.end());
	copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));

	sort(v1.begin(), v1.end(),less<int>());

源码：

两个参数的sort()，默认调用less<>{}

三个参数的sort()
使用的排序方法是优化后的快速排序；
优化方式：

• 三位取中法
• 快排之前对待排序序列加入冒泡或者选择排序：每次冒泡进行交换，如果一趟过去没有进行交换就说明数据已经有序或者数据完全重复
• 快排需要递归，递归会开辟堆栈，从而效率低下。因此当数据量很大时可以使用快排，但是当数据量剩的不多时就应该调用其他排序。

该排序的使用是：首先调用快排，当待排序数据足够小时就调用堆排

自实现mySort()

2个参数

template<typename T>
void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}


template<typename IT>
void mySort(const IT& first, const IT& last)
{
	for (IT tmp1=first; tmp1 != last; tmp1++)
	{
		for (IT tmp2 = tmp1 + 1; tmp2 != last; tmp2++)
		{
			if (!(*tmp1 < *tmp2))
			{
				Swap(*tmp1, *tmp2);
			}
		}
	}
}

3个参数

//函数对象。本质是一个对象，但是使用和函数一样，因为函数对象重载了（）运算符
template<typename T>
class Mless
{
public:
	bool operator()(T a, T b)
	{
		cout << "operator()" << endl;
		return a < b;
	}
};

template<typename IT, typename PRE>
void mySort1(const IT& first, const IT& last,PRE pre)
{
	for (IT tmp1=first; tmp1 != last; tmp1++)
	{
		for (IT tmp2 = tmp1 + 1; tmp2 != last; tmp2++)
		{
			if(!pre(*tmp1 , *tmp2))//pre可以是一个函数，但是C++考虑到更广泛的使用，采用了函数对象
			{
				Swap(*tmp1, *tmp2);
			}
		}
	}
}

函数对象用法：

		Mless<int> _less;
		_less(10, 20);

	mySort1(v1.begin(), v1.end(),Mless<int>());

find_if

作用：在容器区间寻找第一个满足条件的

• 返回值是一个迭代器

• 前两个参数是容器的左右区间

• 第三个参数是绑定的函数对象

• 调用find_if在v1.begin()到v1.end()这个区间进行查找，查找的条件是：该区间第一个小于10的元素

vector<int>::iterator it=find_if(v1.begin(), v1.end(), binder2nd <less<int>>(less<int>(), 10));

等价于：函数模板封装类模板

vector<int>::iterator it1 = find_if(v1.begin(), v1.end(), bind2nd (less<int>(), 12));

vector<int>::iterator it1=find_if(v1.begin(), v1.end(), binder2nd <less<int>>(less<int>(), 12));
	//                           binder2nd：是一个模板，意思是绑定对象的第二个参数
	//                           绑定less对象的第二个参数，因为less是函数对象，是2个参数的函数对象
	//                           使用binder2nd给less函数对象绑定第二个参数为10
	if (it1 == v1.end())
	{
		cout << " not find " << endl;
	}
	else
	{
		cout << *it1 << endl;
	}

自实现myFind_if()

标准库里的less

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


template<typename PRE>
class myBinder2nd//绑定器的作用就是给函数对象绑定参数
{
public:
	myBinder2nd(PRE pre, typename PRE::TYPE_SECOND val)//第一个参数是函数对象，第二个参数是一个未知类型的值
		:_pre(pre),_val(val)
	{
	}
	typename PRE::TYPE_RET operator()(typename PRE::TYPE_FIRST tmp)//因为使用到的是模板里面的类型所以需要加typename
	{
		//cout << "operator()" << endl;
		return _pre(tmp, _val);
	}

private:
	PRE _pre;//函数对象
	typename PRE::TYPE_SECOND _val;
};



template<typename IT, typename PRE>
IT myFind_if(const IT& first, const IT& last, PRE pre)
{
	IT tmp = first;
	while (tmp != last)
	{
		if (pre(*tmp))
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

vector<int>::iterator it2 = myFind_if(v1.begin(), v1.end(), myBinder2nd <Myless<int>>(Myless<int>(), 12));
	if (it1 == v1.end())
	{
		cout << " not find " << endl;
	}
	else
	{
		cout << *it2 << endl;
	}