积累-destroy

#pragma once

#include <vector>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

#define SAFE_DELETE(point) do {delete (point); (point) = nullptr;} while(false);

template<class T>
struct auto_delete
{
	inline static void safe_delete( const T & )
	{

	}
};

template<class T>
struct auto_delete<T *>
{
	inline static void safe_delete( T* p )
	{
		SAFE_DELETE( p );
	}
};

template<class T>
struct auto_delete<const T *>
{
	inline static void safe_delete( const T* p )
	{
		SAFE_DELETE( p );
	}
};

template<class T>
struct destroyer
{
	inline static void destroy( const T & )
	{

	}
};

template<class T>
struct destroyer<T *>
{
	inline static void destroy( T* p )
	{
		auto_delete<T *>::safe_delete( p );
	}
};

template<class T>
struct destroyer<const T *>
{
	inline static void destroy( const T* p )
	{
		auto_delete<const T *>::safe_delete( p );
	}
};

template<class V, class A>
struct destroyer<typename std::vector<V, A> >
{
	inline static void destroy( const std::vector<V, A>& v )
	{
		for( typename std::vector<V, A>::const_iterator iter = v.begin(); iter != v.end(); ++iter )
		{
			destroyer<V>::destroy( *iter );
		}
	}
};

template<class V, class A>
struct destroyer<typename std::list<V, A> >
{
	inline static void destroy( const std::list<V, A>& l )
	{
		for( typename std::list<V, A>::const_iterator iter = l.begin(); iter != l.end(); ++iter )
		{
			destroyer<V>::destroy( *iter );
		}
	}
};

template<class K, class P, class A>
struct destroyer<typename std::set<K, P, A> >
{
	inline static void destroy( const std::set<K, P, A>& s )
	{
		for( typename std::set<K, P, A>::const_iterator iter = s.begin(); iter != s.end(); ++iter )
		{
			destroyer<K>::destroy( *iter );
		}
	}
};

template<class K, class V, class P, class A>
struct destroyer<typename std::map<K, V, P, A> >
{
	inline static void destroy( const std::map<K, V, P, A>& m )
	{
		for( typename std::map<K, V, P, A>::const_iterator iter = m.begin(); iter != m.end(); ++iter )
		{
			destroyer<K>::destroy( iter->first );
			destroyer<V>::destroy( iter->second );
		}
	}
};

template<class K, class V, class P, class A>
struct destroyer<typename std::multimap<K, V, P, A> >
{
	inline static void destroy( const std::multimap<K, V, P, A>& mm )
	{
		for( typename std::multimap<K, V, P, A>::const_iterator iter = mm.begin(); iter != mm.end(); ++iter )
		{
			destroyer<K>::destroy( iter->first );
			destroyer<V>::destroy( iter->second );
		}
	}
};

template< class K, class H, class E, class A >
struct destroyer< typename std::unordered_set< K, H, E, A > >
{
	inline static void destroy( const std::unordered_set< K, H, E, A >& us )
	{
		for( typename std::unordered_set<K, H, E, A>::const_iterator iter = us.begin(); iter != us.end(); ++iter )
		{
			destroyer<K>::destroy( *iter );
		}
	}
};

template< class K, class V, class H, class E, class A >
struct destroyer< typename std::unordered_map< K, V, H, E, A > >
{
	inline static void destroy( const std::unordered_map< K, V, H, E, A >& um )
	{
		for( typename std::unordered_map< K, V, H, E, A >::const_iterator iter = um.begin(); iter != um.end(); ++iter )
		{
			destroyer<K>::destroy( iter->first );
			destroyer<V>::destroy( iter->second );
		}
	}
};

template<class T>
void destroy( const T& v )
{
	destroyer<T>::destroy( v );
}

自行加入其它需要的类型即可，如果是容器调用过destroy后需要自行处理clear

template<class _Ty>
vector<_Ty> split(const char* src, const char* tokens)
{
	std::vector<_Ty> ret;
	if (!src)
		return ret;

	const char* str = src + strspn(src, tokens);
	while(*str)
	{
		const char* brk = strpbrk(str, tokens);
		if (NULL == brk)
		{
			std::istringstream oss(str);
			std::copy(std::istream_iterator<_Ty>(oss), std::istream_iterator<_Ty>(), std::back_inserter(ret));
			break;
		}

		std::istringstream oss(string(str, brk));
		std::copy(std::istream_iterator<_Ty>(oss), std::istream_iterator<_Ty>(), std::back_inserter(ret));
		str = brk + strspn(brk, tokens);
	}
	return ret;
}