1. 從“硬編碼”到“通用藍(lán)圖”為什么我們需要泛型編程干了這么多年C我見過太多新手甚至一些工作幾年的朋友寫的代碼為了處理一個int數(shù)組和一個double數(shù)組吭哧吭哧寫了兩套幾乎一模一樣的排序函數(shù)只是把參數(shù)類型和內(nèi)部變量類型改了一下。代碼冗余不說哪天老板說再加個long或者自定義的Student類也要排序又得復(fù)制粘貼一遍維護(hù)起來簡直是噩夢。這種場景就是泛型編程要解決的核心痛點。泛型編程Generic Programming不是什么高深莫測的黑魔法它的思想非常樸素編寫與數(shù)據(jù)類型無關(guān)的通用代碼。在C里實現(xiàn)這一思想的利器就是模板Template。你可以把模板理解為一個“代碼生成器”或者“藍(lán)圖”。你告訴編譯器“我這里有個算法邏輯但具體用什么類型我還沒定你先按這個邏輯給我生成一份代碼的模具?！钡鹊秸嬲玫臅r候你傳入具體的類型比如int,string, 或者你自己的Matrix類編譯器就拿著這個模具“咔嚓”一下現(xiàn)場為你澆鑄出針對這個特定類型的、完全可用的代碼。這帶來的好處是顛覆性的。首先代碼復(fù)用率飆升。一套模板代碼可以應(yīng)對無數(shù)種數(shù)據(jù)類型徹底告別重復(fù)勞動。其次類型安全得到保證。模板是在編譯期進(jìn)行類型檢查和代碼生成的這比C語言里用void*來實現(xiàn)通用性要安全得多類型錯誤在編譯階段就會暴露出來。最后它不損失性能。因為編譯器生成的是針對具體類型的特化代碼和手寫的一樣高效沒有運行時類型判斷的開銷。所以當(dāng)你開始對重復(fù)的、僅類型不同的代碼感到厭倦時就是你該認(rèn)真學(xué)學(xué)模板的時候了。接下來我們就從最常用的兩種模板——函數(shù)模板和類模板——入手把它們掰開揉碎了講清楚。2. 函數(shù)模板打造你的第一個通用算法函數(shù)模板是泛型編程的入門磚。它的目標(biāo)很簡單讓一個函數(shù)能處理多種類型的參數(shù)。2.1 基礎(chǔ)語法與定義從swap函數(shù)說起我們從一個最經(jīng)典的例子開始交換兩個變量的值。沒有模板時你得為每種類型寫一個void swapInt(int a, int b) { int temp a; a b; b temp; } void swapDouble(double a, double b) { double temp a; a b; b temp; } // 再來個string再來個自定義類...沒完沒了用函數(shù)模板一行聲明搞定所有template typename T // 模板聲明T是一個占位符類型參數(shù) void mySwap(T a, T b) { T temp a; // 注意這里temp的類型也是T a b; b temp; }拆解一下這句template typename Ttemplate關(guān)鍵字告訴編譯器“我要開始定義模板了”。typename T模板參數(shù)列表。typename是另一個關(guān)鍵字也可以用古老的class效果一樣意思是“這里將是一個類型”。T是你自己起的名字叫Type、Ty、U都行但慣例用大寫字母開頭比如T、U、V。你可以把它理解為一個“類型變量”。這個模板就像一個公式。當(dāng)你調(diào)用mySwap(x, y)時編譯器會做兩件事類型推導(dǎo)查看x和y的類型比如都是int。實例化將模板里的所有T替換成推導(dǎo)出的int生成一個實實在在的void mySwapint(int a, int b)函數(shù)然后編譯它。注意typename和class在模板參數(shù)里幾乎完全等價。但typename更現(xiàn)代、語義更清晰“一個類型名”尤其是在嵌套依賴類型中必須用typename。我個人的習(xí)慣是表示基本類型或類類型時用typename強(qiáng)調(diào)這是一個類時用class但無傷大雅。2.2 類型推導(dǎo)與顯式指定編譯器是怎么“猜”類型的調(diào)用函數(shù)模板時大多數(shù)情況你不需要指明T是什么編譯器很聰明能自己推導(dǎo)。int i 1, j 2; double m 3.14, n 2.71; std::string s1 hello, s2 world; mySwap(i, j); // 編譯器推導(dǎo) T 為 int mySwap(m, n); // 編譯器推導(dǎo) T 為 double mySwap(s1, s2); // 編譯器推導(dǎo) T 為 std::string但有些時候編譯器會“猜”錯或者你需要它生成一個特定版本的函數(shù)。這時就需要顯式指定模板參數(shù)template typename T T add(T a, T b) { return a b; } int main() { int a 5; double b 3.14; // auto result add(a, b); // 錯誤編譯器懵了T到底是int還是double auto result1 adddouble(a, b); // 顯式指定T為doublea會被隱式轉(zhuǎn)換為double auto result2 addint(a, b); // 顯式指定T為intb會被截斷為int return 0; }實操心得當(dāng)函數(shù)模板的返回值類型與參數(shù)類型相關(guān)或者存在重載決議模糊時養(yǎng)成顯式指定模板參數(shù)的習(xí)慣能讓代碼意圖更清晰避免意想不到的隱式轉(zhuǎn)換。2.3 多類型參數(shù)與默認(rèn)參數(shù)讓模板更靈活模板參數(shù)可以不止一個也可以有默認(rèn)值和函數(shù)參數(shù)非常像。// 兩個類型參數(shù) template typename T, typename U auto mixedAdd(const T t, const U u) - decltype(t u) { // C11 尾返回類型 return t u; } // 帶有默認(rèn)類型參數(shù)的模板C11起 template typename T, typename Container std::vectorT // Container默認(rèn)為vectorT class MyClass { // ... 使用 Container }; // 甚至非類型模板參數(shù)后面會詳述 template typename T, int N class FixedArray { T data[N]; // 數(shù)組大小在編譯期就確定了 };2.4 重載與特化當(dāng)通用方案遇到特殊情況函數(shù)模板可以被重載也可以被特化以處理某些特殊類型。重載提供同名但參數(shù)列表不同的模板或普通函數(shù)。// 通用版本 template typename T void print(const T val) { std::cout Generic: val std::endl; } // 重載版本針對指針類型 template typename T void print(T* ptr) { if(ptr) std::cout Pointer points to: *ptr std::endl; else std::cout Null pointer std::endl; } // 普通函數(shù)重載針對C風(fēng)格字符串優(yōu)先級可能高于模板 void print(const char* str) { std::cout C-string: str std::endl; }特化為特定的類型提供一個完全定制化的實現(xiàn)。特化是“全部指定”不像重載還可以部分推導(dǎo)。// 主模板 template typename T bool isEqual(T a, T b) { return a b; } // 全特化針對const char* 類型 template bool isEqualconst char*(const char* a, const char* b) { return strcmp(a, b) 0; }重要提示函數(shù)模板的全特化并不參與重載決議它只是主模板的一個特殊實例。對于函數(shù)通常更推薦使用重載來實現(xiàn)特定類型的特殊處理因為重載是更通用的機(jī)制。類模板的特化則更為常用和強(qiáng)大我們后面會看到。3. 類模板構(gòu)建可復(fù)用的數(shù)據(jù)結(jié)構(gòu)如果說函數(shù)模板讓算法通用化那么類模板就讓數(shù)據(jù)結(jié)構(gòu)通用化。STL標(biāo)準(zhǔn)模板庫的核心如vector,list,map全都是類模板。3.1 類模板的定義與使用打造自己的Box假設(shè)我們要一個能存放任何類型數(shù)據(jù)的“盒子”類。template typename T // 類模板聲明 class Box { private: T content; public: Box(const T item) : content(item) {} // 構(gòu)造函數(shù) T getContent() const { return content; } void setContent(const T item) { content item; } };使用類模板時必須顯式指定模板參數(shù)因為編譯器無法從構(gòu)造函數(shù)調(diào)用中推導(dǎo)出類的類型C17的類模板參數(shù)推導(dǎo)CTAD在某些場景下可以但這里不展開。Boxint intBox(123); // 必須指定int std::cout intBox.getContent() std::endl; Boxstd::string strBox(Hello Template); strBox.setContent(New String); // 甚至可以嵌套 BoxBoxdouble nestedBox(3.14);注意事項類模板的成員函數(shù)如果定義在類外部語法需要特別注意template typename T class Box { T content; public: Box(const T item); T getContent() const; }; // 外部定義構(gòu)造函數(shù) template typename T BoxT::Box(const T item) : content(item) {} // 外部定義成員函數(shù) template typename T T BoxT::getContent() const { return content; }每個成員函數(shù)定義前都要重復(fù)template typename T并且用BoxT::來指明作用域。我強(qiáng)烈建議對于簡單的類模板直接將成員函數(shù)定義在類內(nèi)部隱式內(nèi)聯(lián)代碼更緊湊。只有函數(shù)體很大時才考慮分離到外部。3.2 默認(rèn)模板參數(shù)與多參數(shù)更符合工程實踐和函數(shù)模板一樣類模板也支持默認(rèn)參數(shù)這大大提升了易用性。// 一個簡單的動態(tài)數(shù)組模板分配器默認(rèn)為std::allocator template typename T, typename Allocator std::allocatorT class SimpleVector { T* data; size_t capacity; size_t size; Allocator alloc; // 使用分配器對象 public: // ... 使用alloc分配/釋放內(nèi)存 }; // 使用時大多數(shù)情況只需要關(guān)心元素類型 SimpleVectorint vec1; // 使用默認(rèn)的std::allocatorint SimpleVectorMyClass, MyCustomAllocatorMyClass vec2; // 使用自定義分配器多參數(shù)模板能構(gòu)建更復(fù)雜的關(guān)系。例如一個映射類簡陋版maptemplate typename Key, typename Value, typename Compare std::lessKey class MyMap { // 內(nèi)部可能用std::pairKey, Value存儲 Compare comp; // 比較器對象用于排序 public: bool insert(const Key k, const Value v); Value* find(const Key k); };3.3 類模板的特化與偏特化為特定類型開小灶這是類模板最強(qiáng)大的特性之一。當(dāng)通用方案對某些類型效率低下或根本行不通時特化就派上用場了。全特化為所有模板參數(shù)都指定具體類型。// 主模板通用版本 template typename T class TypeInfo { public: static std::string name() { return unknown type; } }; // 全特化針對int類型 template class TypeInfoint { public: static std::string name() { return int; } }; // 全特化針對double類型 template class TypeInfodouble { public: static std::string name() { return double; } }; std::cout TypeInfofloat::name(); // 輸出unknown type std::cout TypeInfoint::name(); // 輸出int偏特化部分特化只特化一部分模板參數(shù)或者對模板參數(shù)加上一些限制如特化為指針類型。// 主模板 template typename T, typename U class MyPair { T first; U second; }; // 偏特化當(dāng)兩個類型相同時 template typename T class MyPairT, T { T first; T second; public: T sum() const { return first second; } // 增加特殊方法 }; // 偏特化特化為指針類型 template typename T, typename U class MyPairT*, U* { T* first; U* second; public: // 可能提供針對指針的特殊操作比如判空 }; MyPairint, double p1; // 使用主模板 MyPairint, int p2; // 使用偏特化版本 MyPairint, int它有sum()方法 MyPairint*, double* p3; // 使用指針偏特化版本偏特化在元編程和類型萃取中極其重要是構(gòu)建復(fù)雜編譯期邏輯的基礎(chǔ)。3.4 模板與友元、靜態(tài)成員友元在類模板中聲明友元語法有點繞。template typename U class OtherClass; // 前向聲明 template typename T class MyClass { private: T secret; public: // 聲明一個特定實例化的OtherClass是友元 friend class OtherClassT; // 聲明所有實例化的OtherClass都是友元慎用 template typename U friend class OtherClass; };靜態(tài)成員類模板的每個實例化如MyClassint,MyClassdouble都擁有自己獨立的一份靜態(tài)成員副本。template typename T class Counter { public: static int count; // 聲明 Counter() { count; } ~Counter() { --count; } }; // 定義并初始化靜態(tài)成員必須對每個用到的類型進(jìn)行定義 template typename T int CounterT::count 0; Counterint a, b; // Counterint::count 現(xiàn)在是 2 Counterdouble c; // Counterdouble::count 是 1和上面的count不是同一個變量4. 深入模板元編程非類型參數(shù)與模板的更多玩法模板的能力遠(yuǎn)不止參數(shù)化類型。它還可以參數(shù)化值非類型參數(shù)這打開了編譯期計算的大門。4.1 非類型模板參數(shù)非類型模板參數(shù)必須是編譯期常量包括整型、枚舉、指針指向靜態(tài)存儲期的對象、引用等。// 一個固定大小的數(shù)組類大小是編譯期確定的 template typename T, std::size_t N class FixedArray { private: T data[N]; // 棧上數(shù)組大小固定 public: constexpr std::size_t size() const { return N; } T operator[](std::size_t idx) { return data[idx]; } }; FixedArrayint, 10 arr10; // 一個包含10個int的數(shù)組 FixedArraydouble, 100 arr100; // 一個包含100個double的數(shù)組 // FixedArrayint, n arr; // 錯誤n必須是編譯期常量經(jīng)典應(yīng)用編譯期階乘計算template int N struct Factorial { static const int value N * FactorialN - 1::value; }; // 特化遞歸基 template struct Factorial0 { static const int value 1; }; int main() { std::cout Factorial5::value; // 輸出 120在編譯期就計算好了 return 0; }這個Factorial5::value在編譯時就已經(jīng)被替換成字面量120運行時沒有任何計算開銷。這就是模板元編程的雛形。4.2 變參模板處理任意數(shù)量參數(shù)C11引入了變參模板可以接受任意數(shù)量、任意類型的參數(shù)包。這是實現(xiàn)std::tuple,std::function等高級設(shè)施的基礎(chǔ)。// 遞歸展開參數(shù)包打印所有參數(shù)需要遞歸終止函數(shù) void print() { // 終止函數(shù)處理空包 std::cout end std::endl; } template typename T, typename... Args // Args是一個模板參數(shù)包 void print(T first, Args... args) { // args是一個函數(shù)參數(shù)包 std::cout first ; print(args...); // 遞歸調(diào)用展開參數(shù)包 } int main() { print(1, 2.5, hello, a); // 輸出1 2.5 hello a end return 0; }折疊表達(dá)式C17提供了更簡潔的展開方式。template typename... Args auto sum(Args... args) { return (args ...); // 折疊表達(dá)式展開為 args1 args2 ... }4.3 SFINAE與std::enable_if基于類型的編譯期分支SFINAESubstitution Failure Is Not An Error是模板元編程的核心規(guī)則之一。簡單說就是在模板參數(shù)推導(dǎo)/替換時如果失敗了編譯器不會報錯而是簡單地忽略這個候選繼續(xù)嘗試其他重載。利用這個特性我們可以控制模板在什么條件下可用。std::enable_if是常用的工具。// 只有T是整數(shù)類型時這個函數(shù)才參與重載 template typename T typename std::enable_ifstd::is_integralT::value, void::type processInteger(T t) { std::cout Processing integer: t std::endl; } // 只有T是浮點類型時這個函數(shù)才參與重載 template typename T typename std::enable_ifstd::is_floating_pointT::value, void::type processFloat(T t) { std::cout Processing float: t std::endl; } processInteger(42); // 匹配第一個 processFloat(3.14); // 匹配第二個 // processInteger(3.14); // 編譯錯誤沒有匹配的函數(shù)C20引入了concepts可以更優(yōu)雅地實現(xiàn)這種約束但enable_if在舊代碼中依然非常常見。5. 實戰(zhàn)避坑與性能考量模板很強(qiáng)大但用不好也會帶來很多問題。下面是一些我踩過的坑和總結(jié)的經(jīng)驗。5.1 編譯時間膨脹與代碼膨脹每用一組新的模板參數(shù)實例化一個模板編譯器都會生成一份新的代碼。大量使用模板尤其是深度嵌套的模板會導(dǎo)致編譯時間急劇增加編譯器要做更多的工作。目標(biāo)文件體積變大生成的二進(jìn)制代碼冗余。緩解策略將非類型相關(guān)的代碼抽離到非模板基類或普通函數(shù)中。使用顯式實例化在.cpp文件中手動實例化你需要的特定類型然后阻止在其他翻譯單元中隱式實例化。// mytemplate.cpp #include mytemplate.h template class MyTemplateint; // 顯式實例化 template class MyTemplatedouble; // mytemplate.h template typename T class MyTemplate { ... }; extern template class MyTemplateint; // 外部實例化聲明告訴編譯器別處已定義 extern template class MyTemplatedouble;謹(jǐn)慎使用頭文件內(nèi)聯(lián)模板雖然方便但會擴(kuò)散到所有包含它的編譯單元。5.2 鏈接錯誤未定義的引用這是類模板分離編譯的經(jīng)典問題。因為模板代碼需要在編譯期看到完整定義所以通常將模板的聲明和定義都放在頭文件.hpp中。如果像普通類一樣把定義放在.cpp文件鏈接時會找不到符號。解決方案堅持“模板定義放在頭文件”的原則?；蛘呤褂蒙厦嫣岬降娘@式實例化。5.3 錯誤信息晦澀難懂模板相關(guān)的編譯錯誤可能是C里最令人崩潰的動輒幾十行、上百行核心錯誤淹沒在層層疊疊的實例化棧中。調(diào)試技巧從錯誤信息的最后幾行開始往前看通常第一行是根源。如果錯誤指向標(biāo)準(zhǔn)庫內(nèi)部很可能是因為你傳遞給模板的類型不支持某個操作比如沒有定義operator卻用在std::sort里。使用static_assert在模板內(nèi)部提供清晰的錯誤信息。template typename T class Container { static_assert(std::is_default_constructibleT::value, Container requires T to be default-constructible); // ... };5.4 類型推導(dǎo)的陷阱template typename T void func(T param) {} int arr[10]; func(arr); // T被推導(dǎo)為 int*而不是 int[10]數(shù)組退化為指針。 template typename T void func2(T param) {} func2(arr); // T被推導(dǎo)為 int[10], param類型是 int()[10]保留了數(shù)組大小信息。理解函數(shù)模板在按值、按引用、萬能引用等不同情況下的類型推導(dǎo)規(guī)則是寫出正確模板代碼的關(guān)鍵。Scott Meyers的《Effective Modern C》前幾章講得非常透徹。6. 現(xiàn)代C中的模板新特性auto,decltype與concepts現(xiàn)代CC11/14/17/20讓模板編程變得更簡單、更安全。6.1auto與decltype讓類型推導(dǎo)無處不在auto在模板編程中極大減少了冗余的類型書寫。// C98 template typename Iterator typename std::iterator_traitsIterator::value_type // 這行太長了 getFirst(Iterator begin, Iterator end) { return *begin; } // C11/14 使用 auto 和 decltype template typename Iterator auto getFirst(Iterator begin, Iterator end) - decltype(*begin) { // 尾返回類型 return *begin; } // C14 更簡單 template typename Iterator auto getFirst(Iterator begin, Iterator end) { return *begin; // 返回類型自動推導(dǎo) }decltype用于查詢表達(dá)式的類型在編寫泛型代碼時非常有用尤其是當(dāng)類型依賴于復(fù)雜的表達(dá)式時。6.2 C20concepts為模板參數(shù)戴上“緊箍咒”concepts是模板領(lǐng)域的革命性特性。它允許你為模板參數(shù)指定必須滿足的約束條件讓錯誤提前、讓代碼更清晰、讓編譯器錯誤信息更友好。// 定義一個概念要求類型T有size()成員函數(shù)且返回size_t template typename T concept HasSize requires(T t) { { t.size() } - std::convertible_tostd::size_t; }; // 使用概念約束模板 template HasSize Container void printSize(const Container c) { std::cout c.size() std::endl; } std::vectorint vec{1,2,3}; printSize(vec); // OK // printSize(42); // 編譯錯誤42不滿足HasSize概念相比于std::enable_if的“黑魔法”concepts的語法直觀得像在寫注釋極大地提升了模板代碼的可讀性和可維護(hù)性。泛型編程和模板是C從“帶類的C”升華為一門強(qiáng)大抽象語言的關(guān)鍵。初學(xué)時會覺得語法古怪、錯誤難懂但一旦掌握你就會發(fā)現(xiàn)它能讓你寫出極其靈活、高效且類型安全的代碼。我的建議是先從模仿STL的簡單用法開始寫一些自己的MyVector、MyAlgorithm在實踐中慢慢理解實例化、特化、SFINAE這些概念。記住好的抽象不是一次性寫出來的而是在不斷重構(gòu)和實踐中打磨出來的。當(dāng)你開始習(xí)慣用模板思維來設(shè)計接口和數(shù)據(jù)結(jié)構(gòu)時你會發(fā)現(xiàn)另一片廣闊的天地。