泛型算法和函数对象

2021-11-26 12:01:16 阅读：133 来源： 互联网

泛型算法

copy 拷贝

//模拟实现拷贝

template <typename INSERT_IT, typename IT>
void my_copy(const IT &first,const IT &last, INSERT_IT insert_it)
{
	IT tmp = first;
	for (; tmp != last; tmp++)
	{
		*insert_it = *tmp;
	}
}
int main()
{
	vector<int> v1;
	for (int i = 0; i <10; i++)
	{
		v1.push_back(i);
	}
	//		迭代器区间           拷贝到输出流迭代器
	my_copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));//完成输出v1
	cout << endl;

	vector<int> v2;
	my_copy(v1.begin(), v1.end(), inserter(v2, v2.begin()));
	my_copy(v2.begin(), v2.end(), ostream_iterator<int>(cout, " "));//完成输出v2
	return 0;

find 查找


	template <typename I, typename IT>
IT mfind(const IT& first, const IT &last, const I &val)//返回值为迭代器类型
{
	IT tmp = first;
	for (; tmp != last; tmp++)
	{
		if (*tmp == val)
		{
			return tmp;
		}
	}
	return last;
}
	
	int main()
{
	vector<int> v1;
	for (int i = 0; i <10; i++)
	{
		v1.push_back(i);
	}
	//		迭代器区间           拷贝到输出流迭代器
	my_copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));//完成输出v1
	cout << endl;
	
	vector<int>::iterator it=mfind(v1.begin(), v1.end(), 5);
	if (it == v1.end())//等于第二个参数，没找到
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it << endl;
	}
return 0;

sort 排序

从小到大排序

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

template <typename IT>
void msort(const IT& first, const IT& last)  //用选择排序来实现
{

	for (IT tmp = first; tmp != last; tmp++)
	{
		for (IT tmp1 = tmp + 1; tmp1 != last; tmp1++)
		{
			if (!(*tmp < *tmp1))
			//if (!pre(*tmp, *tmp1))
			{
				mswap(*tmp, *tmp1);
			}
		}
	}
}
int main()
{
	vector<int> v1;
	for (int i = 10; i >0; i--)
	{
		v1.push_back(i);
	}
	//		迭代器区间           拷贝到输出流迭代器
	my_copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));//完成输出v1
	cout << endl;
	//从小到大排序
	msort(v1.begin(), v1.end());
	my_copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));

通过函数对象，实现从小到大（less)排序，
或从大到小（greater)排序

template <typename IT,typename PRE>
void msort(const IT& first, const IT& last,PRE pre)  
{
	
	for (IT tmp = first; tmp != last; tmp++)
	{
		for (IT tmp1 = tmp + 1; tmp1 != last; tmp1++)
		{
			
			if(!pre(*tmp,*tmp1))
			{
				mswap(*tmp, *tmp1);
			}
		}
	}
}

第三个参数为Mless的对象
msort(v1.begin(), v1.end(),Mless());

find_if

查找第一个小于10的

template <typename IT,typename PRE>
IT mfind_if(const IT& first, const IT& last, PRE pre)//传入绑定器的对象
{
	IT tmp = first;
	for (; tmp != last; tmp++)
	{
		//if (*tmp < 10)
		//if(less(*tmp,10))
		//外界会将10传进来 拿到tmp和10进行比较，是否满足查找条件
		if(pre(*tmp))//给pre对象传入遍历的tmp的值 看它是否满足
		{
			return tmp;
		}
	}
	return last;
}

int main()
{
	vector<int> v1;
	for (int i = 10; i >0; i--)
	{
		v1.push_back(i);
	}
	//		迭代器区间           拷贝到输出流迭代器
	my_copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));//完成输出v1
	cout << endl;
//查找第一个小于10的元素												//绑定Mless对象的第二个参数
	vector<int>::iterator it1=find_if(v1.begin(), v1.end(), binder2nd<Mless<int>>(Mless<int>(),10));
	if (it1 == v1.end())//等于第二个参数，没找到
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it1 << endl;
	}
	return 0;
}

函数对象

less <

//函数对象
template<typename T>
class Mless
{
public:
	bool operator()(T a, T b)//重载括号运算符
	{
		cout << "bool operator()(T a, T b)" << endl;
		return a < b;
	}
};

template<typename T>
bool  mless(T a, T b)
{
	return a < b;
}

int main()
{
	vector<int> v1;
	for (int i = 10; i >0; i--)
	{
		v1.push_back(i);
	}
	//		迭代器区间           拷贝到输出流迭代器
	my_copy(v1.begin(), v1.end(), ostream_iterator<int>(cout, " "));//完成输出v1
	cout << endl;

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

greater >

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

binder1st 绑定器给函数对象绑定第一个参数

//绑定器1
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;
};

binder2nd 给函数对象绑定第二个参数

//函数对象  
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   给函数参数绑定参数
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;
};

标签：tmp,pre,last,cout,v1,算法,PRE,泛型,函数
来源： https://blog.csdn.net/weixin_54670782/article/details/121554283

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9