标签：des style blog http io ar color os 使用
前面两篇已经编写了内存配置器和建构解构工具函数。这里，就准备编写并介绍下内存基本处理工具函数。比如uninitialized_copy()、uninitialized_copy和 uninitialized_copy_n()等的实现。
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()，源码如下：
// 如果是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); }
不是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 }
对于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 }
该函数调用接口为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 }
利用迭代器的分类类型产生临时对象，并利用其进行重载，对不同的分类类型进行不同的适当处理.
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 }
由于迭代器的分类标签类型的继承关系，
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 }
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类型的定义，并利用其定义产生临时对象，进行重载，对于不同的情况，进行不同的适当处理。
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 }
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 }
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 }
这几个函数比较简单，都是调用上面的函数就可以实现功能了，就不解释了。直接上源码：
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 }
1 /************************************************************************* 2 > File Name: stl_uninitialized_wjzh.h 3 > Author: wjzh 4 > Mail: wangjzh_1@163.com 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
自己动手实现STL 03：内存基本处理工具(stl_uninitialized.h)
标签：des style blog http io ar color os 使用
原文地址：http://www.cnblogs.com/wangjzh/p/4106740.html
