《stl源码剖析》-- 内存基本处理工具

STL定义有五个全局函数，作用于未初始化空间上，它们分别是：construct(), destroy(), uninialized_copy(), uninialized_fill()和uninialized_fill_n()。

其中前两个函数前文已经介绍，这里就着重介绍后三个函数。

函数的作用

uninialized_copy()函数

函数原型：

template <class InputIterator, class ForwardIterator>
inline ForwardIterator
uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result) ;

如果[result, result+(last-first))范围内的每一个迭代器都指向未初始化区域，则该函数会使用copy_constructor，给身为输入来源[first, last)范围内的每一个对象产生一个副品，

放进输出范围中，也就是说使用[first, last)范围内的元素初始化对应的[result, result+(last-first))元素。

uninialized_fill函数

函数原型：

template <class ForwardIterator, class T>
inline void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);

如果[first, last)范围内的每个迭代器都指向未初始化区域，那么该函数会在该范围内产生x的复制品。也就是说使用x初始化范围[first, last)的每一个元素。

uninialized_fill_n函数

函数原型：

template <class ForwardIterator, class Size, class T>
inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);

如果[first, first+n)范围内的每个迭代器都指向未初始化区域，那么该函数会在该范围内产生x的复制品。也就是说使用x初始化范围[first, first+n)的每一个元素。

C++标准对这三个函数都有一个要求：具有commit or roolback语意，意思是要么初始化所有的元素，要么（当其中有一个元素初始化失败时）不构造任何东西。

函数的实现

这三个函数的实现思路完全一样，明白了一个如何实现，自然也就明白了另外两个。

我们就以uninialized_copy()函数为例来分析函数的实现。

uninialized_copy()函数的实现如下图所示：



实现代码如下（省去了异常处理）：

//__uninitialized_copy_aux
template <class InputIterator, class ForwardIterator>
inline ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result,
__true_type) {
return copy(first, last, result);  //copy函数仅仅只做赋值操作，不会调用任何构造函数
}

template <class InputIterator, class ForwardIterator>
ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result,
__falst_type) {
ForwardIterator cur = result;

for ( ;first != last; ++first, ++cur)
construct(&*cur, *first);       //构造函数，实现2.2.3节已经给出

return cur;
}

//__uninitialized_copy
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()); //判断T是否是POD类型
}

//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);
}

结合代码和函数调用图，整体实现思路不难看懂。

下面给出uninitialized_fill()和uninitialized_fill_n()实现代码，思路和uninitialized_copy()函数完全一样

//////////////////////////////////////////////////////////////////////
/////uninitialized_fill函数的实现
template <class ForwardIterator, class T>
inline void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, __true_type)
{
fill(first, last, x);       //直接把x的值放入内存区块，不调用构造函数
}

inline void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, __true_type)
{
ForwardIterator cur = first;
for ( ; cur != last; cur++)
construct(&*cur, x);
}

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_copy_aux(first, last, x, is_POD());
}

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

///////////////////////////////////////////////////////////////
//uninitialized_fill_n()函数的实现
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);         //直接赋值，不调用构造函数
}

template <class ForwardIterator, class Size, class T>
inline ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __falst_type) {
ForwardIterator cur = first;

for (; n > 0; --n, ++cur)
construct(&*cur, x);
return cur;
}

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;
return __uninitialized_fill_n_aux(first, n, x, is_POD());
}

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));
}

这三个函数会对STL中容器的实现有很大帮助。