STL容器元素的删除

//合理选择删除算法或容器的删除成员函数。

//
//去除一个容器中有特定值的所有对象：
//

#include <vector>
#include <list>
#include <map>
#include <xstddef>

//如果容器是vector、string或deque，使用erase-remove惯用法。
template<typename containerT>
void erase_remove(containerT& c,typename containerT::value_type v)
{
	c.erase(std::remove(c.begin(),c.end(),v), c.end());

	//for verify
    /*
    containerT::iterator rItr=std::remove(c.begin(),c.end(),v); //前移，rItr为新的逻辑终点
    containerT::iterator itr=c.end(); //itr为旧的终点
    c.erase(rItr,itr);                //删除前移后多出的尾巴
	*/
}

//如果容器是list，使用list::remove，list的成员函数remove真的删除了元素。
template<typename value_type>
void list_remove(std::list<value_type>& ls, value_type v)
{
	ls.remove(v);
}

//如果容器是标准关联容器，使用它的erase成员函数，这里也真的删除了元素
template<typename value_type,typename key_type>
void map_erase(std::map<key_type,value_type>& mp, key_type v)
{
	mp.erase(v);
}

int main(int argc, const char* argv[])
{
	enum{SIZE=10};
	std::vector<int> data;
	data.resize(SIZE);
	for (int i=0;i<SIZE;++i)
	{
		data[i]=i+1;
	}

	erase_remove(data,5);

	std::list<int> ls;
	for (int i=0;i<SIZE;++i)
	{
		ls.push_back(i);
	}
	list_remove(ls,6);

	std::map<int,int> mp;
	for (int i=0;i<SIZE;++i)
	{
		mp.insert(std::make_pair(i+1,i));
	}
	map_erase(mp,7);

	system("pause");
	return 0;
}

//在循环内做某些事情（除了删除对象之外）：
//如果容器是标准序列容器，写一个循环来遍历容器元素，每当调用erase时都要用它的返回值更新你的迭代器。
//如果容器是标准关联容器，写一个循环来遍历容器元素，当你把迭代器传给erase是记得后置递增它。

//错误的做法
template<typename containerT, typename CondT>
void erase(containerT& c, CondT& cond)
{
	for (containerT::iterator itr=c.begin();
		itr!=c.end();++itr)
	{
		if(cond(*itr))
			c.erase(itr);
	}
}

//正确的做法
template<typename containerT, typename CondT>
void erase(containerT& c, CondT& cond)
{
	for (containerT::iterator itr=c.begin();
		itr!=c.end();)
	{
		if(cond(*itr))
			itr=c.erase(itr);//或c.erase(itr++)
		else 
			++itr;
	}
}

struct elm{
	typedef int value_type;
	value_type value;
};

//自定义结构
template<typename _Ty>
struct my_equal_to
	: public std::binary_function<_Ty, _Ty, bool>
{	
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
	{
		return (_Left.value == _Right.value);
	}
};

int main(int argc,const char* argv[])
{
	enum{SIZE=10};
	std::vector<int> rdata;
	rdata.resize(SIZE);
	for (int i=0;i<SIZE;++i)
	{
		rdata[i]=i+1;
	}
	erase(rdata,std::bind1st(std::equal_to<int>(), 6)); //elm为int类型

	//
	std::vector<elm> data;
	data.resize(SIZE);
	for (int i=0;i<SIZE;++i)
	{
		elm el;
		el.value=i+1;
		data[i]=el;
	}

	elm el;
	el.value=6;
	erase(data,std::bind1st(my_equal_to<elm>(), el)); //elm为自定义类型
        
        return 0;
 }