• copy复制操作，其操作通过使用assignment operator 。针对使用trivial assignment operator的元素型别可以直接使用内存直接复制行为(使用C函数 memove或者memcpy)节约时间。
• 还可以通过函数重载(function overloading)、型别特性(type traits)、偏特化(partial specialization)等技巧进一步强化效率。

• copy函数将[first,last) 内的元素复制到区间[result,result+(last-first))内
• 返回迭代器指向的是  result+(last-first)
• 输入区间使用 InputIterator，输出区间使用 OutputIterator
• 注意事项：1，result位于[first , last)之内的时候也就是输出区间的起头与输入区间重叠，不能使用copy；如果输出区间的尾端和输入区间重叠，就可以使用

• 上述第二种情况可能出现错误，是可能。如果输出区间的起点位于输入区间内部，copy算法可能会在输入区间的(某些)元素尚未复制之前就将其覆盖其值，导致错误
• 如果copy算法根据其所接收的迭代器特性 决定使用memmove()来执行任务，就不会出现问题，因为memmove 会将整个输入区间的内容复制下来就不会出现覆盖的危险

#include <iostream>   //std::cout
#include <algorithm>  //std::fill
#include <vector>     //std::vector
#include <deque>template <class T>
struct display{void operator()(const T& value){std::cout << value <<' ';}
};int main(){{int ia[] = {0,1,2,3,4,5,6,7,8};//输出区间的终点和输入区间出现重叠 没有问题std::copy(ia+2,ia+7,ia);std::for_each(ia,ia+9,display<int>()); //2 3 4 5 6 5 6 7 8std::cout << std::endl;}{int ia[] = {0,1,2,3,4,5,6,7,8};//输出区间的起点和输入区间出现重叠 可能会出现问题std::copy(ia+2,ia+7,ia+4);std::for_each(ia,ia+9,display<int>()); //0 1 2 3 2 3 4 5 6std::cout << std::endl;//本例结果正确 因为调用的copy算法使用memmove()执行实际复制操作}{int ia[] = {0,1,2,3,4,5,6,7,8};std::deque<int>id(ia,ia+9);std::deque<int>::iterator first = id.begin();std::deque<int>::iterator last = id.end();++++first;  //advance(first,2)  2std::cout << * first << std::endl;----last;  //advance(last,-2) 7std::cout << * last << std::endl;std::deque<int>::iterator result = id.begin();std::cout << *result << std::endl; //0//输出区间的终点和输入区间重叠 没有问题std::copy(first,last,result);std::for_each(id.begin(),id.end(),display<int>()); //2 3 4 5 6 5 6 7 8std::cout << std::endl;}{int ia[] = {0,1,2,3,4,5,6,7,8};std::deque<int>id(ia,ia+9);std::deque<int>::iterator first = id.begin();std::deque<int>::iterator last = id.end();++++first;  //advance(first,2)  2std::cout << * first << std::endl;----last;  //advance(last,-2)std::cout << * last << std::endl;std::deque<int>::iterator result = id.begin();std::advance(result,4);std::cout << *result << std::endl; //4//输出区间的起点和输入区间重叠 可能会出现问题std::copy(first,last,result);std::for_each(id.begin(),id.end(),display<int>()); //0 1 2 3 2 3 4 5 6//STL源码剖析 此处会出现错误，原因在于copy算法不再使用memcove()执行实际的复制操作//但是实际没有出现错误std::cout << std::endl;/*2 3 4 5 6 5 6 7 8 0 1 2 3 2 3 4 5 6 2702 3 4 5 6 5 6 7 8 2740 1 2 3 2 3 4 5 6 */}}

• 使用vector代替上述的deque进行测试复制结果是正确的，因为vector的迭代器其实就是个原生指针
• copy更改的是迭代器所指向的对象，并不是修改迭代器本身，他会为区间内的元素赋予新的数值，但不是产生新的元素，也不会改变迭代器的个数。即，copy不能用来将元素插入到空的容器中
• 使用copy算法配合序列容器的insert_iterator 

 

#include <iostream>   //std::cout//完全泛化的版本
template <class InputIterator,class OutputIterator>
inline OutputIterator copy(InputIterator first,InputIterator last,OutputIterator result){return __copy_dispatch<InputIterator ,OutputIterator>()(first,last,result);
}//两个重载函数 针对原生指针(视为一种特殊的迭代器)const char* 和 const wchar_t 进行内存的直接拷贝操作
//特殊版本1 重载形式 const char *
inline char* copy(const char* first,const char* last,char* result){std::memmove(result,first,last - first);return result + (last - first);
}//特殊版本2 重载形式 const wchar_t *
inline wchar_t* copy(const wchar_t* first,const wchar_t* last,wchar_t* result){std::memmove(result,first,sizeof(wchar_t)*(last - first));return result + (last - first);
}//copy泛化版本调用了一个 __copy_dispatch函数，这个函数有一个完全泛化版本和两个偏特化版本
//完全泛化版本
//__copy_dispatch完全泛化版本根据迭代器的种类不同，调用了不同的__copy()，是因为不同种类的迭代器使用的循环条件不同，有快有慢
template <class InputIterator,class OutputIterator>
struct __copy_dispatch{OutputIterator operator()(InputIterator first,InputIterator last,OutputIterator result){return __copy(first,last,result,iterator_category(first));}
};//InputIterator 版本
template <class InputIterator,class OutputIterator>
inline OutputIterator __copy(InputIterator first,InputIterator last,OutputIterator result,std::input_iterator_tag){//通过迭代器的等同与否 决定循环是否继续  速度很慢while(first!=last){*result = *first; //assignment operator++first;++result;}return result;
}//RandomAccessIterator 版本
template <class RandomAccessIterator,class OutputIterator>
inline OutputIterator __copy(RandomAccessIterator first,RandomAccessIterator last,OutputIterator result,std::random_access_iterator_tag){//划分新的函数 为了让其余地方可以使用return __copy_d(first,last,result, distance_type(first));
}template <class RandomAccessIterator,class OutputIterator,class Distance>
inline OutputIterator __copy_d(RandomAccessIterator first,RandomAccessIterator last,OutputIterator result,Distance*){//使用n决定循环的执行次数 速度快Distance n = last - first;while (n>0){*result = *first; //assignment operator++result;++first;n--;}return result;
}//偏特化版本1 两个参数的型别都是T* 指针
template<class T>
struct __copy_dispatch<T*,T*>
{T* operator()(T* first,T* last,T* result){typedef typename __type_traits<T>::has_trival_assignment_operator t;return __copy_t(first,last,result,t());}
};//偏特化版本2 第一个参数是constT*指针形式 第二个参数是T* 指针形式
template<class T>
struct __copy_dispatch<const T*,T*>
{T* operator()(const T* first,const T* last,T* result){typedef typename __type_traits<T>::has_trival_assignment_operator t;return __copy_t(first,last,result,t());}
};//在上述偏特化版本指定参数类型为T*和const T*只针的前提下进一步探测 
//探测指针所指之物是否具备trivial assignment operator （平凡赋值操作符）
//SGI STL通过使用__type_traits<>编程技巧 和 增加一层间接性 来区分不同的 __copy_t()//适用于指针所指对象具备 trivial assignment operator 
template <class 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 <class T>
inline T* __copy_t(const T* first,const T* last,T* result,__false_type){//原生指针是一种 RandomAccessIterator 所以交给 __copy_d()完成return __copy_d(first,last,result,(std::ptrdiff_t)0);
}