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