STL里面有一个重要的算法copy，进行的是复制操作，而在上篇文章中，已经提到了对于POD元素类型来说，是可以直接使用C语言中memmove或memcpy，能够大幅提高效率。对此，copy中用了函数重载，迭代器型别特性，模板偏特化等大量技巧来对此优化。
// 泛化版copy
template <typename InputIterator, typename InputIterator>
inline OutputIterator copy
(InputIterator first, InputIterator last, OutputIterator result)
{
returrn __copy_dispatch<InputIteratorm, OutputIterator>()(first, last, result);
}
// 对char* 的重载版本, 直接采用memove
inline char* copy(const char* first, const char* last, char *result)
{
memmove(result, first, last - first);
return result + (last - first);
}
// 对wchar_t* 的重载版本, 直接采用memove
inline wchar_t* copy(const w_char* first, const w_char* last, wchar_t result)
{
memmove(result, first, sizeof(wchar_t) * (last - first));
return result + (last - first);
}
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)char* copy(const char* first, const char* last, char *result)wchar_t* copy(const w_char* first, const w_char* last, wchar_t result)
利用函数重载，如果是char* 和 wchar_t* 则会直接采用memmove。
泛化版__copy_dispatch
// 泛化版__copy_dispatch(重载了函数调用运算符的类)
template <typename InputIterator, typename OutputIterator>
struct __copy_dispatch
{
OutputIterator operator()(InputIterator first, InputIterator last, OutputIterator result)
{
__copy(first, last, result, iterator_category(first));
}
};
// 偏特化
template <T>
struct __copy_dispatch<T*, T*>()
{
T* operator()(T* first, T* last, T* result)
{
typedef typename _type_traits<T>::has_trivial_assignment_operator t;
return __copy_t(first, last, result, t());
}
};
// 偏特化
template <T>
struct __copy_dispatch<const T*, T*>
{
T* operator()(const T* first, const T* last, T* result)
{
typedef typename _type_traits<T>::has_trivial_assignment_operator t;
return __copy_t(first, last, result, t());
}
};
__copy_dispatch()的完全泛化版本根据迭代器的种类不同，会调用不同的__copy()，
为的是不同种类的迭代器所使用的循环条件不同，有快慢之别。
下面讨论将分为2条线，一条是__copy，另一条是偏特化版本
// inputIterator 版本
template <typename InputIterator, typename OutputIterator>
inline OutputIterator __copy(InputIterator first, InputIterator last, OutputIterator result, input_iterator_tag) {
for (; first != last; ++result, ++first)
{
*result = *first;
}
return result;
}
// RandomAccessIterator版本
template <typename RandomAccessIterator, typename OutputIterator>
inline OutputIterator __copy(InputIterator first, InputIterator last, OutputIterator result, random_access_iterator_tag)
{
return __copy_d(first, last, result, distance_type(first));
}
// 这个只是为了复用，后面有块也会用到。
template <typename RandomAccessIterator, typename OutputIteator, typename Distance>
inline OutputIterator __copy_d(RandomAccessIterator first, RandomAccessIterator last, OutputIterator result, Distance*)
{
for (Distance n = last - first; n > 0; --n, ++result, ++first) {
*result = *first;
}
return result;
}
/************************************分割线******************************/
// 指针所指对象具备trivial assignment operator
template <typename T>
inline T* __copy_t(const T* first, const T* last, T* result, __true_type) {
memmove(result, first, sizeof(T)*(last - first));
return result + (last - first);
}
// 指针所指对象具备non trivial assignment operator
template <typename T>
inline T* __copy_t(const T* first, const T* last, T* result, __false_type) {
return __copy_d(first, last, result, (ptrdiff_t*)0);
}
以上就是copy原貌。可用一张图总结：
copy.jpg
