1.簡介

         不論是對客戶端或對STL內部而言，copy() 都是一個常常被呼叫的函式。由於copy進行的是複製操作，而複製操作不外乎運用賦值運算子（assignment operator）或複製建構函式（copy constructor），但是某些元素的型別是trivial assignment operator，因此如果能使用記憶體直接進行復制（例如使用C標準函式memmove、memcpy），便能節約大量時間。為此，copy演算法用盡各種辦法，包括函式過載（function overloading）、型別特性（type traits）、偏特化（partial specialization）等程式設計技巧來加強效率。

         copy演算法可將輸入區間 [first, last ) 內的元素複製到輸出區間 [ result, result + ( last – first ) )內，並返回迭代器：result + (last – first ) 。copy對template引數所要求的條件非常寬鬆，輸入區間有InputIterator 構成，輸出由OutputIterator 構成。

         由上圖可知，copy演算法從以下方面強化複製效能：

1.      迭代器指標型別，一般分為物件指標和原生指標。原生指標可直接使用memmove方式進行拷貝。像memmove這裡的底層庫函式，在彙編層面上做了優化，複製速度極快，有興趣的童鞋請自行查閱相關資料；

2.      賦值運算子（assignment operator）型別，指標指向的物件，其賦值運算子可以分為trivial operator和non-trivial operator（trivial 和non-trivial 的概念請移步：stack overflow、CSDN），trivial 賦值運算子之間呼叫memmove，non-trivial的比較悲劇，只能挨個複製；

3.      迭代器型別，分為InputIterator、RandomAccessIterator。InputIterator型別的需要由迭代器來判斷複製結束，我們知道，判斷iter != contianer.end()需要呼叫operator!=過載函式，速度慢。RandomAccessIterator以距離是否相等來決定複製結束，速度較快。

2.設計與實現

本文介紹的演算法實現需要以下檔案：

1.    cghStl_algobase.h，本文的主角：演算法的原始碼，位於cghSTL/algorithms/

2.    cghUtil.h：包含copy演算法用到的memmove演算法，位於/cghUtil/

3.    cghSTL_type_traits.h，特性萃取機，可以判斷物件是否為trivial或non-trivial；

4.    cghSTL_iterator.h，迭代器的基類，共五種，所有迭代器都要繼承於這五種基類，繼承自不同基類的迭代器，擁有不同特性，在演算法實現中，效能也不一樣；

5.    test_algorithms_algobase_copy.cpp，測試檔案，位於cghSTL/test/；

6.    cghVector.h，自己實現的vector，用於測試copy演算法的容器，位於/sequence containers/cghVector/，想了解vector實現細節的同學請移步：STL簡單vector的實現

7.    cghDeque.h，自己實現的deque，用於測試copy演算法的容器，位於//cghDeque/，想了解vector實現細節的同學請移步：STL簡單deque的實現

為了增強程式碼的可讀性，我用region把各個演算法隔開，如下圖所示

         童鞋們可以藉助上圖和上上圖來理解copy是框架和流程，直接上程式碼吧，註釋已經說明了一切~

cghStl_algobase.h

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  檔案內容：equal、fill、fill_n、iter_sawp、max、min、
			 lexicographical_compare、mismatch、copy 演算法的實現
******************************************************************/


#ifndef _CGH_STL_ALGOBASE_
#define _CGH_STL_ALGOBASE_

#include "cghUtil.h"
#include "cghSTL_type_traits.h"
#include "cghSTL_iterator.h"

namespace CGH{
	#pragma region copy

#pragma region 第一層：copy 演算法入口

	/* copy 演算法唯一的對外介面（完全泛化版）*/
	template<class InputIterator, class OutputIterator>
	inline OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
	{
		return copy_dispatch<InputIterator, OutputIterator>()(first, last, result);
	}

	#pragma region copy的特化版（specialization）

	/* copy 演算法針對const char* 版本的特化版 */
	inline char* copy(const char* first, const char* last, char* result)
	{
		// 採用 memmove 的方式直接複製資料，cgh_memmove 函式位於 cghUtil.h 檔案
		cgh_memmove(result, first, last - first) ;
		return result + (last - first) ;
	}

	/* copy 演算法針對const wchar_t* 版本的特化版 */
	inline wchar_t* copy(const wchar_t* first, const wchar_t* last, wchar_t* result)
	{
		// 採用 memmove 的方式直接複製資料，cgh_memmove 函式位於 cghUtil.h 檔案
		cgh_memmove(result, first, sizeof(wchar_t) * (last - first)) ;
		return result + (last - first) ;
	}
	#pragma endregion

#pragma endregion

#pragma region 第二層：copy_dispatch
	template<class InputIterator, class OutputIterator>
	struct copy_dispatch{
		InputIterator operator()(InputIterator first, InputIterator last, OutputIterator result)
		{
			return _copy(first, last, result, CGH::iterator_category(first));
		}
	};

	#pragma region copy_dispatch 的偏特化版本

	/*
		在引數為原生指標的情況下，進一步探測指標指向的物件是否具有 trivial assignment operator
		assignment operator 對效率的影響不小
		1.如果指標指向的物件具有 non-trivial assignment operator，複製操作就必須通過 trivial assignment operator 進行
		2.如果指標指向的物件具有 trivial assignment operator，我們完全可以通過最快的記憶體拷貝（memmove進行）
	*/
	template<class T>
	struct copy_dispatch<T*, T*>{
		T* operator()(T* first, T* last, T* result)
		{
			// 通過特性萃取機（cghSTL_type_traits），獲得物件 assignment operator 型別
			typedef typename cghSTL_type_traits<T>::has_trivial_assignment_operator	t;
			return _copy_t(first, last, result, t());
		}
	};

	/*
		在引數為原生指標的情況下，進一步探測指標指向的物件是否具有 trivial assignment operator
		assignment operator 對效率的影響不小
		1.如果指標指向的物件具有 non-trivial assignment operator，複製操作就必須通過 trivial assignment operator 進行
		2.如果指標指向的物件具有 trivial assignment operator，我們完全可以通過最快的記憶體拷貝（memmove進行）
	*/
	template<class T>
	struct copy_dispatch<const T*, T*>{
		T* operator()(T* first, T* last, T* result)
		{
			// 通過特性萃取機（cghSTL_type_traits），獲得物件 assignment operator 型別
			typedef typename cghSTL_type_traits<T>::has_trivial_assignment_operator	t;
			return _copy_t(first, last, result, t());
		}
	};

	#pragma endregion

#pragma endregion

#pragma region 第三層
	template<class InputIterator, class OutputIterator>
	inline OutputIterator _copy(InputIterator first, InputIterator last, OutputIterator result, CGH::input_iterator_tag)
	{
		// 以迭代器是否到達末尾，決定迴圈結束，速度慢
		for (; first != last; ++result, ++first)
		{
			*result = *first ;
		}
		return result ;
	}

	template<class RandomAccessIterator, class OutputIterator>
	inline OutputIterator _copy(RandomAccessIterator first, RandomAccessIterator last, OutputIterator result, CGH::random_access_iterator_tag)
	{
		return _copy_d(first, last, result, distance_type(first)) ;
	}

	/* 如果物件擁有 non-trivial assignment operator 那麼直接進行記憶體拷貝 */
	template<class T>
	inline T* _copy_t(const T* first, const T* last, T* result, true_type)
	{
		cgh_memmove(result, first, sizeof(T) * (last - first)) ;
		return result + (last - first) ;
	}

	/* 如果物件擁有 trivial assignment operator 那麼呼叫_copy_d，用自定義的 assignment operator，挨個物件拷貝 */
	template<class T>
	inline T* _copy_t(const T* first, const T* last, T* result, false_type)
	{
		return _copy_d(first, last, result, (ptrdiff_t*)0);
	}

	template<class RandomAccessIterator, class OutputIterator, class Distance>
	inline OutputIterator _copy_d(RandomAccessIterator first, RandomAccessIterator last, OutputIterator result, Distance*)
	{
		// 以 n 決定迴圈次數，速度比用迭代器決定迴圈次數更高效
		for (Distance n = last - first; n > 0; --n, ++result, ++first)
		{
			*result = *first ;
		}
		return result ;
	}
#pragma endregion

	#pragma endregion
}

#endif

3.測試

Copy演算法的測試工作量不小，要從一下方面入手：

1.      原生指標的測試；

2.      trivial和non-trivial 賦值運算子的測試；

3.      InputIterator、RandomAccessIterator迭代器；

測試環節的主要內容已在註釋中說明

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  檔案內容：cghStl_algobase.h 中的copy的測試
******************************************************************/

#include "stdafx.h"
#include "cghVector.h"
#include "_cghList.h"
#include "cghDeque.h"
#include "cghStl_algobase.h"

class C
{
public:
	C() :_data(0){}
	C(int n) :_data(n){}

	int _data;
};

int _tmain(int argc, _TCHAR* argv[])
{
	using namespace::CGH;

	std::cout << "********************** 測試 copy 針對const char* 的特化版 *********************" << std::endl << std::endl;
	std::cout << "呼叫的版本：copy ( const char* )" << std::endl;
	const char srcChar[5] = {'a', 'b', 'c', 'd', 'e'};
	char destChar[5];
	CGH::copy(srcChar, srcChar + 5, destChar);
	for (int i = 0; i < 5; ++i)
	{
		std::cout << "srcChar[" << i << "] = " << srcChar[i] << "\t\t" << "destChar[" << i << "] = " << destChar[i] << std::endl ;
	}
	std::cout << std::endl;

	std::cout << "********************* 測試 copy 針對const wchar_t* 的特化版 ********************" << std::endl;
	std::cout << "呼叫的版本：copy ( const wchar_t* )" << std::endl;
	const wchar_t srcWchar[5] = {'a', 'b', 'c', 'd', 'e'};
	wchar_t destWchar[5];
	CGH::copy(srcWchar, srcWchar + 5, destWchar);
	for (int i = 0; i < 5; ++i)
	{
		std::cout << "srcWchar[" << i << "] = " << srcWchar[i] << "\t\t" << "destWchar[" << i << "] = " << destWchar[i] << std::endl ;
	}
	std::cout << std::endl;

	std::cout << "********************* 測試 int[] ***********************************************" << std::endl;
	std::cout << "依次呼叫：copy() --> copy_dispatch() --> _copy( input_iterator )" << std::endl;
	int arrSrc[5] = {0, 1, 2, 3, 4};
	int arrDest[5];
	CGH::copy(arrSrc, arrSrc + 5, arrDest);
	for (int i = 0; i < 5; ++i)
	{
		std::cout << "arrSrc[" << i << "] = " << arrSrc[i] << "\t\t" << "arrDest[" << i << "] = " << arrDest[i] << std::endl;
	}
	std::cout << std::endl;

	std::cout << "********************* 測試 deque<C> （C為自定義的類）***************************" << std::endl;
	std::cout << "依次呼叫：copy() --> copy_dispatch() --> _copy( random_access_iterator_tag )\n\t\t\t\t\t\t\t  --> _copy_d()" << std::endl;
	C cDequeElem[5];
	cghDeque<C> cSrcDeq;
	cDequeElem[0]._data = 100;
	cDequeElem[1]._data = 101;
	cDequeElem[2]._data = 102;
	cDequeElem[3]._data = 103;
	cDequeElem[4]._data = 104;
	cSrcDeq.push_back(cDequeElem[0]);
	cSrcDeq.push_back(cDequeElem[1]);
	cSrcDeq.push_back(cDequeElem[2]);
	cSrcDeq.push_back(cDequeElem[3]);
	cSrcDeq.push_back(cDequeElem[4]);
	cghDeque<C> cDestDeq(5, cDequeElem[0]);
	copy(cSrcDeq.begin(), cSrcDeq.end(), cDestDeq.begin());
	int m_cDeq = 0;
	for (cghDeque<C>::iterator it = cDestDeq.begin(); it != cDestDeq.end(); ++it)
	{
		std::cout << "cSrcDeq[" << m_cDeq << "] = " << it->_data << "\t\t" << "cSrcDeq[" << m_cDeq << "] = " << it->_data << std::endl;
		m_cDeq++;
	}
	std::cout << std::endl;

	std::cout << "********************* 測試 vector<int> *****************************************" << std::endl;
	std::cout << "依次呼叫：copy() --> copy_dispatch( T*, T* ) --> _copy( true_type )" << std::endl;
	cghVector<int> vecIntSrc;
	vecIntSrc.push_back(1);
	vecIntSrc.push_back(2);
	vecIntSrc.push_back(3);
	vecIntSrc.push_back(4);
	vecIntSrc.push_back(5);
	cghVector<int> vecIntDest(5);
	CGH::copy(vecIntSrc.begin(), vecIntSrc.end(), vecIntDest.begin());
	for (int i = 0; i < 5; ++i)
	{
		std::cout << "vecIntSrc[" << i << "] = " << vecIntSrc[i] << "\t\t" << "vecIntDest[" << i << "] = " << vecIntDest[i] << std::endl;
	}
	std::cout << std::endl;

	std::cout << "********************* 測試 vector<C> （C為自定義的類）**************************" << std::endl;
	std::cout << "依次呼叫：copy() --> copy_dispatch( T*, T* ) --> _copy_t( false_type )\n\t\t\t\t\t\t\t  --> _copy_d()" << std::endl;
	C cVecSrcElem[5];
	cVecSrcElem[0]._data = 0;
	cVecSrcElem[1]._data = 1;
	cVecSrcElem[2]._data = 2;
	cVecSrcElem[3]._data = 3;
	cVecSrcElem[4]._data = 4;
	cghVector<C> cVecSrc;
	cVecSrc.push_back(cVecSrcElem[0]);
	cVecSrc.push_back(cVecSrcElem[1]);
	cVecSrc.push_back(cVecSrcElem[2]);
	cVecSrc.push_back(cVecSrcElem[3]);
	cVecSrc.push_back(cVecSrcElem[4]);
	cghVector<C> cVecDest(5);
	copy(cVecSrc.begin(), cVecSrc.end(), cVecDest.begin());
	int m_cVec = 0;
	for (cghVector<C>::iterator it = cVecDest.begin(); it != cVecDest.end(); ++it)
	{
		std::cout << "cVecSrc[" << m_cVec << "] = " << it->_data << "\t\t" << "cVecDest[" << m_cVec << "] = " << it->_data << std::endl;
		m_cVec++;
	}
	std::cout << std::endl;

	system("pause");
	return 0;
}

結果如下圖所示：