1. 隱式實例化

在代碼中實際使用模板類構造對象或者調用模板函數時，編譯器會根據調用者傳給模板的實參進行模板類型推導然后對模板進行實例化，此過程中的實例化即是隱式實例化。

template<typename T>
T add(T t1, T2)
{
    return t1 + t2;
}
template<typename T>
class Dylan
{
public:
    T m_data;
};
int main()
{
    int ret = add(3,4);//隱式實例化，int add<int>(int t1, int t2);
    Dylan<double> dylan;//隱式實例化
}

2. 顯式實例化聲明與定義

extern template int add<int>(int t1, int t2);//顯式實例化聲明
extern template class Dylan<int>;            //顯式實例化聲明
template int add<int>(int t1, int t2);       //顯式實例化定義
template class Dylan<int>;                   //顯式實例化定義

當編譯器遇到顯式實例化聲明時，表示實例化定義在程序的其他地方（相對于當前cpp文件）即在其他某一個cpp文件中定義，因此不再按照模板進行類型推導去生成隱式實例化定義。

當編譯器遇到顯式實例化定義時，根據定義所提供的模板實參去實例化模板，生成針對該模板實參的實例化定義。

3. 顯式實例化的用途

模板類、函數通常定義在頭文件中，這些頭文件會被很多cpp文件包含，在這些cpp文件中會多次使用這些模板，比如下面的例子：

//template.hpp
template<typename T>
class Dylan
{
public:
    T m_data;
};
//test1.cpp
#include "template.hpp"
Dylan<int> t1;
Dylan<int> t2;
//test2.cpp
#include "template.hpp"
Dylan<int> t3;
Dylan<int> t4;

在test1.cpp/test2.cpp 中多次實例化了Dylan<int>類，按說編譯完后的可執行程序中會包含多份Dylan<T>的定義，然而實際上，整個程序中卻只有一份Dylan<T>的定義。這個處理是在編譯和鏈接過程中實現的，目前主流的實現模式有兩種：? ? ??

a. Borland模式

Borland模式通過在編譯器中加入與公共塊等效的代碼來解決模板實例化問題。在編譯時，每個文件獨立編譯，遇到模板或者模板的實例化都不加選擇地直接編譯。在鏈接的時候將所有目標文件中的模板定義和實例化都收集起來，根據需要只保留一個。這種方法實現簡單，但因為模板代碼被重復編譯，增加了編譯時間。在這種模式下，我們編寫代碼應該盡量讓模板的所有定義都放入頭文件中，以確保模板能夠被順利地實例化。要支持此模式，編譯器廠商必須更換支持此模式的鏈接器。

b. Cfront模式

AT&T編譯器支持此模式，每個文件編譯時，如果遇到模板定義和實例化都不直接編譯，而是將其存儲在模板存儲庫中（template repository）。模板存儲庫是一個自動維護的存儲模板實例的地方。在鏈接時，鏈接器再根據實際需要編譯出模板的實例化代碼。這種方法效率高，但實現復雜。在這種模式下，我們應該盡量將非內聯成員模板的定義分離到一個單獨的文件中，進行單獨編譯。

在一個鏈接器支持Borland模式的編譯目標（編譯后的可執行文件）上，g++使用Borland模式解決實例化問題。比如ELF（Linux/GNU), Mac OS X, Microsoft windows， 否則，g++不支持上述兩種模式。

如何避免Borland模式的缺點？

上面我們說g++實現的是Borland 模式，由于我們為每一份實例化生成代碼，這樣在大型程序中就有可能包含很多重復的實例化定義代碼，雖然鏈接階段，鏈接器會剔除這些重復的定義，但仍然會導致編譯過程中的目標文件（或者共享庫文件）過于龐大。這時候，我們就可以通過C++11的模板顯式實例化的方法解決。看下面的代碼：

// template.hpp
template<typename T>
class Dylan
{
public:
    Dylan(T t);
    T m_data;
};
// template.cpp
#include "template.hpp"
template<typename T>
Dylan<T>::Dylan(T t)
{
    m_data = t;
}
template class Dylan<int>; //模板實例化定義
// main.cpp
#include "template.hpp"
extern template class Dylan<int>; //模板實例化聲明，告訴編譯器，此實例化在其他文件中定義
                                  //不需要根據模板定義生成實例化代碼  
int main()
{
    Dylan<int> dylan(3);//OK, 使用在template.cpp中的定義
    Dylan<float> dylan1(3.0);//error, 引發未定義錯誤
}

? ?上面的代碼中，我們將模板類的具體定義放在template.cpp中，并且在template.cpp中通過顯式實例化定義語句具體化了Dylan<int>。在main.cpp中，我們通過顯式實例化聲明告訴編譯器，Dylan<int>將在其他文件中定義，不需要在本文件中根據template.hpp的類模板實例化Dylan<int>。

由于我們沒有針對Dylan<float>做顯式實例化的聲明和定義，因此Dylan<float> dylan(3.0)會根據template.hpp中的類模板定義進行隱式實例化，然而構造函數是在template.cpp文件中定義的，在template.hpp中找不到構造函數的定義，因而報錯。如果把構造函數的定義挪回template.hpp，那Dylan<float>就能通過編譯了。

Note：在編譯中，如果指定-fno-implicit-templates，編譯器就會禁止隱式實例化，從而只使用顯式實例化。

參考文獻：Template Instantiation (Using the GNU Compiler Collection (GCC))