4、uninitialized_fill_n
G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_uninitialized.h 完整列表
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
/* NOTE: This is an internal header file, included by other STL headers.
* You should not attempt to use it directly.
*/
#ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
#define __SGI_STL_INTERNAL_UNINITIALIZED_H
__STL_BEGIN_NAMESPACE
// Valid if copy construction is equivalent to assignment, and if the
// destructor is trivial.
template
inline ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result,
__true_type) {//_true_type说明是POD类型
return copy(first, last, result);//调用STL算法copy()
}
template
ForwardIterator
__uninitialized_copy_aux(InputIterator first, InputIterator last,
ForwardIterator result,
__false_type) {//_false_type说明是non-POD类型,要一个一个的构建,无法批量进行
ForwardIterator cur = result;
__STL_TRY {
for ( ; first != last; ++first, ++cur)//一个一个的构建
construct(&*cur, *first);
return cur;
}
__STL_UNWIND(destroy(result, cur));
}
template
inline ForwardIterator
__uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result, T*) {
typedef typename __type_traits::is_POD_type is_POD;//用来判断是不是POD类型
return __uninitialized_copy_aux(first, last, result, is_POD());
}
/*
调用copy constructor,复制[first, last)范围内每一个对象,放到目的地[result, result+(last-first) )。
对于char*和wchar_t*提供特殊版本,获得更好效率
具有像数据库事物特性的commit和rollback特性,要么构造出所有必要元素,要么不够造任何东西。
copy() for(; first!=last) construct()
| |
| _true_type | _false_type
<__特化____________特化__>
|
_uninitialized_copy()
|
|泛化
|
uninitialized _____|_____特化___>(const char*, const char*,char*) memmove()
_copy() |
|
|____特化___>(const wchar_t*, const wchar_t*, wchar_t*) memmove()
*/
template
inline ForwardIterator
uninitialized_copy(InputIterator first, InputIterator last,
ForwardIterator result) {
return __uninitialized_copy(first, last, result, value_type(result));
}
//char*版本
inline char* uninitialized_copy(const char* first, const char* last,
char* result) {
memmove(result, first, last - first);
return result + (last - first);
}
//wchar_t*版本
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);
}
//input_iterator_tag只读迭代器类型
template
pair
__uninitialized_copy_n(InputIterator first, Size count,
ForwardIterator result,
input_iterator_tag) {
ForwardIterator cur = result;
__STL_TRY {
for ( ; count > 0 ; --count, ++first, ++cur)
construct(&*cur, *first);
return pair(first, cur);
}
__STL_UNWIND(destroy(result, cur));
}
//RandomAccessIterator迭代器类型
template
inline pair
__uninitialized_copy_n(RandomAccessIterator first, Size count,
ForwardIterator result,
random_access_iterator_tag) {
RandomAccessIterator last = first + count;
return make_pair(last, uninitialized_copy(first, last, result));
}
//用[result, result+count)初始化[first, first+cout)
/*
这个根据迭代器类型跳转
_____input_iterator_tag,调用construct(……)
|
|
uninitialized_copy_n----> iterator_category(first)?判断迭代器类型
|
|_____random_access_iterator_tag,调用uninitialized_copy(……)
*/
template
inline pair
uninitialized_copy_n(InputIterator first, Size count,
ForwardIterator result) {
return __uninitialized_copy_n(first, count, result,
iterator_category(first));//判断迭代器类型
}
// Valid if copy construction is equivalent to assignment, and if the
// destructor is trivial.
//如果复制构造函数和赋值操作符效果相同,且析构函数时trivial的
template
inline void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, __true_type)//POD类型
{
fill(first, last, x);
}
template
void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
const T& x, __false_type)//non-POD类型
{
ForwardIterator cur = first;
__STL_TRY {
for ( ; cur != last; ++cur)//一个一个构建
construct(&*cur, x);
}
__STL_UNWIND(destroy(first, cur));
}
template
inline void __uninitialized_fill(ForwardIterator first, ForwardIterator last,
const T& x, T1*) {
typedef typename __type_traits::is_POD_type is_POD;
__uninitialized_fill_aux(first, last, x, is_POD());
}
/*
用x初始化空间[first, last)
___> construct(……)
| __false_type
|
uninitialized_fill------> is POD?
| __true_type
|___> fill(……)
*/
template
inline void uninitialized_fill(ForwardIterator first, ForwardIterator last,
const T& x) {
__uninitialized_fill(first, last, x, value_type(first));//判断first是不是POD类型
}
// Valid if copy construction is equivalent to assignment, and if the
// destructor is trivial.
template
inline ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __true_type) {
return fill_n(first, n, x);
}
template
ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __false_type) {
ForwardIterator cur = first;
__STL_TRY {
for ( ; n > 0; --n, ++cur)
construct(&*cur, x);
return cur;
}
__STL_UNWIND(destroy(first, cur));
}
template
inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n,
const T& x, T1*) {
typedef typename __type_traits::is_POD_type is_POD;
return __uninitialized_fill_n_aux(first, n, x, is_POD());
}
/*
用x初始化[first, first+n)。也要判断是不是POD类型,看懂前面两个的话,这个自然就懂了,不再赘述。
*/
template
inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n,
const T& x) {
return __uninitialized_fill_n(first, n, x, value_type(first));
}
// Copies [first1, last1) into [result, result + (last1 - first1)), and
// copies [first2, last2) into
// [result, result + (last1 - first1) + (last2 - first2)).
template
inline ForwardIterator
__uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
ForwardIterator result) {
ForwardIterator mid = uninitialized_copy(first1, last1, result);
__STL_TRY {
return uninitialized_copy(first2, last2, mid);
}
__STL_UNWIND(destroy(result, mid));
}
// Fills [result, mid) with x, and copies [first, last) into
// [mid, mid + (last - first)).
template
inline ForwardIterator
__uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid,
const T& x,
InputIterator first, InputIterator last) {
uninitialized_fill(result, mid, x);
__STL_TRY {
return uninitialized_copy(first, last, mid);
}
__STL_UNWIND(destroy(result, mid));
}
// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
// fills [first2 + (last1 - first1), last2) with x.
template
inline void
__uninitialized_copy_fill(InputIterator first1, InputIterator last1,
ForwardIterator first2, ForwardIterator last2,
const T& x) {
ForwardIterator mid2 = uninitialized_copy(first1, last1, first2);
__STL_TRY {
uninitialized_fill(mid2, last2, x);
}
__STL_UNWIND(destroy(first2, mid2));
}
__STL_END_NAMESPACE
#endif /* __SGI_STL_INTERNAL_UNINITIALIZED_H */
// Local Variables:
// mode:C++
// End: