五种内存处理基本工具

//myconstruct.h
#ifndef _MYCONSTRUCT
#define _MYCONSTRUCT
#include"myiterator.h"
#include<algorithm>
using std::copy;
using std::fill_n;
using std::fill;
/**********内存处理基本工具**********************/
//五个全局函数，作用于未初始化的空间
//----------------------------------------------------------------
//将初值设定在指针指定的空间上
template<class T1,class T2>
inline void construct(T1* p,const T2& value)
{
	new(p) T1(value);
}

//---------------------------------------------------------------------
//destroy
//版本一：析构指针所指的对象，注意并不释放内存
template<typename T>
inline void destroy(T* pointer)
{
	pointer->~T();
}
/*版本二析构迭代器[first,last)范围内的对象析构掉
 *如果对象的析构函数都无关紧要，那么调用这些析构函数，会极大降低效率
 *因此，首先利用value_type获得迭代器所指对象的型别；
 *再利用__type_traits<T>判断析构函数是否无关紧要，若是（_true_type),则什么也不做
 *若否（_false_type)，这样才调用每个元素的析构函数
 *value_type和__tyep_traits在迭代器代码中详解
 */
template<typename ForwardIterator>
inline void destroy(ForwardIterator first,ForwardIterator last)
{
	__destroy(first,last,value_type(first));
}
template<typename ForwardIterator,typename T>
inline void __destroy(ForwardIterator first,ForwardIterator last,T*)
{
	typedef typename __type_traits<T>::has_trivial_destructor  trival_destructor;
	__destroy_aux(first,last,trival_destructor());//trival_destructor()产生一个临时对象
}
//如果元素的数值型别（valuetype）有non-trival destructor
template<typename ForwardIterator>
void __destroy_aux(ForwardIterator first,ForwardIterator last,__false_type)
{
	for(;first<last;++first){
		destroy(&*first);//注意传递的参数是指针，而非迭代器
	}
}
//如果元素的数值类型有trival destructor
template<typename ForwardIterator>
inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__true_type)
{
}

//针对char*和w_char*的特化版本
template<>
inline void destroy(char*,char*){ }
template<>
inline void destroy(wchar_t*,wchar_t*){ }
//--------------------------------------------------------------------------------
/*此函数能够将内存的配置与对象的构造行为分开；如果目的地[result,result+(last-first))范围内
 *迭代器都指向未初始化区域，此函数使用copy constructor ，将输入的副本初始化目的地
 *具有“commit and rollback”即：要么构造出所有必要元素，要么不构造任何东西
 */
template<typename InputIterator,typename ForwardIterator>
inline ForwardIterator uninitialized_copy( InputIterator first, InputIterator last,
								   ForwardIterator result)
{
	return __unintialized_copy(first,last,result,value_type(result));
}
//此处拥有跟destroy函数一样的结构，有一点不同的是这里根据is_POD_type来判断
//POD指的是标量类型，或者传统的C struct型别，必然有trival 的构造/析构/copy/assignment
template<typename InputIterator,typename ForwardIterator,typename T>
inline ForwardIterator __unintialized_copy( InputIterator first, InputIterator last,
								   ForwardIterator result,T*)
{
	typedef typename __type_traits<T>::is_POD_type is_POD;
	return __uninitialized_copy_aux(first,last,result,is_POD());
}
//trival copy性质的型别
template<typename InputIterator,typename ForwardIterator>
inline ForwardIterator
	__uninitialized_copy_aux( InputIterator first, InputIterator last,
								   ForwardIterator result,__true_type)
{
	return copy(first,last,result);//STLcopy函数·，由于copy函数的代码过于庞大，就不在此处展开
}

//non-trival copy型别
template<typename InputIterator,typename ForwardIterator>
ForwardIterator __uninitialized_copy_aux( InputIterator first, InputIterator last,
								   ForwardIterator result,__false_type)
{
	ForwardIterator cur=result;
	for(;first!=last;++first,++cur){
		construct(&*cur,*first);
	}
	return cur;
}
//char* wchar_t*特化
template<>
inline char* uninitialized_copy(const char* first,const char* last,char* result)
{
	/*void *memmove( void* dest, const void* src,size_tcount );
	 *由src所指内存区域复制count个字节到dest所指内存区域。
	 */
	memmove(result,first,last-first);
	return result+(last-first);
}
template<>
inline wchar_t* uninitialized_copy(const wchar_t* first,const wchar_t* last,wchar_t* result){
	memmove(result,first,sizeof(wchar_t)*(last-first));
	return result+(last-first);
}

//------------------------------------------------------------------------------------------------
template<typename ForwardIterator,typename T>
inline void uninitialized_fill(ForwardIterator first,ForwardIterator last,const T& x)
{
	__uninitialized_fill(first,last,x,value_type(first));
}

template<typename ForwardIterator,typename T,typename T1>
inline void uninitialized_fill(ForwardIterator first,ForwardIterator last,const T& x,T1*)
{
	typedef typename __type_trait<T1>::is_POD_type is_POD;
	__uninitialized_fill_aux(first,last,x,is_POD());
}
template<typename ForwardIterator,typename T>
inline void __uninitialized_fill_aux(
	ForwardIterator first,ForwardIterator last,const T& x,__true_type)
{
	fill(first,last,x)//stl函数
}
template<typename ForwardIterator,typename T>
void __uninitialized_fill_aux(
	ForwardIterator first,ForwardIterator last,const T& x,__false_type)
{
	ForwardIterator cur=first;
	for(;cur!=last;++cur){
		construct(&*cur,x);
	}
}
//---------------------------------------------------------------------------
template<typename ForwardIterator ,typename Size,typename T>
inline ForwardIterator uninitialized_fill_n(ForwardIterator first,Size n,const T& x)
{
	return __uninitialized_fill_n(first,n,x,value_type(first));
}
template<typename ForwardIterator ,typename Size,typename T,typename T1>
inline ForwardIterator __uninitialized_fill_n(ForwardIterator first,Size n,const T& x,T1*)
{
	typedef typename __type_traits<T1>::is_POD_type is_POD;
	return __uninitialized_fill_n_aux(first,n,x,is_POD());
}
template<typename ForwardIterator ,typename Size,typename T>
inline ForwardIterator 
	__uninitialized_fill_n_aux(ForwardIterator first,Size n,const T& x,__true_type)
{
	return fill_n(first,n,x);//stl function
}
template<typename ForwardIterator ,typename Size,typename T,typename T1>
 ForwardIterator 
	uninitialized_fill_n_aux(ForwardIterator first,Size n,const T& x,__false_type)
 {
	 ForwardIterator cur=first;
	 for(;n>0;--n,++cur){
		 construct(&*cur,x);
	 }
	 return cur;
 }
#endif