实现的一些内存辅助操作函数

#ifndef _STL_UNINITIALIZED_H_
#define _STL_UNINITIALIZED_H_

#include "stl_algobase.h"
#include "stl_iterator.h"
#include "type_traits.h"

//#include <algorithm>

namespace zstd
{
/***************************************************************************/
template<class InputIterator, class ForwardIterator, class T>
ForwardIterator _uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result, T*);
template<class InputIterator, class ForwardIterator>
ForwardIterator _uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result, _true_type);
template<class InputIterator, class ForwardIterator>
ForwardIterator _uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result, _false_type);

template<class InputIterator, class ForwardIterator>
ForwardIterator
inline uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result)
{
return _uninitialized_copy(first, last, result, value_type(result));
}
template<>
inline char *uninitialized_copy(const char *first, const char *last, char *result)
{
memmove(result, first, last - first);
return result + (last - first);
}
template<>
inline char *uninitialized_copy(char *first, char *last, char *result)
{
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, (last - first) * sizeof(wchar_t));
return result + (last - first);
}
template<>
inline wchar_t *uninitialized_copy(wchar_t *first, wchar_t *last, wchar_t *result)
{
memmove(result, first, (last - first) * sizeof(wchar_t));
return result + (last - first);
}
template<class InputIterator, class ForwardIterator, class T>
inline ForwardIterator _uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result, T*)
{
typedef typename _type_traits<T>::is_POD_type is_POD_type;
return _uninitialized_copy_aux(first, last, result, is_POD_type());
}
template<class InputIterator, class ForwardIterator>
inline ForwardIterator _uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result, _true_type)
{
return std::copy(first, last, result);//到时候记得自己实现copy
}
template<class InputIterator, class ForwardIterator>
ForwardIterator _uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result, _false_type)
{
ForwardIterator cur = result;
try
{
for (; first != last; ++first, ++cur)
construct(&*cur, *first);
}
catch (...)
{
destroy(result, cur);
}
return cur;
}

/***************************************************************************/
template<class ForwardIterator, class T, class T1>
void _uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x, T1*);
template<class ForwardIterator, class T>
void _uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, _true_type);
template<class ForwardIterator, class T>
void _uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, _false_type);

template<class ForwardIterator, class T>
void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x)
{
_uninitialized_fill(first, last, x, value_type(first));
}
template<class ForwardIterator, class T, class T1>
void _uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x, T1*)
{
typedef typename _type_traits<T1>::is_POD_type is_POD;
_uninitialized_fill_aux(first, last, x, is_POD());
}
template<class ForwardIterator, class T>
void _uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, _true_type)
{
fill(first, last, x);
}
template<class ForwardIterator, class 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<class ForwardIterator, class Size, class T, class T1>
ForwardIterator _uninitialized_fill_n(ForwardIterator first,
Size n, const T& x, T1*);
template<class ForwardIterator, class Size, class T>
ForwardIterator _uninitialized_n_fill_aux(ForwardIterator first,
Size n, const T& x, _true_type);
template<class ForwardIterator, class Size, class T>
ForwardIterator _uninitialized_n_fill_aux(ForwardIterator first,
Size n, const T& x, _false_type);

template<class ForwardIterator, class Size, class T>
inline ForwardIterator uninitialized_fill_n(ForwardIterator first,
Size n, const T& x)
{
return _uninitialized_fill_n(first, n, x, value_type(first));
}
template<class ForwardIterator, class Size, class T, class T1>
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<class ForwardIterator, class Size, class T>
ForwardIterator _uninitialized_n_fill_aux(ForwardIterator first,
Size n, const T& x, _true_type)
{
return fill_n(first, n, x);
}
template<class ForwardIterator, class Size, class T>
ForwardIterator _uninitialized_n_fill_aux(ForwardIterator first,
Size n, const T& x, _false_type)
{
ForwardIterator cur = first;
for (; n > 0; --n, ++cur)
construct(&*cur, x);
return cur;
}

}
#endif