類模板的分離編譯

  一直以爲模板類是特別神奇的東西，它能夠構造出不一樣類型的對象，使代碼更加的靈活。這個過程就是類模板的實例化。

  咱們使用類的模板寫一個stack類：

#include<assert.h>
#include"Seqlist1.h"
using namespace std;
template<class T,template<class> class Container  = Seqlist>
class Stack
{
public:
	void Push(const T& x)
	{
		_con.Pushback(x);
	}
	void Pop()
	{
		_con.Popback();
	}
	bool Empty()
	{
		return Size() == 0;
	}
	size_t Size()
	{
		return _con.Size();
	}
	T& Top()
	{
		size_t size = Size();
		assert(size > 0);
		return _con[size - 1];
	}
	void print()
	{
		_con.Print();
	}
	T& operator[](size_t index)
	{
		return _con[index];
	}
protected:
	Container _con;
};

  其中咱們能夠傳入不一樣類型的T，class Continer是類型T的一個容器，這裏默認是用自定義的一個順序表來當容器。編譯器就會構造出不一樣的代碼出來。

  這樣的實現方式是在類內定義成員函數，並把整個類放在.h中，這種方式叫作類模板的包含模式。這樣的定義方式是有好處的，要使用Stack這個類，只要在頭文件內包含類體就能夠了，編譯器很容易就能夠找到類的定義。固然這種方式是有弊端的，若是一個類的成員函數個數不少而且很複雜，無疑在你去閱讀或者修改定義的時候會讓人很頭疼，不能快速找到成員函數的定義。

  還好C++提供了另一種方式——將成員函數的聲明放在類體內.h中，將函數的定義放在.cpp中，就至關與類外定義，咱們把這種方式叫作類模板的分離模式。這樣寫出來的代碼是很美觀的，而且易於修改。

//.h文件
#include<assert.h>
#include"Seqlist1.h"
using namespace std;
template<class T,template<class> class Container  = Seqlist>
class Stack
{
public:
	void Push(const T& x);
	void Pop();
	bool Empty();
	size_t Size();
	T& Top();
	void print();
	T& operator[](size_t index);
protected:
	Container _con;
};

//.cpp文件
//類外定義

template<class T,template<class> class Container  = Seqlist>
void Push(const T& x)
{
_con.Pushback(x);
}


template<class T,template<class> class Container  = Seqlist>
void Pop()
{
_con.Popback();
}

template<class T,template<class> class Container  = Seqlist>
bool Empty()
{
return Size() == 0;
}

template<class T,template<class> class Container  = Seqlist>
size_t Size()
{
return _con.Size();
}

template<class T,template<class> class Container  = Seqlist>
T& Top()
{
size_t size = Size();
assert(size > 0);
return _con[size - 1];
}

template<class T,template<class> class Container  = Seqlist>
void print()
{
_con.Print();
}

template<class T,template<class> class Container  = Seqlist>
T& operator[](size_t index)
{
return _con[index];
}

  類模板的分離模式就會牽扯出一些問題，好比說編譯器在構造對象的時候它怎麼找函數的定義的，由於函數的定義是在.cpp文件中的。這就是類模板的分離編譯問題。

  假設咱們stack類是放在stack.h中的，成員函數的定義放在stack.cpp中的，而後類的調用放在main.cpp中，而且在main.cpp中包含了stack.h。

 按照咱們一般的思路：

• 編譯main.cpp時，編譯器不知道f（f是成員函數中的任意一個函數）的實現，因此當碰到對它的調用時只是給出一個指示，指示鏈接器應該爲它尋找f的實現體。這也就是說main.obj中沒有關於f的任何一行二進制代碼。

• 編譯test.cpp時，編譯器找到了f的實現。因而乎f的實現（二進制代碼）出如今test.obj裏。 

• 鏈接時，鏈接器在test.obj中找到f的實現代碼（二進制）的地址（經過符號導出表）。而後將main.obj中懸而未決的call XXX地址改爲f實際的地址，pofect。

 

可是當你編譯的時候，編譯器就會報連接錯誤，找不到成員函數的定義。說明咱們的思路是錯誤的。對於模板，在沒有實例化出對象以前是不會被編譯成二進制代碼的，而實例化是在程序運行的時候（也就是用到模板的時候）才實例化出對象，實例化是在編譯器對代碼進行編譯的後面才發生的。這樣問題就迎刃而解了，咱們得手動的在main中包含.cpp文件，讓編譯器知道有函數的定義，這樣編譯器就不會報錯了。

這裏有必要提醒（總結）一下的是：

• 若是你的類不是用模板實現的，就不會有分離編譯的問題，也就是說，即便你的類的成員函數是在類外定義的也不用include .cpp文件，無論你用沒用到都會實例化出代碼出來，就會編譯成二進制文件，在連接時就會連接起來。

• 若是你的類是模板類，而且想要在類外定義成員函數，就必須include .cpp文件。