template<class 模板引數表>
class 類名｛
// 類定義．．．．．．
｝；

template<class type,int width>
//type為型別引數，width為非型別引數
class Graphics;

(4)、在不同的類模板或宣告中，模板引數名可以被重複使用。

(5)、在類模板的前向宣告和定義中，模板引數的名字可以不同。
(6)、類模板引數可以有預設實參，給引數提供預設實參的順序是先右後左。
(7)、類模板名可以被用作一個型別指示符。當一個類模板名被用作另一個模板定義中的型別指示符時，必須指定完整的實參表。

二、如何編寫一個類模板

類模板一般應用於容器類中，使得容器能夠處理各種型別的物件。下面的雙向連結串列，其節點只能存放整型資料型別的元素：

struct Node
{
	Node( int nData = 0 )
	{
		m_nData = nData;
		m_pPrev = m_pNext = NULL;
	}
	int m_nData;	// 資料元素
	Node* m_pPrev;	// 指向上一個元素的指標
	Node* m_pNext;	// 指向下一個元素的指標
};

class CDList
{
private:
	int m_nCount;
	Node* m_pHead;
	Node* m_pTail;
public:
	CDList();
	virtual ~CDList();
public:
	int length() const
	{
		return m_nCount;
	}
	Node* get_head() const
	{
		return m_pHead;
	}
	Node* get_tail() const
	{
		return m_pTail;
	}
public:
	void release();
	//增加
	Node* push_back( int nData )
	{
		Node* pNewNode = new Node(nData);

		if ( m_pTail )
			m_pTail->m_pNext = pNewNode;
		pNewNode->m_pPrev = m_pTail;

		if ( m_pTail == NULL )
			m_pHead = pNewNode;
		m_pTail = pNewNode;

		m_nCount++;
		return pNewNode;
	}
	Node* push_front( int nData );
	Node* operator[](int nIndex);
	//刪除
	bool erase( int nIndex );
	//查詢
	Node* find_node( int nIndex );
};
 

        如果要想讓此雙向連結串列能夠存放任何一種型別的元素，那必須將此類修改成類模板，其實把類改寫成類模板，並不是什麼難事，對照原來的類，一步一步改就行了！另外，這也是最不容易出錯的編碼方式。下面是實現雙向連結串列的C++程式碼：

#include <tchar.h>
#include <stdlib.h>
#include <iostream>
#include <assert.h>


template <typename T>
struct NodeT
{
	NodeT( T Data )
	{
		m_Data = Data;
		m_pPrev = m_pNext = NULL;
	}
	T m_Data;			// 通用型別的資料元素
	NodeT<T>* m_pPrev;	// 指向上一個元素的指標
	NodeT<T>* m_pNext;	// 指向下一個元素的指標
};

template <typename T>
class CDListT
{
private:
	int m_nCount;		// 連結串列中元素的數量
	NodeT<T>* m_pHead;	// 連結串列頭指標
	NodeT<T>* m_pTail;	// 連結串列尾指標
public:
	CDListT(): m_nCount(0), m_pHead(NULL), m_pTail(NULL){}

	template<typename T>  
	CDListT(const T &data) : m_nCount(0), m_pHead(NULL), m_pTail(NULL)
	{
		push_front(data);
	}

	virtual ~CDListT()
	{
		release();
	}
public:
	int length() const
	{
		return m_nCount;
	}
	NodeT<T>* get_head() const
	{
		return m_pHead;
	}
	NodeT<T>* get_tail() const
	{
		return m_pTail;
	}
public:
	//
	NodeT<T>* operator[](int nPos)
	{
		return find_node(nPos);
	}
	//
	bool empty() const { return ( !m_pHead || !m_pTail ); }
	//
	void release()
	{
		while(m_pHead)
		{
			NodeT<T>* temp(m_pHead);
			m_pHead = m_pHead->m_pNext;
			delete temp;
			m_nCount = 0;
		}
	}
	//從尾部增加
	NodeT<T>* push_back( T Data )
	{
		NodeT<T>* pNewNode = new NodeT<T>(Data);

		if ( m_pTail )
			m_pTail->m_pNext = pNewNode;
		pNewNode->m_pPrev = m_pTail;

		if ( m_pTail == NULL )
			m_pHead = pNewNode;
		m_pTail = pNewNode;

		m_nCount++;
		return pNewNode;
	}
	//從頭部增加
	NodeT<T>* push_front( T Data )
	{
		NodeT<T>* pNewNode = new NodeT<T>(Data);
		if ( m_pHead )
			m_pHead->m_pPrev = pNewNode;
		pNewNode->m_pNext = m_pHead;

		if (m_pHead == NULL)
			m_pTail = pNewNode;
		m_pHead = pNewNode;

		m_nCount++;
		return pNewNode;
	}

	//從尾部彈出
	template<typename T>
	T pop_back()
	{
		if( empty() )
			throw("CDListT : list is empty");

		NodeT<T>* temp(m_pTail);
		T data( m_pTail->m_Data );
		m_pTail = m_pTail->m_pPrev;
		if( m_pTail )
			m_pTail->m_pNext = NULL;
		else
			m_pHead = NULL;

		delete temp;
		m_nCount--;

		return data;
	}
	//從頭部彈出
	template<typename T>
	T pop_front()
	{
		if( empty() )
			throw("CDListT : list is empty");

		NodeT<T>* temp(m_pHead);
		T data( m_pHead->m_Data );
		m_pHead = m_pHead->m_pNext;
		if( m_pHead )
			m_pHead->m_pPrev = NULL;
		else
			m_pTail = NULL;

		delete temp;
		m_nCount--;

		return data;
	}

	//刪除
	bool erase( int nPos )
	{
		assert(1 <= nPos && nPos <= m_nCount);

		NodeT<T> *pTmpNode = m_pHead;
		// 是否為第一個節點
		if (1 == nPos)
		{
			m_pHead = m_pHead->m_pNext;
			if(m_pHead)
			{
				m_pHead->m_pPrev = NULL;
			}

			delete pTmpNode;
			--m_nCount;
			if (0 == m_nCount)
			{
				m_pTail = NULL;
			}

			return true;
		}

		//如果不是...  
		for (int i = 1; i < nPos; ++i)
		{
			pTmpNode = pTmpNode->m_pNext;
		}
		pTmpNode->m_pPrev->m_pNext = pTmpNode->m_pNext;
		
		//是否為最後一個節點
		if(pTmpNode->m_pNext)
		{
			pTmpNode->m_pNext->m_pPrev = pTmpNode->m_pPrev;
		}
		else
		{
			m_pTail = pTmpNode->m_pPrev;
		}

		delete pTmpNode;
		--m_nCount;
		if (0 == m_nCount)
		{
			m_pTail = NULL;
		}
		return true;
	}

	//查詢
	template <typename T>
	NodeT<T>* find_node( int pos )
	{
		assert(1 <= pos && pos <= m_nCount);

		NodeT<T>* pTmp = m_pHead;
		for (int i=1; i < pos; ++i)
		{
			pTmp = pTmp->m_pNext;
		}
		return pTmp;
	}
};


int _tmain(int argc, _TCHAR* argv[])
{
	CDListT<int> _list; // 將CDListT例項化為一個int型別，即連結串列中資料元素為整型
	_list.push_back(12);
	_list.push_back(23);
	_list.push_back(34);
	_list.push_back(45);
	_list.push_back(56);
	_list.push_back(67);
	_list.push_front(78);

	//12
	NodeT<int> *_node = _list.find_node<int>(2);
	std::cout << _node->m_Data << "\r\n";

	//23
	_list.erase(3);

	//列印連結串列
	int nCount = _list.length();
	while( nCount > 0)
	{
		std::cout << _list.pop_back<int>()  << ", ";
		nCount--;
	}

	system("pause");
	return 0;
}
 

12

67, 56, 45, 34, 12, 78

        C++支援兩種模板程式碼的組織方式，分別是包含方式和分離方式。這兩種組織方式沒有太根本的區別，就是一個將程式碼全寫在標頭檔案中，分離方式是像寫類一樣宣告和定義分別寫在標頭檔案（.h檔案）和實現檔案（cpp檔案）中。

3.1、包含方式：

當然，將程式碼都寫在標頭檔案中還有一點點小要求：
1）、 如果模板的成員函式寫在類外，則需要寫成如下樣式：

template<typename T>// 每個類外成員函式前都要有這句
T CDListT<T>::pop_back()
{
	if( empty() )
		throw("CDListT : list empty");

	NodeT<T>* temp(m_pTail);
	T data( m_pTail->m_Data );
	m_pTail = m_pTail->m_pPrev;
	if( m_pTail )
		m_pTail->m_pNext = NULL;
	else
		m_pHead = NULL;

	delete temp;
	m_nCount--;

	return data;
}

3.2、分離方式

所謂的分離方式組織程式碼，就是將模板的宣告和定義分別寫在標頭檔案（.h檔案）和實現檔案（cpp檔案）中，需要注意的是，並不是所有的編譯器都支援這種寫法，目前我只知道GCC支援這種寫法。當然，分離方式組織程式碼也有個小要求，就是在模板的宣告和定義的template關鍵字前都加上export關鍵字。比如：
// .h 標頭檔案中

export template <typename T>
class CDListT
{
        //......
};

//.cpp實現檔案

export template<typename T>
T CDListT<T>::pop_back()
{
//......
}

       類模板不是真正的定義，它僅在編譯時根據例項化本模板時，傳遞的實參來生成具體的類程式碼！若類模板沒有被例項化也沒有被呼叫，那編譯器不會為本模板生成任何程式碼，也不對模板程式碼作任何語法檢查。

        因此，模板的過載、特化等多型性也都是在編譯期間體現出來的，如果我們對編譯生成的可執行檔案進行反彙編時，我們不會找到任何與模板有關的程式碼，因為模板只是編譯期間的產物。