//type_traits.h----应用于STL内部，而非规范化内容
//类似的，利用对象来特例化
struct __true_type {
};
struct __false_type {
};
//设计榨取机
template <class type>
struct __type_traits {
typedef __true_type this_dummy_member_must_be_first;
/* Do not remove this member. It informs a compiler which
automatically specializes __type_traits that this
__type_traits template is special. It just makes sure that
things work if an implementation is using a template
called __type_traits for something unrelated. */
/* The following restrictions should be observed for the sake of
compilers which automatically produce type specific specializations
of this class:
- You may reorder the members below if you wish
- You may remove any of the members below if you wish
- You must not rename members without making the corresponding
name change in the compiler
- Members you add will be treated like regular members unless
you add the appropriate support in the compiler. */
typedef __false_type has_trivial_default_constructor;//是否默认构造函数---false表示采取非快速的方式
typedef __false_type has_trivial_copy_constructor;//是否复制构造函数----- 需要用到construtor,destructor
typedef __false_type has_trivial_assignment_operator;//是否分配空间函数--- 而不是malloc,memcpy
typedef __false_type has_trivial_destructor;//是否注销函数
typedef __false_type is_POD_type;//是否传统处理
};
//特化例子---都采取了快速方式了进行一下操作，拷贝，赋值
__STL_TEMPLATE_NULL struct __type_traits<char> {
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
//特化版本有：
//char ，signed char，unsigned char，short，unsigned short
//int,unsigned int,long,unsigned long,float,double,long double
//T* ,char*,signed char*,unsigned char*
//-------------------------------------------------------------------------------------------------------
//stl_uninitialized.h文件介绍全局函数
//uninitialized_fill函数--赋值函数，初始化迭代器区间值
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));
}
//
//
//具体实施函数是__uninitialized_fill_n
template <class ForwardIterator, class Size, class T, class T1>
inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n,
const T& x, T1*) {
typedef typename __type_traits<T1>::is_POD_type is_POD;//可以看出是否具有特化版本，是则用，不是则用泛化
//泛化则会返回__false_type是一种安全保险的处理，调用了constructor之类的；
//特化则会返回__true_type是一种高效的处理，因为表示该类型T1具有复制构造，默认构造，分配空间这行函数
return __uninitialized_fill_n_aux(first, n, x, is_POD());//此处利用类型对象，编译时就能确定调用哪个模板
}
//为__true_type的处理
template <class ForwardIterator, class Size, class T>
inline ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __true_type) {
return fill_n(first, n, x);
}
//此函数在stl_algobase.h文件中实现的。
template <class OutputIterator, class Size, class T>
OutputIterator fill_n(OutputIterator first, Size n, const T& value) {
for ( ; n > 0; --n, ++first)
*first = value;//就是个赋值的过程，显然这样可以交付给系统处理了
return first;
}
//为__false_type的处理
template <class ForwardIterator, class Size, class T>
ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __false_type) {
ForwardIterator cur = first;
__STL_TRY {//是tyr的宏
for ( ; n > 0; --n, ++cur)
construct(&*cur, x);//这是需要人为调用了系统的construct函数，在stl_construct.h文件中
return cur;
}
//如果没有完全成功，则把之前的成功全部释放
__STL_UNWIND(destroy(first, cur));//#define __STL_UNWIND(action) catch(...) { action; throw; }
}
//
//
//具体实施函数是uninitialized_fill
//
template <class ForwardIterator, class T>
inline 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>
inline 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());
}
//true
template <class ForwardIterator, class T>
inline void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, __true_type)
{
fill(first, last, x);
}
//此函数在stl_algobase.h文件中实现的
template <class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value) {
for ( ; first != last; ++first)
*first = value;
}
//false
template <class ForwardIterator, class T>
void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, __false_type)
{
ForwardIterator cur = first;
__STL_TRY {
for ( ; cur != last; ++cur)
construct(&*cur, x);
}
__STL_UNWIND(destroy(first, cur));
}
//
//
//具体实施函数是uninitialized_copy
//
//泛化
template <class InputIterator, class ForwardIterator>
inline ForwardIterator
uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result) {
return __uninitialized_copy(first, last, result, value_type(result));
}
//特化
inline char* uninitialized_copy(const char* first, const char* last,
char* result) {
memmove(result, first, last - first);
return result + (last - first);
}
//特化
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 <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;
return __uninitialized_copy_aux(first, last, result, is_POD());
}
//true
template <class InputIterator, class ForwardIterator>
inline ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result,
__true_type) {
return copy(first, last, result);//在stl_algobase.h实现
}
//false
template <class InputIterator, class ForwardIterator>
ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result,
__false_type) {
ForwardIterator cur = result;
__STL_TRY {
for ( ; first != last; ++first, ++cur)
construct(&*cur, *first);
return cur;
}
__STL_UNWIND(destroy(result, cur));
}
