学步园

template <class ForwardIterator>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last );

template <class ForwardIterator, class BinaryPredicate>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last,
                           BinaryPredicate pred );

<algorithm>

Remove consecutive duplicates in range

Removes the duplicate consecutive elements from the range [first,last). This is done by removing all the elements that compare equal to the element right preceding them (only the first element in each group of consecutive equal elements is kept).

The comparison between elements is performed by either applying the == comparison operator, or the template parameter comp (for the second version) between them.

The behavior of this function template is equivalent to:

template <class ForwardIterator>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last )
{
  ForwardIterator result=first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for the pred version
      *(++result)=*first;
  }
  return ++result;
}

Notice that this function does not alter the elements past the new end, which keep their old values and are still accessible.

Parameters

first, last

Forward iterators to the initial and final positions of the sequence. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but
not the element pointed by last.

pred

Binary predicate taking two elements as argument and returning the result of the comparison between them, with true (non-zero) meaning that they are to be considered equal, and false (zero) for not-equal. This
can either be a pointer to a function or an object whose class overloads operator().

Return value

A forward iterator pointing to the new end of the sequence, which now does not include the elements that were consecutive duplicates.

使用二元模板函数

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
class student{
	public:
		int key;
		int value;
	bool operator==(student s){
		return key==s.key;
}
};
template<class _inPara1,class _inPara2>
class isEqual:public binary_function<_inPara1,_inPara2,bool>{
	public:
		bool operator()(_inPara1 in1,_inPara2 in2){
			return in1==in2;
}
};
int main(){
	vector<student>vec(5);
	vec[0].key=1;
	vec[0].value=1;
	vec[1].key=1;
	vec[1].value=2;
	vec[2].key=2;
	vec[2].value=2;
	vec[3].key=3;
	vec[3].value=3;
	vec[4].key=4;
	vec[4].value=4;
	vector<student>::iterator it;
	it=unique(vec.begin(),vec.end(),isEqual<student&,student&>());
	vec.resize(it-vec.begin());
	for(it=vec.begin();it!=vec.end();it++)
		cout<<(*it).key<<endl;
}

定义一个比较函数

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
class student{
	public:
		int key;
		int value;
	bool operator==(student s){
		return key==s.key;
}
};
template<class _inPara1,class _inPara2>
class isEqual:public binary_function<_inPara1,_inPara2,bool>{
	public:
		bool operator()(_inPara1 in1,_inPara2 in2){
			return in1==in2;
}
};
bool cmp(student a,student b){
	return a.key==b.key;
}
int main(){
	vector<student>vec(5);
	vec[0].key=1;
	vec[0].value=1;
	vec[1].key=1;
	vec[1].value=2;
	vec[2].key=2;
	vec[2].value=2;
	vec[3].key=3;
	vec[3].value=3;
	vec[4].key=4;
	vec[4].value=4;
	vector<student>::iterator it;
//	it=unique(vec.begin(),vec.end(),isEqual<student&,student&>());
	it=unique(vec.begin(),vec.end(),cmp);
	vec.resize(it-vec.begin());
	for(it=vec.begin();it!=vec.end();it++)
		cout<<(*it).key<<endl;
}

重载运算符()

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
class student{
	public:
		int key;
		int value;
	bool operator()(student a,student b){
		return a.key==b.key;
}
};
int main(){
	vector<student>vec(5);
	vec[0].key=1;
	vec[0].value=1;
	vec[1].key=1;
	vec[1].value=2;
	vec[2].key=2;
	vec[2].value=2;
	vec[3].key=3;
	vec[3].value=3;
	vec[4].key=4;
	vec[4].value=4;
	vector<student>::iterator it;
//	it=unique(vec.begin(),vec.end(),isEqual<student&,student&>());
	it=unique(vec.begin(),vec.end(),student());
	vec.resize(it-vec.begin());
	for(it=vec.begin();it!=vec.end();it++)
		cout<<(*it).key<<endl;
}

重载==

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
class student{
	public:
		int key;
		int value;
		bool operator==(student s){
			return value==s.value;
}
};
student op(student s){
		s.value=s.value+1;
		return s;
}
int main(){
	vector<student>vec(5);
	vector<student>vec_sub;
	vec[0].key=1;
	vec[0].value=1;
	vec[1].key=1;
	vec[1].value=2;
	vec[2].key=2;
	vec[2].value=2;
	vec[3].key=3;
	vec[3].value=3;
	vec[4].key=4;
	vec[4].value=4;
	vec_sub.resize(vec.size());
	vector<student>::iterator it,p;
	p=unique(vec.begin(),vec.end());	
	for(it=vec.begin();it!=p;it++)
		cout<<(*it).value<<endl;
}