1. 從“通用藍(lán)圖”到“具體產(chǎn)品”模板的本質(zhì)如果你寫過C大概率遇到過這樣的場景你需要寫一個函數(shù)來比較兩個整數(shù)的大小然后又需要比較兩個浮點數(shù)的大小接著是比較兩個字符串的大小。代碼邏輯幾乎一模一樣只是參數(shù)類型不同。最直接的做法是復(fù)制粘貼然后改一下參數(shù)類型于是你有了compareInt、compareFloat、compareString三個函數(shù)。這還只是三個類型如果未來要比較自定義的Student對象呢繼續(xù)復(fù)制粘貼嗎這種重復(fù)不僅讓代碼變得臃腫更致命的是維護(hù)成本。當(dāng)你發(fā)現(xiàn)比較邏輯有個小bug或者想優(yōu)化一下算法你就得把所有這些函數(shù)都改一遍極易出錯。C模板Template就是為了解決這類“代碼復(fù)用但類型不同”的問題而生的。你可以把它理解為一個通用藍(lán)圖或者模具。想象一下你是一個玩具廠的設(shè)計師要生產(chǎn)恐龍、汽車、機(jī)器人三種玩具。如果沒有模具你需要為每一種玩具單獨畫一份詳細(xì)到每個螺絲的生產(chǎn)圖紙。但如果你有一個“可調(diào)節(jié)模具”它定義了玩具的基本結(jié)構(gòu)和組裝流程只是預(yù)留了“頭部形狀”、“輪子數(shù)量”、“手臂關(guān)節(jié)類型”這幾個參數(shù)。那么當(dāng)你需要生產(chǎn)恐龍時就把模具參數(shù)調(diào)成“三角龍頭、四條腿、尾巴關(guān)節(jié)”生產(chǎn)汽車時就調(diào)成“流線型車頭、四個輪子、無手臂”。這個“可調(diào)節(jié)模具”就是模板而根據(jù)具體參數(shù)類型生產(chǎn)出恐龍玩具、汽車玩具的過程就是模板的實例化。在C中模板允許你編寫與類型無關(guān)的通用代碼。編譯器則在你使用這些代碼時根據(jù)你提供的具體類型自動生成一份針對該類型的特化代碼。這實現(xiàn)了編譯期多態(tài)是C泛型編程的基石。今天我們就深入這個“模具車間”看看函數(shù)模板和類模板這兩臺核心機(jī)器是如何工作的并徹底搞懂“實例化”這個從藍(lán)圖到產(chǎn)品的關(guān)鍵工序。2. 函數(shù)模板讓算法與類型脫鉤函數(shù)模板是模板中最直觀的形式。它允許你定義一個函數(shù)家族這些函數(shù)除了參數(shù)類型和返回類型不同操作邏輯完全一致。2.1 函數(shù)模板的聲明與定義一個經(jīng)典的例子就是上面提到的比較函數(shù)。我們來看看如何用模板來實現(xiàn)它// 函數(shù)模板的聲明與定義通常寫在一起在頭文件中 template typename T // 模板參數(shù)列表聲明一個類型參數(shù)Ttypename 也可用 class 替代 int compare(const T v1, const T v2) { if (v1 v2) return -1; if (v2 v1) return 1; // 使用 運(yùn)算符進(jìn)行比較這意味著類型T必須支持 操作 return 0; }這段代碼定義了一個名為compare的函數(shù)模板。template typename T是模板引入的關(guān)鍵字它告訴編譯器接下來我要定義一個模板其中有一個類型參數(shù)我暫時叫它T。在函數(shù)體內(nèi)部T就像一個占位符代表某種具體的類型。這里有一個非常重要的細(xì)節(jié)我們使用了if (v1 v2)和if (v2 v1)而不是if (v1 v2)。為什么這是為了最大限度地減少對類型T的要求。我們只要求類型T支持運(yùn)算符。如果同時使用了和就要求類型同時支持兩種運(yùn)算符這增加了不必要的約束。這種“最小化模板參數(shù)要求”的思想是編寫良好模板代碼的重要原則。2.2 模板參數(shù)推導(dǎo)與顯式指定當(dāng)我們調(diào)用函數(shù)模板時編譯器會進(jìn)行模板參數(shù)推導(dǎo)。int main() { int i1 1, i2 2; double d1 3.14, d2 2.71; std::string s1 hello, s2 world; // 調(diào)用1compare(i1, i2) // 編譯器推導(dǎo)實參i1, i2是int類型所以 T 被推導(dǎo)為 int // 編譯器生成并調(diào)用int compareint(const int, const int) std::cout compare(i1, i2) std::endl; // 輸出-1 // 調(diào)用2compare(d1, d2) // 編譯器推導(dǎo)T 被推導(dǎo)為 double // 編譯器生成并調(diào)用int comparedouble(const double, const double) std::cout compare(d1, d2) std::endl; // 輸出1 // 調(diào)用3compare(s1, s2) // 編譯器推導(dǎo)T 被推導(dǎo)為 std::string // 編譯器生成并調(diào)用int comparestd::string(const std::string, const std::string) // std::string 支持 運(yùn)算符按字典序比較所以可以編譯 std::cout compare(s1, s2) std::endl; // 輸出-1 (h w) }編譯器就像個偵探通過你傳入的實參類型反向推斷出模板參數(shù)T應(yīng)該是什么。絕大多數(shù)情況下這都能自動完成。但有時也會遇到推導(dǎo)歧義或者我們想指定特定類型的情況這時就需要顯式指定模板實參。// 一個簡單的例子返回兩個數(shù)中較大的一個 template typename T T max(T a, T b) { return (a b) ? a : b; } int main() { int a 1; double b 2.5; // 錯誤編譯器困惑了從第一個實參a推導(dǎo)T為int從第二個實參b推導(dǎo)T為double矛盾。 // auto result max(a, b); // 正確做法1顯式指定T為double或int編譯器會將另一個參數(shù)進(jìn)行隱式轉(zhuǎn)換。 auto result1 maxdouble(a, b); // T 被顯式指定為 double, a 從 int 轉(zhuǎn)換為 double std::cout result1 std::endl; // 輸出2.5 // 正確做法2使用C11的自動類型推導(dǎo)auto但這已經(jīng)離開了模板實例化的范疇。 auto result2 std::max(a, b); // std::max 有多個重載版本其中一個能處理不同類型 }注意模板參數(shù)推導(dǎo)發(fā)生在編譯期它不涉及任何運(yùn)行時開銷。編譯器根據(jù)推導(dǎo)或指定的類型在編譯階段就生成了對應(yīng)的函數(shù)代碼。2.3 非類型模板參數(shù)模板參數(shù)不僅僅是類型typename T還可以是整型常量、指針或引用指向?qū)ο蠡蚝瘮?shù)等這些被稱為非類型模板參數(shù)。它們必須是編譯期常量。// 定義一個數(shù)組包裝類其大小由模板參數(shù)指定 template typename T, std::size_t N // N 是一個非類型模板參數(shù)必須是編譯期常量 class Array { private: T m_elements[N]; // 棧上分配的固定大小數(shù)組 public: std::size_t size() const { return N; } T operator[](std::size_t index) { return m_elements[index]; } const T operator[](std::size_t index) const { return m_elements[index]; } }; int main() { Arrayint, 10 intArr; // 實例化一個大小為10的int數(shù)組類 Arraydouble, 100 doubleArr; // 實例化一個大小為100的double數(shù)組類 // Arrayint, size dynArr; // 錯誤size如果是變量則不是編譯期常量無法作為非類型模板參數(shù)。 constexpr std::size_t size 20; // constexpr 確保size是編譯期常量 Arraychar, size charArr; // 正確 }非類型模板參數(shù)讓代碼更具靈活性和性能優(yōu)勢。例如上面的Array類因為大小N在編譯期已知編譯器可以進(jìn)行更多的優(yōu)化如循環(huán)展開。標(biāo)準(zhǔn)庫中的std::array就是基于這個原理實現(xiàn)的。3. 類模板構(gòu)建通用數(shù)據(jù)結(jié)構(gòu)如果說函數(shù)模板是通用算法那么類模板就是通用數(shù)據(jù)結(jié)構(gòu)。C標(biāo)準(zhǔn)庫中的vector、list、map等容器無一不是類模板的杰作。3.1 類模板的基本定義我們來實現(xiàn)一個簡化的Box類模板它可以存放任何類型的物品。template typename ItemType // ItemType 是類型參數(shù) class Box { private: ItemType m_item; public: // 構(gòu)造函數(shù) Box(const ItemType item) : m_item(item) {} // 成員函數(shù) ItemType getItem() const { return m_item; } void setItem(const ItemType newItem) { m_item newItem; } // 一個演示性的模板成員函數(shù)在類內(nèi) void describe() const { std::cout A box containing: m_item std::endl; } };與函數(shù)模板類似類模板也以template typename T開頭。在類內(nèi)部你可以把ItemType當(dāng)作一個已知類型來使用定義成員變量、成員函數(shù)。3.2 類模板的實例化與使用關(guān)鍵點來了類模板的實例化必須顯式指定模板參數(shù)。編譯器無法像函數(shù)模板那樣通過構(gòu)造函數(shù)參數(shù)來推導(dǎo)類模板的參數(shù)在C17之前這個說法是絕對正確的C17引入了類模板參數(shù)推導(dǎo)CTAD但為了理解本質(zhì)我們先從基礎(chǔ)看起。int main() { // 實例化一個 Boxint 類型并創(chuàng)建其對象 intBox Boxint intBox(42); std::cout intBox.getItem() std::endl; // 輸出42 intBox.describe(); // 輸出A box containing: 42 // 實例化一個 Boxstd::string 類型并創(chuàng)建其對象 strBox Boxstd::string strBox(Magic); strBox.describe(); // 輸出A box containing: Magic // 實例化一個 Boxdouble 類型 Boxdouble doubleBox(3.14159); // doubleBox.getItem() 返回 double 類型 // 錯誤編譯器不知道 ItemType 是什么 // Box unknownBox(10); }當(dāng)你寫下Boxint intBox(42);時發(fā)生了兩件事模板實例化編譯器看到Boxint它知道需要根據(jù)BoxItemType這個藍(lán)圖將其中所有的ItemType替換為int生成一個實實在在的Box_int類這個名字是邏輯上的實際名稱會經(jīng)過修飾。這個類擁有int m_item成員以及對應(yīng)的成員函數(shù)。對象創(chuàng)建使用生成的Box_int類調(diào)用其構(gòu)造函數(shù)Box_int(int)來創(chuàng)建對象intBox。Boxint、Boxstd::string、Boxdouble是三個完全不同的類它們之間沒有繼承關(guān)系。這是模板與面向?qū)ο蠖鄳B(tài)的一個根本區(qū)別。3.3 在類外定義成員函數(shù)對于復(fù)雜的類模板將成員函數(shù)定義在類外部可以使頭文件更清晰。語法稍有不同// Box.h template typename ItemType class Box { private: ItemType m_item; public: Box(const ItemType item); ItemType getItem() const; void setItem(const ItemType newItem); }; // 在類外定義構(gòu)造函數(shù) template typename ItemType BoxItemType::Box(const ItemType item) : m_item(item) { // 構(gòu)造函數(shù)體 } // 在類外定義 getItem 成員函數(shù) template typename ItemType ItemType BoxItemType::getItem() const { return m_item; } // 在類外定義 setItem 成員函數(shù) template typename ItemType void BoxItemType::setItem(const ItemType newItem) { m_item newItem; }注意每個在類外定義的成員函數(shù)都必須以自己的template typename ItemType開頭并且使用BoxItemType::作為作用域限定。這是因為每個成員函數(shù)本身也是模板的一部分。非常重要的一點是類模板的成員函數(shù)通常必須和類模板定義放在同一個頭文件里。原因我們會在下一節(jié)“實例化細(xì)節(jié)”中深入探討。4. 實例化深度剖析編譯器的“代碼生成器”“實例化”是模板機(jī)制的核心也是最容易產(chǎn)生困惑的地方。很多人以為“使用模板”就是實例化其實這背后編譯器做了大量工作。4.1 實例化的兩種方式隱式與顯式隱式實例化這是我們最常見的方式。當(dāng)代碼中使用了模板的具體特化版本時編譯器會自動為我們生成該版本的代碼。Boxint myBox; // 此處導(dǎo)致編譯器隱式實例化 Boxint 類 compare(10, 20); // 此處導(dǎo)致編譯器隱式實例化 compareint 函數(shù)編譯器在鏈接前會在當(dāng)前編譯單元.cpp文件中生成Boxint和compareint的代碼。如果多個.cpp文件都用了Boxint每個文件都會生成一份自己的副本鏈接器最后會去重大多數(shù)情況下。顯式實例化我們明確地告訴編譯器“請為我生成這個特定模板參數(shù)的代碼”。這通常用于控制代碼生成的位置避免在多個源文件中重復(fù)實例化導(dǎo)致的編譯時間增長和潛在的鏈接問題。// 在某個源文件如 template_inst.cpp中 #include Box.h #include compare.h // 顯式實例化類模板 Box 的 int 和 double 版本 template class Boxint; template class Boxdouble; // 顯式實例化函數(shù)模板 compare 的 int 和 double 版本 template int compareint(const int, const int); template int comparedouble(const double, const double);這樣在其他.cpp文件中使用Boxint時編譯器就不會再生成代碼而是鏈接到template_inst.cpp中已生成的那一份。這對于大型項目減少編譯時間很有幫助。4.2 為什么模板定義要放在頭文件這是一個經(jīng)典的C模板問題。對于普通函數(shù)和類我們通常將聲明放在.h文件定義放在.cpp文件。但對于模板這條規(guī)則不適用。根本原因在于模板不是代碼它是生成代碼的藍(lán)圖。編譯器需要在看到模板被使用實例化的地方同時也能看到模板的完整定義藍(lán)圖才能生成具體的代碼?？紤]以下錯誤的分開編譯方式// mytemplate.h template typename T T add(T a, T b); // 只有聲明 // mytemplate.cpp #include mytemplate.h template typename T T add(T a, T b) { // 定義在這里 return a b; } // main.cpp #include mytemplate.h int main() { int sum add(1, 2); // 編譯器在這里需要實例化 addint // 問題編譯器在編譯 main.cpp 時只看到了 mytemplate.h 中的聲明。 // 它看不到 add 函數(shù)模板的定義藍(lán)圖因此無法生成 addint 的代碼。 // 鏈接時鏈接器也找不到 addint 的函數(shù)體導(dǎo)致“未定義引用”錯誤。 }為了解決這個問題必須將模板的聲明和定義都放在頭文件里。這樣任何包含該頭文件的源文件在需要實例化模板時都能看到完整的藍(lán)圖從而自己生成所需的代碼。實操心得對于大型項目將所有模板代碼放在頭文件會導(dǎo)致編譯依賴嚴(yán)重任何一個模板的改動都會引發(fā)大范圍重新編譯。常見的優(yōu)化策略是顯式實例化如上所述將常用特化版本集中在一個.cpp中實例化。使用外部模板C11在用到模板的源文件中使用extern template class std::vectorint;聲明告訴編譯器不要在此處實例化去別處找。這需要配合顯式實例化使用。將模板實現(xiàn)分離到.ipp或.tpp文件然后在頭文件末尾#include這個實現(xiàn)文件。這只是在邏輯上分離對編譯器而言定義依然在頭文件中。4.3 惰性實例化編譯器很“懶”編譯器實例化模板時遵循“用到什么才生成什么”的原則即惰性實例化。它只實例化那些真正被用到的成員函數(shù)。template typename T class LazyExample { public: void usedFunction() { std::cout This function is used.\n; } void unusedFunction() { T nonExistent T::someStaticMethod(); // 假設(shè)T沒有這個靜態(tài)方法這行代碼本身是錯的 std::cout This function is never called.\n; } }; int main() { LazyExampleint obj; obj.usedFunction(); // 只實例化 usedFunction // obj.unusedFunction(); // 如果調(diào)用這行編譯器會嘗試實例化unusedFunction并因Tint沒有someStaticMethod而報錯。 }即使unusedFunction的函數(shù)體存在錯誤對于Tint來說只要程序中沒有代碼試圖調(diào)用它編譯器就不會去檢查它的函數(shù)體因此也不會報錯。這個特性有時可以用來寫一些“條件編譯”的代碼但更多時候需要你注意模板代碼的錯誤只有在實例化時才會暴露。5. 模板實戰(zhàn)一個簡單的棧Stack類模板讓我們綜合運(yùn)用所學(xué)實現(xiàn)一個功能完整的棧Stack類模板。棧是一種后進(jìn)先出LIFO的數(shù)據(jù)結(jié)構(gòu)。5.1 棧類模板的設(shè)計與實現(xiàn)我們將使用動態(tài)數(shù)組std::vector作為內(nèi)部容器這比裸數(shù)組更安全、更方便。// Stack.h #ifndef STACK_H #define STACK_H #include vector #include stdexcept // 用于 std::runtime_error #include iostream template typename T class Stack { private: std::vectorT m_elements; // 內(nèi)部容器 public: // 構(gòu)造函數(shù)默認(rèn)構(gòu)造一個空棧 Stack() default; // 入棧操作 void push(const T value) { m_elements.push_back(value); } // 出棧操作返回棧頂元素 T pop() { if (isEmpty()) { throw std::runtime_error(Stack is empty, cannot pop.); } T topElement m_elements.back(); // 獲取末尾元素棧頂 m_elements.pop_back(); // 移除末尾元素 return topElement; } // 查看棧頂元素但不彈出 T top() { if (isEmpty()) { throw std::runtime_error(Stack is empty, no top element.); } return m_elements.back(); } const T top() const { // const 版本用于const對象 if (isEmpty()) { throw std::runtime_error(Stack is empty, no top element.); } return m_elements.back(); } // 判斷棧是否為空 bool isEmpty() const { return m_elements.empty(); } // 獲取棧中元素數(shù)量 std::size_t size() const { return m_elements.size(); } // 打印棧內(nèi)容輔助函數(shù)非棧標(biāo)準(zhǔn)操作 void print() const { std::cout Stack (top to bottom): ; // 從后向前打印模擬從棧頂?shù)綏５?for (auto it m_elements.rbegin(); it ! m_elements.rend(); it) { std::cout *it ; } std::cout std::endl; } }; #endif // STACK_H這個Stack類模板封裝了std::vector提供了經(jīng)典的棧接口push、pop、top、isEmpty、size。我們使用了異常來處理空棧時的pop和top操作這比返回一個特殊值或未定義行為更安全。5.2 使用棧類模板現(xiàn)在我們可以用這個棧來存儲各種類型的數(shù)據(jù)。// main.cpp #include Stack.h #include string int main() { // 實例化一個存儲int的棧 Stackint intStack; intStack.push(10); intStack.push(20); intStack.push(30); intStack.print(); // 輸出Stack (top to bottom): 30 20 10 std::cout Top element: intStack.top() std::endl; // 輸出30 std::cout Stack size: intStack.size() std::endl; // 輸出3 int popped intStack.pop(); std::cout Popped: popped std::endl; // 輸出30 intStack.print(); // 輸出Stack (top to bottom): 20 10 // 實例化一個存儲std::string的棧 Stackstd::string stringStack; stringStack.push(Hello); stringStack.push(Template); stringStack.push(World); stringStack.print(); // 輸出Stack (top to bottom): World Template Hello while (!stringStack.isEmpty()) { std::cout stringStack.pop() ; } // 輸出World Template Hello std::cout std::endl; // 嘗試從空棧彈出會拋出異常 Stackdouble doubleStack; try { doubleStack.pop(); } catch (const std::runtime_error e) { std::cerr Error: e.what() std::endl; // 輸出Error: Stack is empty, cannot pop. } return 0; }通過這個例子你可以清晰地看到類模板的強(qiáng)大我們用同一套Stack的藍(lán)圖生成了操作int、std::string、double等不同類型數(shù)據(jù)的棧而無需為每種類型重寫代碼。5.3 模板與代碼膨脹模板帶來了代碼復(fù)用和類型安全但也可能導(dǎo)致代碼膨脹。因為Stackint、Stackstd::string、Stackdouble是三個不同的類編譯器會為它們生成三份獨立的機(jī)器代碼。如果模板很復(fù)雜比如std::vector并且實例化了很多不同類型最終的可執(zhí)行文件大小可能會顯著增加。不過現(xiàn)代編譯器和鏈接器有“智能去重”的優(yōu)化。更重要的是在大多數(shù)情況下類型安全、性能泛型代碼通常是內(nèi)聯(lián)的和開發(fā)效率帶來的好處遠(yuǎn)大于可執(zhí)行文件輕微增大的代價。對于特別關(guān)心尺寸的嵌入式系統(tǒng)則需要謹(jǐn)慎評估模板的使用范圍。6. 進(jìn)階話題初探與常見陷阱掌握了基礎(chǔ)之后我們來看看模板在實際使用中容易遇到的幾個“坑”。6.1 依賴名稱與typename關(guān)鍵字在模板定義中有些名稱的含義依賴于模板參數(shù)它們被稱為依賴名稱?？聪旅孢@個例子template typename T class MyClass { public: void myMethod() { T::subType * ptr; // 這行代碼有歧義 // 編譯器不知道 T::subType 是一個類型名還是一個靜態(tài)成員變量。 // 如果是一個類型名這行是在聲明一個指針。 // 如果是一個靜態(tài)成員變量這行是在做乘法運(yùn)算。 } };對于編譯器來說在模板未被實例化之前它無法從語法上確定T::subType是什么。默認(rèn)情況下編譯器會假定它是一個值變量而不是一個類型。為了解決這個歧義C規(guī)定如果依賴名稱表示的是一個類型必須用typename關(guān)鍵字顯式指明。template typename T class MyClass { public: void myMethod() { typename T::subType * ptr; // 正確明確告訴編譯器 T::subType 是一個類型 // 現(xiàn)在這行代碼明確是聲明一個指向 T::subType 類型的指針。 } };這是一個非常容易出錯的細(xì)節(jié)尤其是在編寫模板庫或使用嵌套類型時。記住規(guī)則在模板中對于依賴于模板參數(shù)的限定名如T::something如果它表示一個類型前面必須加typename。6.2 模板與友元讓一個函數(shù)或類成為模板類的友元語法上會有點繞。主要分為幾種情況非模板友元一個普通的函數(shù)或類是所有模板實例的友元。綁定的模板友元一個特定實例化的模板函數(shù)或類是另一個模板類特定實例的友元。非綁定的模板友元一個模板函數(shù)或類是所有模板實例的友元并且其類型參數(shù)可以不同。這里舉一個“綁定的模板友元”的例子它相對常見// 先聲明模板函數(shù) template typename U void friendFunc(); template typename T class HasFriend { T value; public: HasFriend(T v) : value(v) {} // 聲明 friendFuncint 是 HasFriendint 的友元 // friendFuncdouble 則不是 HasFriendint 的友元 friend void friendFuncint(); }; // 定義 friendFunc 模板 template typename U void friendFunc() { HasFriendint hf(10); // 可以訪問 HasFriendint 的私有成員嗎 // 只有當(dāng) U 是 int 時這個函數(shù)才是 HasFriendint 的友元。 // 所以 friendFuncint() 可以訪問 hf.value但 friendFuncdouble() 不行。 std::cout hf.value std::endl; // 如果 U ! int這行編譯報錯 } int main() { friendFuncint(); // 正確是友元 // friendFuncdouble(); // 編譯錯誤不是 HasFriendint 的友元無法訪問私有成員 value }模板友元的規(guī)則比較復(fù)雜使用時需要仔細(xì)查閱資料并測試。6.3 默認(rèn)模板參數(shù)和函數(shù)參數(shù)可以有默認(rèn)值一樣模板參數(shù)包括類型參數(shù)和非類型參數(shù)也可以有默認(rèn)值。// 類模板的默認(rèn)參數(shù) template typename T int, int INIT_SIZE 10 // T默認(rèn)為intINIT_SIZE默認(rèn)為10 class Container { // ... 使用 T 和 INIT_SIZE ... }; int main() { Container c1; // 使用所有默認(rèn)參數(shù)Containerint, 10 Containerdouble c2; // 指定T為doubleINIT_SIZE使用默認(rèn)值10Containerdouble, 10 Containerchar, 20 c3; // 指定所有參數(shù)Containerchar, 20 } // 函數(shù)模板的默認(rèn)參數(shù)C11起支持 template typename T int T add(T a, T b) { return a b; } int main() { auto sum add(5, 3); // 推導(dǎo)為 addint auto sum2 add(5.0, 3.0); // 顯式使用默認(rèn)參數(shù)但推導(dǎo)會覆蓋仍然是 adddouble auto sum3 add(5); // 錯誤無法推導(dǎo)出第二個參數(shù)b的類型。 }默認(rèn)模板參數(shù)在標(biāo)準(zhǔn)庫中大量使用例如std::vectorT, Allocator中的分配器Allocator就有默認(rèn)值。模板的世界遠(yuǎn)不止于此還有特化、偏特化、變參模板、模板元編程等高級主題。但理解并掌握今天所講的函數(shù)模板、類模板以及實例化的核心機(jī)制已經(jīng)為你打開了泛型編程的大門。記住模板的本質(zhì)是編譯期的代碼生成它追求的是類型安全下的高度抽象和效率。從今天起嘗試在你的項目中用模板替換那些重復(fù)的類型特定代碼你會立刻感受到它的威力。