自己动手实现STL 03：内存基本处理工具(stl_uninitialized.h)

一、前言

　　前面两篇已经编写了内存配置器和建构解构工具函数。这里，就准备编写并介绍下内存基本处理工具函数。比如uninitialized_copy()、uninitialized_copy和 uninitialized_copy_n()等的实现。

二、内存工具函数简介

1.uninitialized_copy函数

　　uninitialized_copy()使我们能够将内存的配置与对象的建构行为分离开来。如果作为输出目的地的[result, result+(last-first))范围内的每一个迭代器都指向未初始化区域，则uninitialized_copy()会使用copy construct,为身为输入来源[first, last)范围内的每一个对象产生一份复制品，放进输出范围中。

　　如果你需要初始化一个容器的话，这个函数可以其很大最用。通过用两步完成：配置内存区块；然后使用uninitizlied_copy,在该内存区块上建构元素。

　　c++标准还规定uninitialized_copy()具有"commit or rollback"语意。即，要么建构出所有元素，要么不建构任何东西，不能存在半建构状态。

　　下面是uninitialized_copy函数调用结构图：

图1：uninitialized_copy函数体系

　　uninitialized_copy()是一个模版函数：

 1 // uninitialized_copy 的函数模板
 2 // uninitialized_copy -> __uninitialized_copy
 3 // 利用编译器的类型推导，萃取处迭代器指向的类型
 4 // 以便最后通过类型萃取__type_traits机制获取迭代器指向类型的一些属性
 5 template <class InputIterator, class ForwardIterator>
 6 inline ForwardIterator
 7 uninitialized_copy(InputIterator first, InputIterator last,
 8         ForwardIterator result)
 9 {
10     // value_type是个模板函数，萃取迭代器指向类型，用该类型生成临时对象，
11     // 再利用类型推导
12     return __uninitialized_copy(first, last, result, value_type(result));
13 
14 }

　　在uninitialized_copy()内调用了一个内部的实现函数__uninitialized_copy()，这个调用的目的就是为了利用编译器的类型推导功能，获取迭代器的指向对象的类型。下面是内部调用的__unintialized_copy()函数:

 1 // __uninitialized_copy-->__uninitilaized_copy_aux
 2 // 是为利用编译器的类型参数推导，判断是否是POD类型
 3 template <class InputIterator, class ForwardIterator, class T>
 4 inline ForwardIterator
 5 __uninitialized_copy(InputItearator first, InputIeratorlast,
 6         ForwardIterator result, T*)
 7 {
 8     // is_POD 是一种类型,或者是__true_type代表为真，__
 9     // false_type代表为否，假
10     // 利用is_POD的不同定义，生成不同的临时对象，用其进行重载
11     typedef typename __type_traits<T>::is_POD_type  is_POD;
12     return __uninitialized_copy_aux(first, last, result, is_POD());
13 }

　　在__uninitialized_copy()内部又利用了类型属性萃取类型萃取了迭代器指向对象类型是否是POD，并利用is_POD生成对象用于重载。对于__uninitialized_copy_aux()，源码如下：

a. is_POD定义为__true_type

// 如果是POD型别,那么copy construction 等同于 assignment，而且
// destruction 是trivial,以下就有效
// 执行流程就会转进到以下函数。
// POD  意指Plain Old Data,指标量型别或者是传统的C Struct型别
// POD型别必须拥有trivial ctor/dtor/copy/assignment函数
// 这是藉由function template的参数推导机制而得
template <class InputIterator, class ForwardIterator>
inline ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
                        ForwardIterator result,
                        __true_type)
{
    //这里的_true_type 代表迭代器指向的类型是POD型别，不用构造，可以
    //直接拷贝
    return copy(first, last, result);
}

b.is_POD定义为__false_type

　　不是POD类型，那么对于每一个元素，都需要调用其copy construct函数进行构造

 1 template <class InputIterator, class ForwardIterator>
 2 ForwardIerator
 3 __uninitialized_copy_aux(InputIterator first, InputIterator last,
 4                         ForwardIterator result,
 5                         __false_type)
 6 {
 7     //这里的_false_type 代表迭代器指向的类型非POD型别，
 8     //不能直接拷贝，需要一个一个的调用其构造函数
 9     ForwardIterator cur = result;
10     __STL_TRY
11     {
12         for (; first != last; ++first, ++cur)
13             construct(&*cur, *first);
14         return cur;
15     }
16     //commit or rollback
17     __STL_UNWIND(destroy(result, cur));
18 }

c.针对char*和wchar_t* 的特化版本

　　对于char*类型的迭代器，其迭代器指向的对象类型是char，对于char利用内存底层的memmove()复制速度更快。所以针对char*编写出其的特化版本。上述理由对于wchar_t*也是成立。源码如下：

1 // uninitialized_copy 对于char* 的特化版本
2 inline char* uninitialized_cpoy(const char* first, const char* last,
3         char* result)
4 {
5     //对于char *对其使用memmove效率最高
6     memmove(result, first, last - first);
7     return result + (last - first);
8 }

1 // unitialized_copy 对于 wchar_t* 的特化版本
2 inline wchar_t* uninitialized_copy(const wchar_t* first,
3         const wchar_t* last, wchar_t* result)
4 {
5     //同样对于wchar_t *对其使用memmove效率最高
6     memmove(result, first, sizeof(wchar_t) * (last - first));
7     return result + (last - first);
8 }

 

2.uninitialized_copy_n函数

　　该函数调用接口为uninitialized_copy_n(InputIterator first, Size count,ForwardIterator result)，这个函数接受一个输入迭代器，和输出迭代器，以及要复制的个数。

　　函数对外的接口实现：

 1 template <class InputIterator, class Size, class ForwardIterator>
 2 inline pair<InputIterator, ForwardIterator>
 3 uninitialized_copy_n(InputIterator first, Size count,
 4         ForwardIterator result)
 5 {
 6     // 利用模板函数iterator_category提取出first迭代器的分类型别
 7     // 然后利用其型别进行重载，对于不同的型别进行不同的优化处理
 8     return __uninitialized_copy_n(first, count, result,
 9             iterator_category(first));
10 }

　　利用迭代器的分类类型产生临时对象，并利用其进行重载，对不同的分类类型进行不同的适当处理.

a.迭代器分类为random_ierator_tag

 1 template <class RandomAccessItearator, class Size, class ForwardIterator>
 2 inline pair<RandomAccessIterator, ForwardIterator>
 3 __uninitialized_copy_n(RandomAccessIterator first, Size count,
 4         ForwardIterator result, random_ierator_tag)
 5 {
 6     // 对于random_iterator_tag类型的迭代器
 7     // 可以利用first和count计算出last迭代器
 8     // 然后利用uninitialized_copy(first, last, result)
 9     // 然而对于input_iterator_tag,就不能
10     RandomAccessIterator last = first _count;
11     return make_pair(last, uninitialized_copy(first, last, result));
12 }

b.迭代器分类为输入迭代器，前向迭代器和双向迭代器时

　　由于迭代器的分类标签类型的继承关系，

1 //五个作为标记用的型别(tag types)
2 struct input_iterator_tag { };
3 struct forward_iterator_tag : public input_iterator_tag { };
4 struct bidirectional_iterator_tag : public forward_iterator_tag { };
5 struct random_access_iterator_tag : public bidirectional_iterator_tag { };

后面三种迭代器类型，都会进行隐式类型转换，转换为input_ierator_tag。

 1 // input_iterator_tag 是迭代器的分类中的一种，利用迭代器分类类型的不同
 2 // 可以进行重载，不同的迭代器的类型，会针对其有特定的最优实现
 3 template <class InputItearator, class Size, class ForwardIterator>
 4 pair<InputIterator, ForwardIterator>
 5 __uninitialized_copy_n(InputIterator first, Size count,
 6         ForwardIterator result, input_ierator_tag)
 7 {
 8     // 对于input_iterator_tag类型的迭代器，只能逐个调用构造
 9     ForwardIterator cur = result;
10     __STL_TRY
11     {
12         for (; count > 0; --count, ++first, ++cur)
13             construct(&*cur, *first);
14         return pair<InputIterator, ForwardIterator>(first, cur);
15     }
16     // commit or rollback
17     __STL_UNWIND(destroy(result, cur));
18 }

 

3.uninitialized_fill函数

　　uninitialized_fill()也能够使我们将内存配置与对象的建构行为分离开。如果[first, last)范围内每个迭代器都指向未初始化的内存，那么uninitialized_fill()会在该范围内产生x的复制品。全部初始化为x。与uninitialized_copy()不同，uninitialized_copy()是以一段迭代器标记的区块内的元素去初始化自己的未初始化元素。这里是全部初始化为同一个指定的值x。下面是uninitialized_fill()函数的实现体系：

图2：uninitialized_fill()函数的实现体系

　　下面，先是uninitialized_fill函数对外的接口的实现：

1 // uninitialized_fill()对外接口
2 template <class ForwardIterator, class T>
3 inline void uninitialized_fill(ForwardIterator first, ForwardIterator last,
4         const T& x)
5 {
6     __uninitialized_fill(first, last, x, value_type(first));
7 }

　　在这里uninitialized_fill()----->__uninitialized_fill()的调用还是为了利用编译器的类型推导功能，获取迭代器指向对象的类型。

 1 // 内部的第二层，用于提取迭代器指向的类型是否是POD类型
 2 // 并利用其进行重载
 3 template <class ForwardIterator, class T, class T1>
 4 inline void __uninitialized_fill(ForwardIterator first,
 5         ForwardIterator last, const T& x, T1*)
 6 {
 7     // 利用__type_traits来萃取is_POD_type定义的类型
 8     // 并利用其调用更底层的重载实现
 9     typedef typename __type_traits<T1>::is_POD_type is_POD;
10     __uninitialized_fill_aux(first, last, x, is_POD());
11 }

　　在__uninitialized_fill()中,我们依旧是利用类型属性萃取类型，萃取了迭代器指向对象类型的属性，获取其is_POD类型的定义，并利用其定义产生临时对象，进行重载，对于不同的情况，进行不同的适当处理。

a.is_POD类型定义为__true_type

 1 // 如果是POD型别,那么copy construction 等同于 assignment,而且
 2 // destructor 是trivial,以下就有效
 3 // 执行流程就会转进到以下函数。
 4 template <class ForwardIterator, class T>
 5 inline void 
 6 __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
 7         const T& x, __true_type)
 8 {
 9     // isPOD的类型定义为__true_type，表示是POD类型
10     fill(first, last, x); //调用STL算法fill()    
11 }

b.is_POD类型定义为__false_type

 1 template <class ForwardIterator, class T>
 2 void
 3 __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
 4         const T& x, __false_type)
 5 {
 6     // is_POD定义为__false_type表示不是POD类型，所以只能逐个构造
 7     ForwardIterator cur = first;
 8     __STL_TRY
 9     {
10         for (; cur != last; ++cur)
11             construct(&*cur, x);
12     }
13     // commit or rollback
14     __STL_UNWIND(destroy(first, cur));
15 }

 

4.uninitialized_fill_n函数

　　uninitialized_fill_n()也能够使我们将内存配置与对象的建构行为分离开。uninitialized_fill_n(ForwardIterator first,Size n,const T& x),这个函数接受一个前向迭代器，一个指定的初始化初值，和要初始化的个数。基本原理于uninitialized_copy_n一样。uninitialized_fill_n()实现的体系如下：

图3：uninitialized_fill_n()实现的体系

　　

　　源码如下：

 1 // uninitialized_fill_n的实现
 2 
 3 // 基本原理于uninitialized_copy_n一样
 4 
 5 template <class ForwardIterator, class Size, class T>
 6 inline ForwardIterator
 7 __uninitialized_fill_n_aux(ForwardIterator first, Size n,
 8         const T& x, __true_type)
 9 {
10     return fill_n(first, n, x);
11 }
12 
13 template <class ForwardIterator, class Size, class T>
14 ForwardIterator
15 __uninitialized_fill_n_aux(ForwardIterator first, Size n,
16         const T& x, __false_type)
17 {
18     ForwardIterator cur = first;
19     __STL_TRY
20     {
21         for (; n > 0; --n, ++cur)
22             construct(&*cur, x);
23         return cur;
24     }
25     __STL_UNWIND(destroy(first, cur));
26 }
27 
28 template <class ForwardIterator, class Size, class T, class T1>
29 inline ForwardIterator __uninitialized_fill_n(ForwardIterator first,
30         Size n, const T& x, T1*)
31 {
32     typedef typename __type_traits<T1>::is_POD_type is_POD;
33     return __uninitialized_fill_n_aux(first, n, x, is_POD());
34 }
35 
36 // uninitialized_fill_n对外接口
37 template <class ForwardIterator, class Size, class T>
38 inline ForwardIterator uninitialized_fill_n(ForwardIterator first,Size n,
39         const T& x)
40 {
41     return __uninitialized_fill_n(first, n, value_type(first));
42 }

 

5.__uninitialized_copy_copy、__uninitialized_fill_copy和__uninitialized_copy_fill函数

　　这几个函数比较简单，都是调用上面的函数就可以实现功能了，就不解释了。直接上源码：

 1 // 拷贝[first1, last1)到[result, result + (last1 - first1))
 2 // 同时拷贝[first2, last2)到
 3 // [result + (last1 - first1), result + (last1 - first1) + (last2 - first2)]
 4 
 5 template <class InputIterator1, class InputIterator2, class ForwardIterator>
 6 inline ForwardIterator
 7 __uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
 8         InputIterator2 first2, InputIterator last2, ForwardIterator result)
 9 {
10     ForwardIterator mid = uninitialized_copy(first1, last1, reuslt);
11     __STL_TRY
12     {
13         return uninitialized_copy(first2, last2, mid);
14     }
15     __STL_UNWIND(destroy(result, mid));
16 }
17 
18 
19 // 用x填充[result, mid),同时拷贝[first, last)到[mid, mid + (last - first))
20 template <class ForwardIterator, class T, class InputIterator>
21 inline ForwardIterator
22 __uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid,
23         const T& x, InputIterator first, InputIterator last)
24 {
25     uninitialized_fill(result, mid, x);
26     __STL_TRY
27     {
28         return uninitialized_copy(first, last, mid);
29     }
30     __STL_UNWIND(destroy(result, mid));
31 }
32 
33 
34 // 拷贝[first1, last1)到[first2, first2 + (last1 - first1))
35 // 并且用x填充[first2 + (last1 - first1), last2]
36 template <class InputIterator, class ForwardIterator, class T>
37 inline void
38 __uninitialized_copy_fill(InputIterator first1, InputIterator last1,
39         ForwardIterator first2, ForwardIterator last2,
40         const T& x)
41 {
42     ForwardIterator mid2 = uninitialized_copy(first1, last1, first2);
43     __STL_TRY
44     {
45         uninitialized_fill(mid2, last2, x);
46     }
47     __STL_UNWIND(destroy(first2, mid2));
48 }

 

三、完整源码stl_uninitialized_wjzh.h

  1 /*************************************************************************
  2     > File Name: stl_uninitialized_wjzh.h
  3     > Author: wjzh
  4     > Mail: [email protected] 
  5     > Created Time: 2014年11月04日 星期二 17时09分15秒
  6  ************************************************************************/
  7 
  8 // 该文件中提供五个全局函数，作用于未初始化空间上 
  9 
 10 #ifndef __SGI_STL_INTERNAL_UNINITIALIZED_WJZH_H
 11 #define __SGI_STL_INTERNAL_UNINITIALIZED_WJZH_H
 12 
 13 __STL_BEGIN_NAMESPACE
 14 
 15 // uninitialized_copy的实现
 16 
 17 // 如果是POD型别，那么copy construction 等同于 assignment，而且
 18 // destruction 是trivial,以下就有效
 19 // 执行流程就会转进到以下函数。
 20 // POD  意指Plain Old Data,指标量型别或者是传统的C Struct型别
 21 // POD型别必须拥有trivial ctor/dtor/copy/assignment函数
 22 // 这是藉由function template的参数推导机制而得
 23 template <class InputIterator, class ForwardIterator>
 24 inline ForwardIterator
 25 __uninitialized_copy_aux(InputIterator first, InputIterator last,
 26                         ForwardIterator result,
 27                         __true_type)
 28 {
 29     //这里的_true_type 代表迭代器指向的类型是POD型别，不用构造，可以
 30     //直接拷贝
 31     return copy(first, last, result);
 32 }
 33 
 34 template <class InputIterator, class ForwardIterator>
 35 ForwardIerator
 36 __uninitialized_copy_aux(InputIterator first, InputIterator last,
 37                         ForwardIterator result,
 38                         __false_type)
 39 {
 40     //这里的_false_type 代表迭代器指向的类型非POD型别，
 41     //不能直接拷贝，需要一个一个的调用其构造函数
 42     ForwardIterator cur = result;
 43     __STL_TRY
 44     {
 45         for (; first != last; ++first, ++cur)
 46             construct(&*cur, *first);
 47         return cur;
 48     }
 49     //commit or rollback
 50     __STL_UNWIND(destroy(result, cur));
 51 }
 52 
 53 
 54 // __uninitialized_copy-->__uninitilaized_copy_aux
 55 // 是为利用编译器的类型参数推导，判断是否是POD类型
 56 template <class InputIterator, class ForwardIterator, class T>
 57 inline ForwardIterator
 58 __uninitialized_copy(InputItearator first, InputIeratorlast,
 59         ForwardIterator result, T*)
 60 {
 61     // is_POD 是一种类型,或者是__true_type代表为真，__
 62     // false_type代表为否，假
 63     // 利用is_POD的不同定义，生成不同的临时对象，用其进行重载
 64     typedef typename __type_traits<T>::is_POD_type  is_POD;
 65     return __uninitialized_copy_aux(first, last, result, is_POD());
 66 }
 67 
 68 
 69 
 70 // uninitialized_copy 的函数模板
 71 // uninitialized_copy -> __uninitialized_copy
 72 // 利用编译器的类型推导，萃取处迭代器指向的类型
 73 // 以便最后通过类型萃取__type_traits机制获取迭代器指向类型的一些属性
 74 template <class InputIterator, class ForwardIterator>
 75 inline ForwardIterator
 76 uninitialized_copy(InputIterator first, InputIterator last,
 77         ForwardIterator result)
 78 {
 79     // value_type是个模板函数，萃取迭代器指向类型，用该类型生成临时对象，
 80     // 再利用类型推导
 81     return __uninitialized_copy(first, last, result, value_type(result));
 82 
 83 }
 84 
 85 // uninitialized_copy 对于char* 的特化版本
 86 inline char* uninitialized_cpoy(const char* first, const char* last,
 87         char* result)
 88 {
 89     //对于char *对其使用memmove效率最高
 90     memmove(result, first, last - first);
 91     return result + (last - first);
 92 }
 93 
 94 // unitialized_copy 对于 wchar_t* 的特化版本
 95 inline wchar_t* uninitialized_copy(const wchar_t* first,
 96         const wchar_t* last, wchar_t* result)
 97 {
 98     //同样对于wchar_t *对其使用memmove效率最高
 99     memmove(result, first, sizeof(wchar_t) * (last - first));
100     return result + (last - first);
101 }
102 
103 
104 
105 // uninitialized_copy_n 的实现
106 
107 // input_iterator_tag 是迭代器的分类中的一种，利用迭代器分类类型的不同
108 // 可以进行重载，不同的迭代器的类型，会针对其有特定的最优实现
109 template <class InputItearator, class Size, class ForwardIterator>
110 pair<InputIterator, ForwardIterator>
111 __uninitialized_copy_n(InputIterator first, Size count,
112         ForwardIterator result, input_ierator_tag)
113 {
114     // 对于input_iterator_tag类型的迭代器，只能逐个调用构造
115     ForwardIterator cur = result;
116     __STL_TRY
117     {
118         for (; count > 0; --count, ++first, ++cur)
119             construct(&*cur, *first);
120         return pair<InputIterator, ForwardIterator>(first, cur);
121     }
122     // commit or rollback
123     __STL_UNWIND(destroy(result, cur));
124 }
125 
126 template <class RandomAccessItearator, class Size, class ForwardIterator>
127 inline pair<RandomAccessIterator, ForwardIterator>
128 __uninitialized_copy_n(RandomAccessIterator first, Size count,
129         ForwardIterator result, random_ierator_tag)
130 {
131     // 对于random_iterator_tag类型的迭代器
132     // 可以利用first和count计算出last迭代器
133     // 然后利用uninitialized_copy(first, last, result)
134     // 然而对于input_iterator_tag,就不能
135     RandomAccessIterator last = first _count;
136     return make_pair(last, uninitialized_copy(first, last, result));
137 }
138 
139 template <class InputIterator, class Size, class ForwardIterator>
140 inline pair<InputIterator, ForwardIterator>
141 uninitialized_copy_n(InputIterator first, Size count,
142         ForwardIterator result)
143 {
144     // 利用模板函数iterator_category提取出first迭代器的分类型别
145     // 然后利用其型别进行重载，对于不同的型别进行不同的优化处理
146     return __uninitialized_copy_n(first, count, result,
147             iterator_category(first));
148 }
149 
150 
151 
152 // uninitialized_fii 的实现
153 
154 // 如果是POD型别，那么copy construction 等同于 assignment,而且
155 // destructor 是trivial,以下就有效
156 // 执行流程就会转进到以下函数。
157 template <class ForwardIterator, class T>
158 inline void 
159 __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
160         const T& x, __true_type)
161 {
162     // isPOD的类型定义为__true_type，表示是POD类型
163     fill(first, last, x); //调用STL算法fill()    
164 }
165 
166 template <class ForwardIterator, class T>
167 void
168 __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
169         const T& x, __false_type)
170 {
171     // is_POD定义为__false_type表示不是POD类型，所以只能逐个构造
172     ForwardIterator cur = first;
173     __STL_TRY
174     {
175         for (; cur != last; ++cur)
176             construct(&*cur, x);
177     }
178     // commit or rollback
179     __STL_UNWIND(destroy(first, cur));
180 }
181 
182 // 内部的第二层，用于提取迭代器指向的类型是否是POD类型
183 // 并利用其进行重载
184 template <class ForwardIterator, class T, class T1>
185 inline void __uninitialized_fill(ForwardIterator first,
186         ForwardIterator last, const T& x, T1*)
187 {
188     // 利用__type_traits来萃取is_POD_type定义的类型
189     // 并利用其调用更底层的重载实现
190     typedef typename __type_traits<T1>::is_POD_type is_POD;
191     __uninitialized_fill_aux(first, last, x, is_POD());
192 }
193 
194 // uninitialized_fill()对外接口
195 template <class ForwardIterator, class T>
196 inline void uninitialized_fill(ForwardIterator first, ForwardIterator last,
197         const T& x)
198 {
199     __uninitialized_fill(first, last, x, value_type(first));
200 }
201 
202 
203 // uninitialized_fill_n的实现
204 
205 // 基本原理于uninitialized_copy_n一样
206 
207 template <class ForwardIterator, class Size, class T>
208 inline ForwardIterator
209 __uninitialized_fill_n_aux(ForwardIterator first, Size n,
210         const T& x, __true_type)
211 {
212     return fill_n(first, n, x);
213 }
214 
215 template <class ForwardIterator, class Size, class T>
216 ForwardIterator
217 __uninitialized_fill_n_aux(ForwardIterator first, Size n,
218         const T& x, __false_type)
219 {
220     ForwardIterator cur = first;
221     __STL_TRY
222     {
223         for (; n > 0; --n, ++cur)
224             construct(&*cur, x);
225         return cur;
226     }
227     __STL_UNWIND(destroy(first, cur));
228 }
229 
230 template <class ForwardIterator, class Size, class T, class T1>
231 inline ForwardIterator __uninitialized_fill_n(ForwardIterator first,
232         Size n, const T& x, T1*)
233 {
234     typedef typename __type_traits<T1>::is_POD_type is_POD;
235     return __uninitialized_fill_n_aux(first, n, x, is_POD());
236 }
237 
238 // uninitialized_fill_n对外接口
239 template <class ForwardIterator, class Size, class T>
240 inline ForwardIterator uninitialized_fill_n(ForwardIterator first,Size n,
241         const T& x)
242 {
243     return __uninitialized_fill_n(first, n, value_type(first));
244 }
245 
246 
247 // 拷贝[first1, last1)到[result, result + (last1 - first1))
248 // 同时拷贝[first2, last2)到
249 // [result + (last1 - first1), result + (last1 - first1) + (last2 - first2)]
250 
251 template <class InputIterator1, class InputIterator2, class ForwardIterator>
252 inline ForwardIterator
253 __uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
254         InputIterator2 first2, InputIterator last2, ForwardIterator result)
255 {
256     ForwardIterator mid = uninitialized_copy(first1, last1, reuslt);
257     __STL_TRY
258     {
259         return uninitialized_copy(first2, last2, mid);
260     }
261     __STL_UNWIND(destroy(result, mid));
262 }
263 
264 
265 // 用x填充[result, mid),同时拷贝[first, last)到[mid, mid + (last - first))
266 template <class ForwardIterator, class T, class InputIterator>
267 inline ForwardIterator
268 __uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid,
269         const T& x, InputIterator first, InputIterator last)
270 {
271     uninitialized_fill(result, mid, x);
272     __STL_TRY
273     {
274         return uninitialized_copy(first, last, mid);
275     }
276     __STL_UNWIND(destroy(result, mid));
277 }
278 
279 
280 // 拷贝[first1, last1)到[first2, first2 + (last1 - first1))
281 // 并且用x填充[first2 + (last1 - first1), last2]
282 template <class InputIterator, class ForwardIterator, class T>
283 inline void
284 __uninitialized_copy_fill(InputIterator first1, InputIterator last1,
285         ForwardIterator first2, ForwardIterator last2,
286         const T& x)
287 {
288     ForwardIterator mid2 = uninitialized_copy(first1, last1, first2);
289     __STL_TRY
290     {
291         uninitialized_fill(mid2, last2, x);
292     }
293     __STL_UNWIND(destroy(first2, mid2));
294 }
295 
296 __STL_END_NAMESPACE
297 
298 #endif  /* __SGI_STL_INTERNAL_UNINITIALIZED_WJZH_H*/
299 
300 // End

View Code