STL函数重写第一步：非修改式操作

于 2013-06-14 10:55:40 发布
阅读量712 收藏
点赞数
分类专栏： STL C++ 文章标签： STL C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Grey110/article/details/9092531
版权
C++ 同时被 2 个专栏收录
2 篇文章 0 订阅
订阅专栏
STL
1 篇文章 0 订阅
订阅专栏

C++学习也是有一段时间了，但是感觉一直学没啥用，想弄点什么做做，就开始研究起STL来了，想着光会用也不行，于是就想着实现下，于是开始源源本本地实现起STL算法库中的函数，这只是开始，接下来会一直进行下去


这是STL算法库中所有的非修改式操作，包括C++11的一些函数哦（由于有些和标准库重名的，就稍微改了下名字，比如：iterator_traits改成了aiterator_traits）

template<class InputIterator,class Predicate>
	bool all_of(InputIterator first,InputIterator last,
							Predicate pred)
	{
		do
		{
			if(!pred(*first))
				return false;
		}while(++first!=last);
		return true;
	}

如果对于区间[first,last]中的每个迭代器，pred(*i)都为true，或者该区间为空，则函数all_of()返回true，否则返回false（C++11新特性） 

template<class InputIterator,class Predicate>
	bool any_of(InputIterator first,InputIterator last,
							Predicate pred)
	{
		do
		{
			if(pred(*first))
				return true;
		}while(++first!=last);
		return false;
	}

如果对于区间[first,last]中的每个迭代器，pred(*i)都为false，或者该区间为空，则函数any_of()返回false，否则返回true（C++11新特性） 

template<class InputIterator,class Predicate>
	bool none_of(InputIterator first,InputIterator last,
							Predicate pred)
	{
		do
		{
			if(pred(*first))
				return false;
		}while(++first!=last);
		return true;
	}

如果对于区间[first,last]中的每个迭代器，pred(*i)都为false，或者该区间为空，则函数none_of()返回true，否则返回false（C++11新特性） 

template<class InputIterator,class Function>
	Function for_each(InputIterator first,InputIterator last,
										Function f)
	{
		do
		{
			f(*first);
		}while(++first!=last);
		return f;
	}

for_each()函数将函数对象f用于[first,last]区间中的每个元素，它也返回f 

template<class InputIterator,class T>
	InputIterator find(InputIterator first,InputIterator last,
										 const T& value)
	{
		do
		{
			if(value==*first)
				return first;
		}while(++first!=last);
		return first;
	}

find()函数返回一个迭代器，该迭代器指向[first,last]区间中第一个值为value的元素，如果没有找到这样的元素，则返回last 

template<class InputIterator,class Predicate>
	InputIterator find_if(InputIterator first,InputIterator last,
												Predicate pred)
	{
		do
		{
			if(pred(*first))
				return first;
		}while(++first!=last);
		return first;
	}

find_if()函数返回一个迭代器，该迭代器指向[first,last]区间中的第一个对其调用函数对象pred(*i)时结果为true的元素；如果没有找到这样的元素，则返回last 

template<class InputIterator,class Predicate>
	InputIterator find_if_not(InputIterator first,InputIterator last,
												Predicate pred)
	{
		do
		{
			if(!pred(*first))
				return first;
		}while(++first!=last);
		return first;
	}

find_if_not()函数返回一个迭代器，该迭代器指向[first,last]区间中的第一个对其调用函数对象pred(*i)时结果为false的元素，如果没有找到这样的元素，则返回last（C++11新特性） 

template<class ForwardIterator1,class ForwardIterator2>
	ForwardIterator1 find_end(ForwardIterator1 first1,ForwardIterator1 last1,
														ForwardIterator2 first2,ForwardIterator2 last2)
	{
		assert(distance(first1,last1)>=distance(first2,last2));
		if(first2==last2)
			return last1;
		ForwardIterator1 ret=last1;
		while(first1!=last1)
		{
			ForwardIterator1 ft1=first1;
			ForwardIterator2 ft2=first2;
			while(*ft1==*ft2)
			{
				ft1++;
				ft2++;
				if(ft2==last2)
				{	
					ret=first1;
					break;
				}
				if(ft1==last1)
					return ret;
			}
			first1++;
		}
		return ret;
	}
	
	template<class ForwardIterator1,class ForwardIterator2,
					class BinaryPredicate>
	ForwardIterator1 find_end(ForwardIterator1 first1,ForwardIterator1 last1,
														ForwardIterator2 first2,ForwardIterator2 last2,
														BinaryPredicate pred)
	{
		assert(distance(first1,last1)>=distance(first2,last2));
		if(first2==last2)
			return last1;
		ForwardIterator1 ret=last1;
		while(first1!=last1)
		{
			ForwardIterator1 ft1=first1;
			ForwardIterator2 ft2=first2;
			while(pred(*ft1,*ft2))
			{
				ft1++;
				ft2++;
				if(ft2==last2)
				{
					ret=first1;
					break;
				}
				if(ft1==last1)
					return ret;
			}
			first1++;
		}
		return ret;
	}

find_end()函数返回一个迭代器，该迭代器指向[first1,last1]区间中的最后一个与[first2,last2]区间的内容匹配的序列的第一个元素。第一个版本使用值类型的==运算符来比较元素；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果
pred(*i1,*i2)为true，则i1和i2指向的元素匹配。如果没有找到这样的元素，则它们都返回last1 

template<class ForwardIterator1,class ForwardIterator2>
	ForwardIterator1 find_first_of(ForwardIterator1 first1,ForwardIterator1 last1,
																 ForwardIterator2 first2,ForwardIterator2 last2)
	{
		assert(distance(first1,last1)>=distance(first2,last2));
		if(first2==last2)
			return last1;
		for(;first1!=last1;++first1)
		{
			for(ForwardIterator2 fi2=first2;fi2!=last2;++fi2)
			{
				if(*first1==*fi2)
					return first1;
			}
		}
		return first1;
	}
	
	template<class ForwardIterator1,class ForwardIterator2,
					 class BinaryPredicate>
	ForwardIterator1 find_first_of(ForwardIterator1 first1,ForwardIterator1 last1,
																 ForwardIterator2 first2,ForwardIterator2 last2,
																 BinaryPredicate pred)
	{
		assert(distance(first1,last1)>=distance(first1,last1));
		if(first2==last2)
			return last1;
		for(;first1!=last1;++first1)
		{
			for(ForwardIterator2 fi2=first2;fi2!=last2;++fi2)
			{
				if(pred(*first1,*fi2))
					return first1;
			}
		}
		return first1;
	}

find_first_of()函数返回一个迭代器，该迭代器指向区间[first1,last1]中第一个与[first2,last2]区间中的任何元素匹配的元素。第一个版本使用值类型的==运算符对元素进行比较；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(*i1,*i2)为true，则i1和i2指向的元素匹配。如果没有找到这样的元素，则它们都返回last1 

template<class ForwardIterator>
	ForwardIterator adjacent_find(ForwardIterator first,ForwardIterator last)
	{
		if(first==last)
			return last;
		for(ForwardIterator ret;ret=first,first++!=last;)
		{
			if(*ret==*first)
				return ret;
		}
		return last;
	}
	
	template<class ForwardIterator,class BinaryPredicate>
	ForwardIterator adjacent_find(ForwardIterator first,ForwardIterator last,
																BinaryPredicate pred)
	{
		if(first==last)
			return last;
		for(ForwardIterator ret;ret=first,first++!=last;)
		{
			if(pred(*ret,*first))
				return ret;
		}
		return last;
	}

adjacent_find()函数返回一个迭代器，该迭代器指向[first1,last1]区间中第一个与其紧接着的后面的一个元素匹配的元素。如果没有找到这样的元素，则返回last。第一个版本使用值类型的==运算符来对元素进行比较；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(*i1,*i2)为true，则i1和i2指向的元素匹配。 

template<class InputIterator,class T>
	typename aiterator_traits<InputIterator>::difference_type
		count(InputIterator first,InputIterator last,const T& value)
	{
		if(first==last)
			return 0;
		typename aiterator_traits<InputIterator>::difference_type counter=0;
		while(first!=last)
		{
			if(*first==value)
				counter++;
			first++;
		}
		return counter;
	}

count()函数返回[first,last]区间中与值value匹配的元素数目。对值进行比较时，将使用值类型的==运算符。返回值类型为整数，它足以存储容器所能存储的最大元素数 

template<class InputIterator,class Predicate>
	typename aiterator_traits<InputIterator>::difference_type
		count_if(InputIterator first,InputIterator last,Predicate pred)
	{
		if(first==last)
			return 0;
		typename aiterator_traits<InputIterator>::difference_type counter=0;
		while(first!=last)
		{
			if(pred(*first))
				counter++;
			first++;
		}
		return counter;
	}

count_if()函数返回[first,last]区间中所有如果pred(*i)为true的这样的元素的数目 

template<class InputIterator1,class InputIterator2>
	std::pair<InputIterator1,InputIterator2>
	 _mismatch(InputIterator1 first1,InputIterator1 last1,
	 					InputIterator2 first2)
	{
		if(first1==last1)
			return std::pair<InputIterator1,InputIterator2>(last1,first2+(last1-first1));
		for(;first1!=last1&&*first1==*first2;)
		{
			++first1;
			++first2;
		}
		return std::pair<InputIterator1,InputIterator2>(first1,first2);
	}
															
	template<class InputIterator1,class InputIterator2,
						class BinaryPredicate>
	std::pair<InputIterator1,InputIterator2>
	 _mismatch(InputIterator1 first1,InputIterator1 last1,
	 					InputIterator2 first2,BinaryPredicate pred)
	{
		if(first1==last1)
			return std::pair<InputIterator1,InputIterator2>(last1,first2+(last1-first1));
		for(;first1!=last1&&pred(*first1,*first2);)
		{
			++first1;
			++first2;
		}
		return std::pair<InputIterator1,InputIterator2>(first1,first2);
	}

每个mismatch()函数都在[first1,last1]区间中查找第一个从first2开始的区间中相应元素不匹配的元素，并返回两个迭代器，它们指向不匹配的两个元素。如果没有发现不匹配的情况，则返回值为pair<last1,first2+(last1-first1)>。第一个版本使用==运算符来测试匹配情况；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(*i1,*i2)为false，则i1和i2指向的元素不匹配（注意：原函数是mismatch，这里改名了） 

template<class InputIterator1,class InputIterator2>
	bool _equal(InputIterator1 first1,InputIterator1 last1,
						 InputIterator2 first2)
	{
		if(first1==last1)
			return false;
		for(;first1!=last1;++first1,++first2)
		{
			if(*first1!=*first2)
				return false;
		}
		return true;
	}
						 
	template<class InputIterator1,class InputIterator2,
					 class BinaryPredicate>
	bool _equal(InputIterator1 first1,InputIterator1 last1,
						 InputIterator2 first2,BinaryPredicate pred)
	{
		if(first1==last1)
			return false;
		for(;first1!=last1;++first1,++first2)
		{
			if(!pred(*first1,*first2))
				return false;
		}
		return true;
	}

如果[first1,last1]区间中每个元素都与以first2开始的序列中相应元素匹配，则equal()函数返回true，否则返回false。第一个版本使用值类型的==运算符来比较元素；第二个版本使用二元谓词函数对象pred来比较元素，即如果pred(*i1,*i2)为true，则i1和i2指向的元素匹配(原函数名equal，这里改了) 

template<class InputIterator1,class InputIterator2>
	bool is_permutation(InputIterator1 first1,InputIterator1 last1,
											InputIterator2 first2)
	{
		if(first1==last1)
			return false;
		for(;first1!=last1;++first1,++first2)
			if(!(*first1==*first2))
				break;
		if(first1!=last1)
		{
			InputIterator2 last2=first2;
			advance(last2,distance(first1,last1));
			for(InputIterator1 it1=first1;it1!=last1;++it1)
			{
				if(it1==find(first1,it1,*it1))
				{
					typename aiterator_traits<InputIterator2>::difference_type counter=count(first2,last2,*it1);
					if(counter==0||counter!=count(it1,last1,*it1))
						return false;
				}
			}
		}
		return true;
	}
											
	template<class InputIterator1,class InputIterator2,
					 class BinaryPredicate>
	bool is_permutation(InputIterator1 first1,InputIterator1 last1,
											InputIterator2 first2,BinaryPredicate pred)
	{
		if(first1==last1)
			return false;
		for(;first1!=last1;++first1,++first2)
			if(!(pred(*first1,*first2)))
				break;
		if(first1!=last1)
		{
			InputIterator2 last2=first2;
			advance(last2,distance(first1,last1));
			for(InputIterator1 it1=first1;it1!=last1;++it1)
			{
				if(it1==find_if(first1,it1,*it1,pred))
				{
					typename aiterator_traits<InputIterator2>::difference_type counter=count_if(first2,last2,*it1,pred);
					if(counter==0||counter!=count_if(it1,last1,*it1,pred))
						return false;
				}
			}
		}
		return true;
	}

如果通过对从first2开始的序列进行排序，可使其与区间[first1,last1]相应的元素匹配，则函数is_permutation()返回true，否则返回false。第一个版本使用值类型的==运算符来比较元素；第二个版本使用二元谓词函数对象pred来比较元素，即，如果
pred(*i1,*i2)为true，则i1和i2指向的元素匹配（C++11新特性） 

template<class ForwardIterator1,class ForwardIterator2>
	ForwardIterator1 search(ForwardIterator1 first1,ForwardIterator1 last1,
													ForwardIterator2 first2,ForwardIterator2 last2)
	{
		assert(distance(first1,last1)>=distance(first2,last2));
		if(first1==last1)
			return last1;
		int counter1,counter2;
		_distance(first1,last1,counter1);
		_distance(first2,last2,counter2);
		for(;counter2<=counter1;++first1,--counter1)
		{
			ForwardIterator1 fi1=first1;
			for(ForwardIterator2 fi2=first2;;++fi2,++fi1)
			{
				if(fi2==last2)
					return first1;
				else if(!(*fi2==*fi1))
					break;
			}
		}
		return last1;
	}
													
	template<class ForwardIterator1,class ForwardIterator2,
					 class BinaryPredicate>
	ForwardIterator1 search(ForwardIterator1 first1,ForwardIterator1 last1,
													ForwardIterator2 first2,ForwardIterator2 last2,
													BinaryPredicate pred)
	{
		assert(distance(first1,last1)>=distance(first2,last2));
		if(first1==last1)
			return last1;
		int counter1,counter2;
		_distance(first1,last1,counter1);
		_distance(first2,last2,counter2);
		for(;counter2<=counter1;++first1,--counter1)
		{
			ForwardIterator1 fi1=first1;
			for(ForwardIterator2 fi2=first2;;++fi2,++fi1)
			{
				if(fi2==last2)
					return first1;
				else if(!pred(*fi1,*fi2))
					break;
			}
		}
		return last1;
	}

search()函数在[first1,last1]序列中搜索第一个与[first2,last2]区间中相应的序列匹配的序列；如果没有找到这样的序列，则返回last1。第一个版本使用值类型的==运算符来对元素进行比较；第二个版本使用二元谓词对象pred来比较元素，即：如果
pred(*i1,*i2)为true，则i1和i2指向的元素是匹配的 

template<class ForwardIterator,class Size,class T>
	ForwardIterator search_n(ForwardIterator first,ForwardIterator last,
													 Size count,const T &value)
	{
		if(first==last||count<=0)
			return last;
		for(;first!=last;++first)
		{
			if(*first==value)
			{
				ForwardIterator fi=first;
				for(Size c=count;;)
				{
					if(--c==0)
						return first;
					else if(++fi==last)
						return last;
					else if(!(*fi==value))
						break;
				}
				first=fi;
			}
		}
		return last;
	}
													 
	template<class ForwardIterator,class Size,class T,
					 class BinaryPredicate>
	ForwardIterator search_n(ForwardIterator first,ForwardIterator last,
													 Size count,const T &value,BinaryPredicate pred)
	{
		if(first==last||count<=0)
			return last;
		for(;first!=last;++first)
		{
			if(pred(*first,value))
			{
				ForwardIterator fi=first;
				for(Size c=count;;)
				{
					if(--c==0)
						return first;
					else if(++fi==last)
						return last;
					else if(!pred(*fi,value))
						break;
				}
				first=fi;
			}
		}
		return last;
	}
}

search_n()函数在[first,last]区间中查找第一个与count个value组成的序列匹配的序列；如果没有找到这样的序列，则返回last。第一个版本使用值类型的==运算符来对元素进行比较；第二个版本使用谓词函数对象pred来比较元素。即：如果pred(*i,value)为true，则i1指向的元素和value是匹配的


写到这，STL算法库中的非修改式操作就算完了，敬请期待接下来的修改式序列操作



Yale_Yange
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值