【C++ 函數模板】—— 模板參數推導、實例化策略與編譯優化

歡迎來到ZyyOvO的博客?，一個關于探索技術的角落，記錄學習的點滴📖，分享實用的技巧🛠?，偶爾還有一些奇思妙想💡
本文由ZyyOvO原創??，感謝支持??！請尊重原創📩！歡迎評論區留言交流🌟
個人主頁 👉 ZyyOvO
本文專欄??C++ 進階之路

在這里插入圖片描述

各位于晏，亦菲們請看

引言
函數模板的概念
函數模板的匹配原則
函數模板的底層原理
- 模板的編譯階段
- 模板實例化
- 編譯器與鏈接器的協作
編譯器的工作流程
- 前端編譯階段
- 模板實例化階段
- 后端編譯階段
函數模板總結
寫在最后

引言

點擊快速復習 👉：【C++ 函數重載】—— 現代編譯技術下的多態表達與性能優化

上篇文章我們講到C++的函數重載，包括函數重載的條件，原理以及一些易錯事項，那么本文我們為大家介紹C++中泛型編程的主要方式——模板。

在 C++ 中，模板（Template）是一種強大的編程特性，它允許程序員編寫與類型無關的代碼，實現代碼的復用和泛型編程。

在這里插入圖片描述

如同模具一樣，C++中的模板也是同樣的道理！

函數模板的概念

模板是 C++泛型編程的基礎，它提供了一種將類型參數化的機制。模板分為類模板和函數模板，通過模板，我們可以定義通用的類或函數，這些類或函數可以處理多種不同的數據類型，而不需要為每種數據類型都編寫一套單獨的代碼。這樣可以提高代碼的復用性和可維護性。

函數模板定義了一系列具有相似功能但可以處理不同數據類型的函數。通過使用模板，你無需為每種數據類型都編寫一個單獨的函數，而是可以定義一個通用的函數，讓編譯器根據實際使用的參數類型自動生成相應的具體函數。

定義

函數模板的定義通常包含模板聲明和函數定義兩部分。模板聲明使用template關鍵字，后跟一個或多個模板參數列表，函數定義則使用這些模板參數來實現通用的邏輯。

語法：

template <typename T,typename T2,...typename Tn>
返回類型 函數名(參數列表){// 函數體
}

template：這是定義模板的關鍵字，表明接下來要定義一個模板。
typename（也可以用 class）：用于聲明一個類型參數，它告訴編譯器 T 是一個代表任意類型的占位符。
T：類型參數的名稱，你可以根據需要自定義，但通常使用單個大寫字母，如 T、U 等。
返回類型：函數的返回類型，可以是模板參數 T 或其他類型。
參數列表：函數的參數列表，可以包含模板參數 T。

示例：

template<typename T>
void Swap( T& left, T& right)
{T temp = left;left = right;right = temp;
}

使用

隱式實例化

讓編譯器根據實參自動推演模板參數的實際類型

使用函數模板時，你可以像調用普通函數一樣調用它，編譯器會根據傳遞的實參類型自動推導模板參數的類型。

聲明一個模板：

template<class T>
T Add(const T& left, const T& right)
{return left + right;
}

使用模板：

int main()
{int a1 = 10, a2 = 20;double d1 = 10.0, d2 = 20.0;int intResult = Add(a1, a2);double doubleResult = Add(d1, d2);return 0;
}

Add(a1, a2);：調用 Add 函數模板，編譯器會根據傳入的參數 a1 和 a2 的類型（int）自動推導模板參數 T 為 int，然后實例化出一個處理 int 類型的 Add 函數。
Add(d1, d2);：同理，調用 Add 函數模板時，編譯器根據 d1 和 d2 的類型（double）推導模板參數 T 為 double，并實例化出一個處理 double 類型的 Add 函數。

下面這條語句不能通過編譯，因為在編譯期間，當編譯器看到該實例化時，需要推演其實參類型通過實參a1將T推演為int，通過實參d1將T推演為double類型，但模板參數列表中只有一個T，編譯器無法確定此處到底該將T確定為int
或者 double類型而報錯.

Add(a1, d1);

注意：在模板中，編譯器一般不會進行類型轉換操作，因為一旦轉化出問題，編譯器就需要背黑鍋，對于語句Add(a1, d1);

此時有兩種處理方式：

用戶自己來強制轉化

Add(a, (int)d);

使用顯式實例化

顯示實例化

模板的顯示實例化（Explicit Instantiation）是一種手動告訴編譯器生成特定模板實例代碼的機制.當你有函數模板時，編譯器通常會在代碼中第一次使用到特定模板實例時才生成對應的代碼，但有時候你可能希望提前顯式地讓編譯器生成特定類型的模板實例，這就需要用到顯式實例化。

還是之前那個例子：

template<class T>
T Add(const T& left, const T& right)
{return left + right;
}

使用顯示實例化

int main(void)
{int a = 10;double b = 20.0;// 顯式實例化Add<int>(a, b);return 0;
}

在這個例子中，Add<int>(a, b);這行代碼顯式地告訴編譯器生成 Add 函數模板針對 int 類型的實例代碼。
如果類型不匹配，編譯器會嘗試進行隱式類型轉換，如果無法轉換成功編譯器將會報錯。
此時編譯器會將double類型的b轉換為int類型來完成函數調用！

函數模板的匹配原則

函數模板的匹配原則是 C++ 中重載決議的核心規則之一，決定了編譯器在多個候選函數（包括模板和非模板函數）中選擇最合適版本的優先級順序。

非模板函數優先

如果存在非模板函數與調用參數完全匹配（無需隱式轉換），則優先選擇非模板函數，而非實例化模板。

#include <iostream>
// 模板函數
template <typename T>
void print(T a) {std::cout << "Template: " << a << std::endl;
}// 非模板函數（參數類型為 int）
void print(int a) {std::cout << "Non-template: " << a << std::endl;
}int main() {print(42);    // 調用非模板函數（精確匹配）print(3.14);  // 調用模板函數（生成 print<double>）
}

輸出：

Non-template: 42
Template: 3.14

更特化的的模板函數優先

當多個模板都能匹配時，編譯器選擇參數范圍更狹窄（更特化）的模板。

#include <iostream>// 通用模板
template <typename T>
void show(T a) {std::cout << "Generic: " << a << std::endl;
}// 更特化的模板（針對指針）
template <typename T>
void show(T* a) {std::cout << "Specialized (pointer): " << *a << std::endl;
}int main() {int x = 10;show(x);    // 調用通用模板（T=int）show(&x);   // 調用指針特化版本（T=int）
}

通用模板 T 可以匹配任何類型。
指針特化模板 T* 只能匹配指針類型，因此更特化。

輸出：

Generic: 10
Specialized (pointer): 10

精確匹配優先于隱式轉換

如果模板生成的實例化版本與非模板函數相比，參數匹配更精確（無需轉換），優先選擇模板。

#include <iostream>// 模板函數
template <typename T>
void log(T a) {std::cout << "Template log: " << a << std::endl;
}// 非模板函數（參數類型為 double）
void log(double a) {std::cout << "Non-template log: " << a << std::endl;
}int main() {log(42);     // 調用模板生成的 log<int>（精確匹配）log(3.14);   // 調用非模板函數（精確匹配）
}

模板實例化版本：完全匹配 int
非模板函數：需要 int → double 隱式轉換

輸出：

Template log: 42
Non-template log: 3.14

對于非模板函數和同名函數模板，如果其他條件都相同，在調動時會優先調用非模板函數而不會從該模板產生出一個實例。如果模板可以產生一個具有更好匹配的函數，那么將選擇模板。

// 專門處理int的加法函數
int Add(int left, int right)
{return left + right;}
// 通用加法函數
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{return left + right;
}
void Test()
{Add(1, 2); // 與非函數模板類型完全匹配，不需要函數模板實例化Add(1, 2.0); // 模板函數可以生成更加匹配的版本，編譯器根據實參生成更加匹配的Add函數
}

顯式指定模板參數

顯式指定模板參數時，編譯器直接實例化模板，不參與與非模板函數的優先級比較。

#include <iostream>template <typename T>
void report(T a) {std::cout << "Template report: " << a << std::endl;
}void report(double a) {std::cout << "Non-template report: " << a << std::endl;
}int main() {report(42);           // 調用模板生成的 report<int>report<double>(3.14); // 強制調用模板生成的 report<double>report(3.14);         // 調用非模板函數（精確匹配 double）
}

顯式指定模板參數

用戶強制要求實例化 report<double>。

跳過非模板函數檢查

顯式指定模板參數時，編譯器直接生成 report<double>，不再考慮非模板函數。

結果

調用模板實例化的report<double>，而非非模板函數 report(double a)。

輸出：

Template report: 42
Template report: 3.14
Non-template report: 3.14

優先級總結

#include <iostream>// 非模板函數
void test(int a) {std::cout << "Non-template: " << a << std::endl;
}// 通用模板
template <typename T>
void test(T a) {std::cout << "Generic template: " << a << std::endl;
}// 更特化的模板（針對 double）
template <>
void test(double a) {std::cout << "Specialized template: " << a << std::endl;
}int main() {test(42);     // 非模板函數（精確匹配）test(3.14);   // 更特化的模板（double 特化）test("Hi");   // 通用模板（T=const char*）
}

非模板函數 > 特化模板 > 通用模板
精確匹配（無需類型轉換）優先于需要隱式轉換的函數。
顯式指定模板參數時，直接實例化模板（跳過非模板函數）。

輸出：

Non-template: 42
Specialized template: 3.14
Generic template: Hi

函數模板的底層原理

模板的編譯階段

- 抽象語法樹（AST）存儲：

編譯器將模板的語法結構（如函數參數、返回類型、操作邏輯）轉換為AST保存，但不生成任何機器碼。

template<typename T>
T max(T a, T b) { return (a > b) ? a : b; } 
// 僅保存AST，無代碼生成

實例化觸發

隱式實例化：當代碼中首次使用模板時觸發。

int main() {max(3, 5);     // 觸發 max<int> 的實例化max(3.0, 5.0); // 觸發 max<double> 的實例化
}

實例化位置：編譯器在調用點的作用域內生成實例化代碼，通常位于當前編譯單元（.cpp文件）內。

顯式實例化控制

手動指定實例化：通過 template 關鍵字強制生成特定類型的實例。

template int max<int>(int, int); // 顯式實例化 int 版本

類型推導的底層邏輯

推導規則

按值傳遞：編譯器執行類型退化（Decay），移除引用、const/volatile 修飾符，數組退化為指針。

template<typename T>
void f(T t) {}const int a = 10;
int arr[3] = {1, 2, 3};
f(a);    // T = int（移除const）
f(arr);  // T = int*（數組退化為指針）

按引用傳遞：保留原始類型信息。

template<typename T>
void f(T& t) {}const int a = 10;
f(a); // T = const int（保留const）

萬能引用（Forwarding Reference）

引用折疊規則：T&& 根據實參的左右值推導不同結果。

引用折疊規則：
T& & → T&
T&& & → T&
T& && → T&
T&& && → T&&

template<typename T>
void f(T&& t) {}int a = 10;
f(a);   // T = int&（左值 → T& && → T&）
f(10);  // T = int（右值 → T&&）

模板實例化

1、語法檢查

兩階段名稱查找（Two-Phase Lookup）：

第1階段：解析模板定義時檢查非依賴名稱（如全局函數、字面量類型）。

template<typename T>
void func(T t) {int x = 10;          // 非依賴名稱，立即檢查std::cout << x;      // 依賴名稱，延遲檢查
}

第2階段：實例化時檢查依賴名稱（如 T::member、模板參數相關的表達式）。

2、生成機器碼

符號生成與名稱修飾：為每個實例生成唯一的符號名。

GCC/Clang：_Z3maxIiET_S0_S0_（max<int>）。MSVC：??$max@H@@YAHHH@Z（max<int>）。

符號組成：

函數名、模板參數、命名空間、參數類型等編碼。

示例：void ns::foo<int, double>(int*) 可能被編碼為：

GCC：_ZN2ns3fooIiJdEEEvPi

MSVC：??$foo@H$0A@@ns@@YAXPAH@Z

反編譯工具：

GCC：c++filt _ZN2ns3fooIiJdEEEvPi → ns::foo<int, double>(int*)
MSVC：undname.exe 工具可解析修飾名。

3、實例化重復與優化

代碼膨脹示例：

max(1, 2);       // 生成 int 版本
max(1L, 2L);     // 生成 long 版本
max(1.0f, 2.0f); // 生成 float 版本

每個實例獨立生成代碼，導致二進制文件增大。

顯式實例化優化：

// 在某個.cpp文件中集中實例化
template int max<int>(int, int);
template double max<double>(double, double);

模板特化的底層實現

全特化（Full Specialization）直接覆蓋通用模板：生成特定類型的獨立實現。

template<>
int max<int>(int a, int b) {// 定制化的int版本實現return (a > b) ? a : b;
}

編譯器直接使用全特化版本，跳過通用模板邏輯。

偏特化模擬（通過重載）函數模板不支持偏特化，但可通過重載實現類似效果。

template<typename T> void process(T) {}      // 通用版本
template<typename T> void process(T*) {}     // 指針特化版本
template<typename T> void process(T[], int size) {} // 數組特化版本

SFINAE的底層機制

替換失敗：

在推導階段，若替換模板參數導致非法表達式或類型，候選被靜默排除。

示例：

template<typename T>
auto f(T t) -> decltype(t.size()) { ... } // 僅當 T 有 size() 時有效

編譯器行為：

嘗試所有候選函數，排除無效替換的模板，保留有效候選參與重載。

編譯器與鏈接器的協作

實例化重復問題

多個編譯單元實例化相同模板：每個.cpp文件獨立生成 max<int>，導致重復代碼。
鏈接器合并：最終鏈接時保留一份 max<int> 的副本，其余被丟棄。

顯式實例化聲明

減少重復實例化：在頭文件中聲明 extern template，在某個.cpp文件中集中定義。

// header.h
extern template int max<int>(int, int); // 聲明不實例化
// source.cpp
template int max<int>(int, int);        // 實際實例化

底層示例：從代碼到匯編

代碼示例：

template<typename T>
T add(T a, T b) { return a + b; }int main() {add(1, 2);     // 實例化 add<int>add(3.0, 4.0); // 實例化 add<double>
}

GCC生成的匯編代碼（簡化版）

; add<int> 的實例化
_Z3addIiET_S0_S0_:lea    eax, [rdi + rsi]  ; 整數加法（寄存器操作）ret; add<double> 的實例化
_Z3addIdET_S0_S0_:addsd  xmm0, xmm1        ; 浮點數加法（SSE指令）retmain:mov    edi, 1            ; 傳遞參數1到edi（int調用約定）mov    esi, 2            ; 傳遞參數2到esicall   _Z3addIiET_S0_S0_ ; 調用 add<int>movsd  xmm0, [rip + .LC0] ; 加載3.0到xmm0movsd  xmm1, [rip + .LC1] ; 加載4.0到xmm1call   _Z3addIdET_S0_S0_ ; 調用 add<double>xor    eax, eax          ; 返回0ret

編譯器的工作流程

編譯器的整體結構

編譯器通常可以分為前端（Front - End）、中端（Middle - End）和后端（Back - End）三個主要部分：

前端：負責處理與源語言相關的分析工作，包括詞法分析、語法分析、語義分析等，將源代碼轉換為一種中間表示形式（IR）。
中端：對中間表示形式進行優化，提高代碼的性能和效率，不依賴于具體的源語言和目標機器。
后端：將優化后的中間表示形式轉換為目標機器的機器語言代碼，處理與目標機器相關的問題，如寄存器分配、指令選擇等。

對于函數模板，編譯器會經過如下幾個階段處理：

前端編譯階段

詞法分析（Lexical Analysis）
工作原理：

編譯器的詞法分析器會按字符逐個讀取源代碼，將其拆分成一個個詞法單元（Token）。例如，對于代碼

 template <typename T> T add(T a, T b) { return a + b; }

詞法分析器會識別出 template、<、typename、T等詞法單元。

實現方式：

通常使用有限狀態自動機（Finite State Automaton, FSA）來實現。編譯器會預先定義好各種詞法單元的模式，當讀取字符時，根據當前狀態和輸入字符進行狀態轉移，最終識別出對應的詞法單元。例如，使用正則表達式來描述標識符、關鍵字等的模式，再將正則表達式轉換為有限狀態自動機進行匹配。

語法分析（Syntax Analysis）
工作原理：

語法分析器根據詞法分析器輸出的詞法單元序列，依據 C++ 的語法規則構建抽象語法樹（Abstract Syntax Tree, AST）。AST 是一種樹形結構，它以一種更結構化的方式表示源代碼的語法結構。例如，對于上述 add 函數模板，AST 會包含模板聲明、函數定義、參數列表、函數體等節點。

實現方式：

常見的實現方法有遞歸下降分析法、算符優先分析法和 LR 分析法等。遞歸下降分析法是一種自頂向下的分析方法，它為每個非終結符編寫一個遞歸函數，通過遞歸調用這些函數來構建 AST。例如，對于函數定義，會有一個函數來處理函數頭，另一個函數來處理函數體。

語義分析 - 模板定義檢查
工作原理：

語義分析器對 AST 進行檢查，確保模板定義符合 C++ 的語義規則。例如，檢查模板參數是否合法、模板函數體中的語句是否符合語法和語義要求等。對于會檢查 T 是否為合法的模板參數類型。

template <typename T> T add(T a, T b)

實現方式：

通過遍歷 AST，對每個節點進行語義檢查。編譯器會維護一些符號表和類型系統，用于記錄和檢查標識符的作用域、類型信息等。例如，當遇到一個變量時，會在符號表中查找其定義，并檢查其類型是否與使用處匹配。

模板定義符號表構建
工作原理：

符號表是編譯器用于記錄標識符信息的數據結構。在模板定義階段，編譯器會為模板及其相關的標識符（如模板參數、函數名等）建立符號表項。例如，對于 add 函數模板，會在符號表中記錄模板名 add、模板參數 T 以及它們的作用域等信息。

實現方式：

通常使用哈希表或樹形結構來實現符號表。當遇到一個新的標識符時，會在符號表中插入一個新的表項；當使用一個標識符時，會在符號表中查找對應的表項。

模板實例化階段

- 模板實例化請求

工作原理

：當代碼中使用模板函數并指定具體類型時，會觸發模板實例化請求。
例如：

int result = add<int>(1, 2);

會觸發 add 函數模板針對 int 類型的實例化請求。

實現方式：

編譯器在編譯過程中遇到模板函數調用時，會記錄調用的位置和提供的模板參數類型，然后發起實例化請求。

顯式與隱式實例化判斷
工作原理：

編譯器會根據代碼中是否使用 template 關鍵字明確指定實例化來判斷是顯式實例化還是隱式實例化。
例如：

template int add<int>(int, int);

是顯式實例化

add<int>(1, 2);

是隱式實例化。

實現方式：

在處理模板實例化請求時，檢查代碼中是否存在顯式實例化的語法結構。

實例化上下文確定
工作原理：

確定實例化所需的環境和信息，包括命名空間、作用域等。例如，在不同的命名空間中使用同一個模板函數，實例化時需要考慮命名空間的影響。

實現方式：

通過維護作用域棧和命名空間信息，在實例化時根據當前的作用域和命名空間來確定實例化上下文。

- 模板參數推導

工作原理：

當調用模板函數時沒有顯式指定模板參數類型，編譯器會根據調用時提供的實參類型推導出模板參數的具體類型。例如，add(1, 2); 編譯器會根據實參 1 和 2 的類型 int 推導出模板參數 T 為 int。

實現方式：

編譯器會根據實參的類型和模板參數的匹配規則進行推導。匹配規則包括類型轉換、引用折疊等。例如，如果實參是 const int 類型，而模板參數是 T，則會推導出 T 為 int。

- 模板參數替換

工作原理：

將模板代碼中的模板參數替換為具體類型。例如，對于 add 函數模板，當 T 被推導為 int 后，會將函數體中的 T 都替換為 int。

實現方式：

通過遍歷 AST，將所有與模板參數相關的節點替換為具體類型的節點。

- 重寫模板代碼

工作原理：

根據替換后的類型，對模板代碼進行重寫，生成具體的函數代碼。例如，將 add 函數模板重寫為

 int add(int a, int b) { return a + b; }。

實現方式：在 AST 上進行修改和生成新的代碼節點，然后將修改后的 AST 轉換為具體的源代碼。

- 模板特化檢查

工作原理：

查看是否存在針對當前類型的特化版本。如果有特化版本，則使用特化版本；否則，使用通用模板。例如，對于 add 函數模板，如果存在針對 double 類型的特化版本，當調用 add<double>(1.0, 2.0) 時，會使用特化版本。

實現方式：

在符號表中查找是否存在針對當前類型的特化模板定義，如果存在，則進行合法性檢查并使用該特化版本。

后端編譯階段

- 具體代碼生成

工作原理：

根據重寫后的模板代碼生成具體的目標代碼。編譯器會將抽象的代碼結構轉換為具體的機器指令。例如，將 int add(int a, int b) { return a + b; } 轉換為對應的匯編指令。

實現方式：

使用代碼生成器，根據目標機器的指令集和架構，將 AST 或中間表示轉換為匯編代碼。

- 中間代碼生成

工作原理：

將具體代碼轉換為中間表示形式（IR），便于后續優化。IR 是一種獨立于目標機器的代碼表示，具有更高的抽象層次。例如，將匯編代碼轉換為 LLVM IR。

實現方式：

通過對 AST 進行分析和轉換，生成中間代碼。中間代碼通常具有更簡單的結構和更統一的表示，便于進行各種優化操作。

- 代碼優化

工作原理：

對中間代碼進行優化，提高代碼的性能。優化包括局部優化和全局優化。局部優化主要針對單個函數或代碼塊內的代碼進行優化，如常量折疊、死代碼消除等；全局優化則考慮整個程序的上下文進行優化，如函數內聯、循環展開等。

實現方式：

使用各種優化算法和技術，如數據流分析、控制流分析等。例如，常量折疊是通過在編譯時計算常量表達式的值，將表達式替換為計算結果；函數內聯是將函數調用替換為函數體的代碼。

- 目標代碼生成

工作原理：

將優化后的中間代碼轉換為目標機器的匯編代碼。編譯器會根據目標機器的指令集和架構，將中間代碼中的操作轉換為具體的機器指令。

實現方式：

使用目標代碼生成器，根據中間代碼和目標機器的信息生成匯編代碼。

- 符號解析

工作原理：

解析代碼中的符號引用，確定符號的實際地址。在編譯過程中，不同的源文件可能會引用相同的符號，符號解析的目的是將這些引用與實際的定義關聯起來。例如，在一個源文件中調用另一個源文件中定義的函數，需要通過符號解析確定函數的實際地址。

實現方式：

鏈接器會維護一個符號表，記錄所有符號的定義和引用信息。在鏈接過程中，會根據符號表中的信息將符號引用與實際的定義進行匹配。

- 鏈接

工作原理：

將多個目標文件鏈接成一個可執行文件。不同的源文件會被編譯成不同的目標文件，鏈接器會將這些目標文件合并，并處理符號引用和重定位等問題。

實現方式：

鏈接器會讀取所有的目標文件和庫文件，將它們的代碼和數據段合并，處理符號引用和重定位信息，最終生成一個可執行文件。

函數模板總結

延遲編譯與模板存儲

藍圖存儲：模板定義時，編譯器僅保存其語法結構（如AST），不生成機器碼。
觸發實例化：首次調用時（如 max(3,5)）才根據具體類型生成實際函數。

類型推導規則

按值傳遞：退化類型（移除引用、const，數組/函數轉指針）。

template<typename T> void f(T t);
f("Hello"); // T推導為 `const char*`（數組退化為指針）

按引用傳遞：保留原始類型修飾符。

template<typename T> void f(T& t);
const int a = 10;
f(a); // T推導為 `const int`

萬能引用（T&&）：根據實參左右值推導不同引用類型（引用折疊規則）。

實例化過程

類型推導：確定模板參數 T。
語法檢查：驗證 T 是否支持模板內所有操作（如 operator+）。
生成機器碼：將模板中的 T 替換為具體類型，生成獨立函數。
名稱修飾：生成唯一符號名（如 Z3maxIiET_S0_S0 表示 max）。

符號管理與鏈接優化

代碼膨脹：每個類型生成獨立實例（如 max 和 max）。
顯式實例化：通過 template int max(int, int); 集中生成代碼，減少重復。
鏈接器合并：多個編譯單元中的相同實例在鏈接時僅保留一份。

模板特化與優先級

全特化：直接覆蓋通用模板，生成特定類型優化版本。

template<> int max<int>(int a, int b) { ... }

偏特化模擬：通過重載實現（如針對指針或容器的特化版本）。

核心代價與優化策略

問題	優化手段
代碼膨脹	顯式實例化、類型擦除（如 std::function）
編譯時間增長	前置聲明、extern template 聲明
二義性錯誤	明確模板參數、避免重載沖突