1. 從“能用”到“好用”成員函數(shù)模板與模板類繼承的進(jìn)階價(jià)值在C的日常開發(fā)中我們經(jīng)常會(huì)遇到一些看似“能用”但總覺得不夠優(yōu)雅或不夠通用的場(chǎng)景。比如你寫了一個(gè)容器類MyVector它有一個(gè)push_back方法可以接受int類型。后來(lái)你需要支持double于是你重載了一個(gè)push_back(double)。再后來(lái)你需要支持std::string、自定義的MyClass……代碼里很快就會(huì)出現(xiàn)一堆功能幾乎相同、只是參數(shù)類型不同的函數(shù)。這不僅是代碼冗余更是維護(hù)的噩夢(mèng)。另一種情況是你設(shè)計(jì)了一個(gè)基類模板BaseT希望派生出不同的子類但子類在處理某些操作時(shí)其邏輯可能與基類模板參數(shù)T不完全綁定或者需要引入新的類型維度。這時(shí)僅僅依靠普通的類模板繼承就會(huì)顯得力不從心。這正是成員函數(shù)模板和模板類繼承這兩個(gè)特性大顯身手的地方。它們解決的不僅僅是“能不能實(shí)現(xiàn)”的問題更是“如何實(shí)現(xiàn)得更優(yōu)雅、更通用、更符合現(xiàn)代C設(shè)計(jì)哲學(xué)”的問題。成員函數(shù)模板允許你在一個(gè)非模板類或類模板內(nèi)部定義一個(gè)參數(shù)獨(dú)立的函數(shù)模板從而實(shí)現(xiàn)“一次編寫支持無(wú)限類型”的泛化操作。而模板類的繼承則將面向?qū)ο蟮亩鄳B(tài)性與泛型編程的靈活性結(jié)合起來(lái)讓你可以構(gòu)建出層次分明、可擴(kuò)展性極強(qiáng)的類型體系。理解并熟練運(yùn)用這兩者尤其是它們的結(jié)合是區(qū)分普通C程序員和資深架構(gòu)師的一道分水嶺。接下來(lái)我將結(jié)合具體場(chǎng)景深入探討它們的原理、用法以及那些容易踩坑的細(xì)節(jié)。2. 成員函數(shù)模板為你的類注入泛型活力成員函數(shù)模板顧名思義就是在類無(wú)論是普通類還是類模板內(nèi)部定義的函數(shù)模板。它的模板參數(shù)獨(dú)立于其所屬類的模板參數(shù)如果類有的話。這賦予了單個(gè)成員函數(shù)超越其類本身類型限制的能力。2.1 基本語(yǔ)法與動(dòng)機(jī)讓我們從一個(gè)簡(jiǎn)單的“智能指針”雛形開始看看為什么需要成員函數(shù)模板。// 一個(gè)簡(jiǎn)單的、僅支持int的“智能指針” class IntPointer { public: IntPointer(int* p) : ptr(p) {} ~IntPointer() { delete ptr; } // 獲取原始指針 - 只返回int* int* get() const { return ptr; } private: int* ptr; };這個(gè)類只能管理int*。如果我們想管理double*就得再寫一個(gè)DoublePointer。這顯然不理想。我們首先想到的是使用類模板template typename T class BasicPointer { public: BasicPointer(T* p) : ptr(p) {} ~BasicPointer() { delete ptr; } T* get() const { return ptr; } private: T* ptr; }; // 使用 BasicPointerint ip(new int(42)); BasicPointerdouble dp(new double(3.14));現(xiàn)在BasicPointer可以管理任意類型的指針了。但是考慮一個(gè)常見的需求指針類型轉(zhuǎn)換。比如我們有一個(gè)BasicPointerDerived想將其轉(zhuǎn)換為BasicPointerBase假設(shè)Derived公有繼承自Base。我們可能希望提供一個(gè)轉(zhuǎn)換構(gòu)造函數(shù)或轉(zhuǎn)換函數(shù)。沒有成員函數(shù)模板的笨拙實(shí)現(xiàn)template typename T class BasicPointer { public: // ... 其他成員同上 ... // 嘗試為特定的基類-派生類關(guān)系提供構(gòu)造函數(shù)不通用且繁瑣 template typename U BasicPointer(const BasicPointerU other) { // 這個(gè)想法很好但我們需要判斷 U* 是否能轉(zhuǎn)換為 T* // 并且這個(gè)構(gòu)造函數(shù)本身不是成員函數(shù)模板嗎不它已經(jīng)是了 // 實(shí)際上這就是成員函數(shù)模板構(gòu)造函數(shù)模板的用武之地。 } };上面的注釋點(diǎn)出了關(guān)鍵我們需要一個(gè)構(gòu)造函數(shù)模板它接受另一個(gè)BasicPointerU但僅當(dāng)U*能安全轉(zhuǎn)換為T*時(shí)才有效。這正是成員函數(shù)模板的典型應(yīng)用。2.2 實(shí)現(xiàn)支持安全轉(zhuǎn)換的智能指針讓我們用成員函數(shù)模板來(lái)實(shí)現(xiàn)一個(gè)更完善的、支持轉(zhuǎn)換的SimplePtr。template typename T class SimplePtr { public: // 普通構(gòu)造函數(shù) explicit SimplePtr(T* p nullptr) : ptr(p) {} // 關(guān)鍵成員函數(shù)模板 - 轉(zhuǎn)換構(gòu)造函數(shù) // 它允許從 SimplePtrU 構(gòu)造 SimplePtrT template typename U SimplePtr(const SimplePtrU other) : ptr(other.get()) { // 這里發(fā)生了一個(gè)隱式轉(zhuǎn)換U* - T* // 這個(gè)轉(zhuǎn)換是否安全由編譯器在實(shí)例化時(shí)根據(jù)類型關(guān)系判斷。 // 例如如果 U 是 Derived T 是 Base且是公有繼承則轉(zhuǎn)換安全。 // 如果無(wú)關(guān)則編譯錯(cuò)誤。 } // 同樣賦值運(yùn)算符也可以做成模板 template typename U SimplePtr operator(const SimplePtrU other) { if (this ! static_castconst void*(other)) { // 注意這里類型不同不能直接比較地址 delete ptr; ptr other.get(); } return *this; } ~SimplePtr() { delete ptr; } // 提供get函數(shù)供轉(zhuǎn)換構(gòu)造函數(shù)使用 T* get() const { return ptr; } // 解引用運(yùn)算符 T operator*() const { return *ptr; } T* operator-() const { return ptr; } private: T* ptr; }; // 示例類層次 class Base { public: virtual void print() const { std::cout Base\n; } virtual ~Base() default; }; class Derived : public Base { public: void print() const override { std::cout Derived\n; } }; int main() { SimplePtrDerived dPtr(new Derived); dPtr-print(); // 輸出: Derived // 關(guān)鍵用法利用成員函數(shù)模板構(gòu)造函數(shù)進(jìn)行轉(zhuǎn)換 SimplePtrBase bPtr dPtr; // 調(diào)用 SimplePtrBase::SimplePtr(const SimplePtrDerived) bPtr-print(); // 輸出: Derived (多態(tài)行為保持) // 錯(cuò)誤示例無(wú)關(guān)類型轉(zhuǎn)換將導(dǎo)致編譯錯(cuò)誤 // SimplePtrint iPtr(new int(10)); // SimplePtrBase errorPtr iPtr; // 錯(cuò)誤無(wú)法從 int* 轉(zhuǎn)換為 Base* }核心要點(diǎn)解析template typename U SimplePtr(const SimplePtrU other)這是一個(gè)成員函數(shù)模板具體是構(gòu)造函數(shù)模板。它的模板參數(shù)U獨(dú)立于類模板參數(shù)T。安全轉(zhuǎn)換保障在ptr(other.get())初始化列表中發(fā)生了U*到T*的轉(zhuǎn)換。這個(gè)轉(zhuǎn)換是否合法由C的類型系統(tǒng)在編譯期檢查。如果U和T無(wú)關(guān)或者繼承關(guān)系不是公有的對(duì)于指針向下/向上轉(zhuǎn)換編譯器會(huì)報(bào)錯(cuò)。這利用了C內(nèi)置的指針轉(zhuǎn)換規(guī)則比運(yùn)行時(shí)檢查更安全、高效。實(shí)現(xiàn)賦值運(yùn)算符模板同理我們可以實(shí)現(xiàn)泛型的賦值運(yùn)算符使得SimplePtrT可以從SimplePtrU賦值。get()成員函數(shù)的作用為了讓轉(zhuǎn)換構(gòu)造函數(shù)能夠訪問other對(duì)象的內(nèi)部指針我們提供了get()這個(gè)公共接口。這是一種常見的模式在實(shí)現(xiàn)諸如智能指針的轉(zhuǎn)換時(shí)非常有用。注意上面的實(shí)現(xiàn)為了清晰省略了移動(dòng)語(yǔ)義、自定義刪除器等現(xiàn)代智能指針的必要特性。在實(shí)際項(xiàng)目中請(qǐng)直接使用std::unique_ptr或std::shared_ptr它們內(nèi)部正是利用成員函數(shù)模板實(shí)現(xiàn)了類似的轉(zhuǎn)換功能如std::unique_ptrDerived到std::unique_ptrBase的轉(zhuǎn)換。2.3 在非模板類中使用成員函數(shù)模板成員函數(shù)模板并非類模板的專屬。在普通類中它同樣可以發(fā)揮巨大作用用于創(chuàng)建泛型的工具函數(shù)。// 一個(gè)負(fù)責(zé)數(shù)據(jù)序列化的工具類非模板類 class Serializer { public: Serializer() default; // 成員函數(shù)模板將任意算術(shù)類型轉(zhuǎn)換為字符串 template typename T, typename std::enable_if_tstd::is_arithmetic_vT std::string toString(const T value) const { return std::to_string(value); } // 成員函數(shù)模板將字符串轉(zhuǎn)換為任意算術(shù)類型 template typename T, typename std::enable_if_tstd::is_arithmetic_vT T fromString(const std::string str) const { if constexpr (std::is_same_vT, int) { return std::stoi(str); } else if constexpr (std::is_same_vT, double) { return std::stod(str); } else if constexpr (std::is_same_vT, long long) { return std::stoll(str); } // ... 其他類型的處理 else { // 對(duì)于不直接支持的類型可以拋出異?；蜢o態(tài)斷言 static_assert(sizeof(T) 0, Unsupported type for fromString); return T{}; } } // 一個(gè)更通用的“克隆”函數(shù)要求類型T可拷貝構(gòu)造 template typename T T clone(const T obj) const { return T(obj); // 調(diào)用拷貝構(gòu)造函數(shù) } }; int main() { Serializer ser; auto intStr ser.toString(100); // 實(shí)例化 toStringint auto doubleStr ser.toString(3.14159); // 實(shí)例化 toStringdouble int i ser.fromStringint(42); double d ser.fromStringdouble(2.718); std::string original Hello; std::string copy ser.clone(original); // 實(shí)例化 clonestd::string }在這個(gè)例子中Serializer類本身不是模板但它通過(guò)成員函數(shù)模板toString和fromString提供了處理多種算術(shù)類型的通用接口。這避免了為int,double,float等類型分別編寫重載函數(shù)極大地減少了代碼重復(fù)。使用std::enable_if進(jìn)行約束在toString和fromString中我們使用了std::enable_if_t和std::is_arithmetic_v來(lái)約束模板參數(shù)T必須是算術(shù)類型。這是一種SFINAE替換失敗不是錯(cuò)誤技術(shù)確保這些函數(shù)模板只對(duì)符合條件的類型參與重載決議防止用戶誤用。這是編寫健壯的成員函數(shù)模板時(shí)常用的技巧。3. 模板類的繼承構(gòu)建泛型層次結(jié)構(gòu)當(dāng)類模板遇到繼承時(shí)情況變得有趣且復(fù)雜。模板類的繼承允許我們創(chuàng)建基于類型參數(shù)的類層次結(jié)構(gòu)這在設(shè)計(jì)泛型庫(kù)、框架時(shí)至關(guān)重要。3.1 基本語(yǔ)法與“模板參數(shù)傳遞”最簡(jiǎn)單的形式是一個(gè)類模板繼承自另一個(gè)類模板。template typename T class Base { public: Base(T val) : data(val) {} void print() const { std::cout Base data: data std::endl; } protected: T data; }; // Derived1 繼承自 Baseint是一個(gè)特化版本的Base class Derived1 : public Baseint { public: Derived1(int val, double extra) : Base(val), extraData(extra) {} void show() const { print(); std::cout Derived1 extra: extraData std::endl; } private: double extraData; }; // Derived2 是一個(gè)類模板它繼承自另一個(gè)類模板 BaseT template typename T class Derived2 : public BaseT { // 注意這里使用 BaseT public: Derived2(T val, const std::string name) : BaseT(val), tag(name) {} void display() const { this-print(); // 注意這里使用了 this- std::cout Derived2 tag: tag std::endl; } private: std::string tag; }; int main() { Derived1 d1(10, 20.5); d1.show(); Derived2double d2(3.14, Pi); d2.display(); Derived2std::string d3(Hello, Greeting); d3.display(); }關(guān)鍵點(diǎn)分析Derived1這是一個(gè)普通類它繼承自一個(gè)完全特化的類模板Baseint。這意味著Derived1的基類部分類型是確定的Baseint。Derived2這是一個(gè)類模板。它的繼承關(guān)系是Derived2T : public BaseT。這意味著對(duì)于每一個(gè)Derived2的實(shí)例化類型T它都繼承自對(duì)應(yīng)T類型的Base特化。這是一種“模板參數(shù)傳遞”是構(gòu)建泛型層次結(jié)構(gòu)的基礎(chǔ)。訪問基類成員在Derived2::display()中我們調(diào)用this-print()而不是直接調(diào)用print()。這是因?yàn)樵谀０孱愔谢怋aseT是一個(gè)依賴基類它的類型依賴于模板參數(shù)T。在非依賴名稱查找階段編譯器無(wú)法確定BaseT中是否一定有print成員因?yàn)榭赡艽嬖贐ase的特化版本沒有print。使用this-或BaseT::前綴可以將print變?yōu)橐蕾嚸Q從而將查找推遲到實(shí)例化階段確保能找到正確的成員。這是模板類繼承中一個(gè)極易出錯(cuò)的地方。3.2 處理依賴基類與名稱查找的兩階段讓我們深入看看這個(gè)坑。假設(shè)我們稍微修改一下Basetemplate typename T class Base { public: Base(T val) : data(val) {} // void print() const { std::cout Base data: data std::endl; } // 注釋掉print protected: T data; }; template typename T class Derived2 : public BaseT { public: Derived2(T val, const std::string name) : BaseT(val), tag(name) {} void display() const { // 錯(cuò)誤對(duì)非依賴名稱 ‘print’ 的查找在定義點(diǎn)完成此時(shí)BaseT中無(wú)print。 // print(); // 方法1使用 this-將 print 變?yōu)橐蕾嚸Q this-print(); // 編譯錯(cuò)誤會(huì)推遲到實(shí)例化時(shí)如果BaseT真的沒有print則報(bào)錯(cuò)。 // 方法2使用 using 聲明引入基類作用域 // using BaseT::print; // print(); // 方法3顯式使用作用域運(yùn)算符 // BaseT::print(); std::cout Derived2 tag: tag std::endl; } private: std::string tag; };當(dāng)Derived2int被實(shí)例化時(shí)編譯器會(huì)嘗試查找this-print。由于Baseint中沒有print成員此時(shí)才會(huì)產(chǎn)生編譯錯(cuò)誤。這種兩階段查找定義點(diǎn)查找非依賴名稱實(shí)例化點(diǎn)查找依賴名稱是C模板元編程的核心機(jī)制之一。最佳實(shí)踐在模板派生類中訪問基類成員時(shí)養(yǎng)成使用this-或BaseT::的習(xí)慣可以避免很多令人困惑的編譯錯(cuò)誤。3.3 結(jié)合成員函數(shù)模板與模板類繼承當(dāng)成員函數(shù)模板遇上模板類繼承我們可以設(shè)計(jì)出極其靈活和強(qiáng)大的組件。考慮一個(gè)更復(fù)雜的例子一個(gè)泛型的“工廠”基類模板其子類可以通過(guò)成員函數(shù)模板來(lái)注冊(cè)不同類型的創(chuàng)建器。#include iostream #include string #include map #include memory #include functional // 基類泛型工廠 template typename BaseProductType class GenericFactory { public: using Creator std::functionstd::unique_ptrBaseProductType(); // 注冊(cè)創(chuàng)建函數(shù) - 成員函數(shù)模板 // 可以注冊(cè)任何返回 std::unique_ptrDerived 的函數(shù)其中 Derived 繼承自 BaseProductType template typename DerivedType bool registerCreator(const std::string key) { // 約束DerivedType 必須是 BaseProductType 的派生類 static_assert(std::is_base_of_vBaseProductType, DerivedType, DerivedType must be derived from BaseProductType); auto [it, inserted] creators_.emplace(key, []() - std::unique_ptrBaseProductType { return std::make_uniqueDerivedType(); }); return inserted; } // 創(chuàng)建產(chǎn)品 std::unique_ptrBaseProductType create(const std::string key) const { auto it creators_.find(key); if (it ! creators_.end()) { return it-second(); // 調(diào)用創(chuàng)建函數(shù) } return nullptr; } private: std::mapstd::string, Creator creators_; }; // 產(chǎn)品基類 class Shape { public: virtual void draw() const 0; virtual ~Shape() default; }; // 具體產(chǎn)品 class Circle : public Shape { public: void draw() const override { std::cout Drawing a Circle.\n; } }; class Square : public Shape { public: void draw() const override { std::cout Drawing a Square.\n; } }; int main() { GenericFactoryShape shapeFactory; // 使用成員函數(shù)模板注冊(cè)無(wú)需為每個(gè)DerivedType寫重載 shapeFactory.registerCreatorCircle(circle); shapeFactory.registerCreatorSquare(square); auto circle shapeFactory.create(circle); auto square shapeFactory.create(square); auto unknown shapeFactory.create(triangle); // 返回 nullptr if (circle) circle-draw(); if (square) square-draw(); if (!unknown) std::cout Creator not found.\n; }設(shè)計(jì)精妙之處GenericFactory是類模板其模板參數(shù)BaseProductType是產(chǎn)品體系的基類。registerCreator是成員函數(shù)模板它的模板參數(shù)DerivedType是具體的產(chǎn)品類型。通過(guò)std::is_base_of_v進(jìn)行編譯期檢查確保類型安全。Lambda 表達(dá)式的類型轉(zhuǎn)換在注冊(cè)時(shí)我們存儲(chǔ)一個(gè)返回std::unique_ptrBaseProductType的Creator。Lambda[]() { return std::make_uniqueDerivedType(); }原本返回std::unique_ptrDerivedType但因?yàn)樗梢噪[式轉(zhuǎn)換為std::unique_ptrBaseProductType得益于unique_ptr的轉(zhuǎn)換構(gòu)造函數(shù)其內(nèi)部也使用了成員函數(shù)模板技術(shù)所以存儲(chǔ)成功。高度解耦與擴(kuò)展性要新增一種Shape只需定義新的派生類然后調(diào)用registerCreatorNewShape(key)即可。工廠基類GenericFactory完全不需要修改。這完美符合開閉原則。這個(gè)例子展示了成員函數(shù)模板如何與模板類繼承協(xié)同工作創(chuàng)建一個(gè)既類型安全又極其靈活的泛型框架。registerCreator這個(gè)成員函數(shù)模板是連接泛型工廠基類和具體產(chǎn)品派生類的橋梁。4. 深入陷阱與高級(jí)模式掌握了基本用法后我們來(lái)看看一些更復(fù)雜、更容易出錯(cuò)的情況和高級(jí)技巧。4.1 派生類中的成員函數(shù)模板與基類函數(shù)的重載/隱藏當(dāng)派生類定義了與基類同名的成員函數(shù)模板時(shí)會(huì)發(fā)生什么class Base { public: void func(int) { std::cout Base::func(int)\n; } template typename T void func(T) { std::cout Base::func(T)\n; } // 基類也有成員函數(shù)模板 }; class Derived : public Base { public: // 情況1派生類定義普通成員函數(shù)隱藏基類同名函數(shù) void func(double) { std::cout Derived::func(double)\n; } // 此時(shí)Base::func(int) 和 Base::funcT(T) 都被隱藏了除非使用 using 聲明。 // 情況2派生類定義成員函數(shù)模板 template typename U void func(U) { std::cout Derived::func(U)\n; } // 這會(huì)隱藏基類中所有名為 func 的函數(shù)包括模板和非模板。 }; int main() { Derived d; d.func(10); // 調(diào)用 Derived::funcint(int)輸出 Derived::func(U) d.func(3.14); // 調(diào)用 Derived::funcdouble(double)輸出 Derived::func(U) d.func(a); // 調(diào)用 Derived::funcchar(char)輸出 Derived::func(U) // 如何調(diào)用基類的 func d.Base::func(10); // 顯式調(diào)用輸出 Base::func(int) 還是 Base::func(T) // 實(shí)際上會(huì)調(diào)用 Base::func(int)因?yàn)榫_匹配 int 參數(shù)。 d.Base::func(3.14); // 顯式調(diào)用輸出 Base::func(T) (T被推導(dǎo)為double) }規(guī)則總結(jié)派生類中定義的名稱包括函數(shù)模板會(huì)隱藏基類中所有同名的名稱無(wú)論參數(shù)是否匹配也無(wú)論是否是模板。如果要讓基類的重載函數(shù)/函數(shù)模板在派生類作用域中可見需要在派生類中使用using Base::func;聲明。成員函數(shù)模板也參與重載決議。當(dāng)調(diào)用發(fā)生時(shí)編譯器會(huì)在可見的函數(shù)集合包括普通函數(shù)和函數(shù)模板中選擇最佳匹配。4.2 模板類繼承中的虛函數(shù)與成員函數(shù)模板的沖突這是一個(gè)重要的限制成員函數(shù)模板不能是虛函數(shù)。class Base { public: // 錯(cuò)誤成員模板不能是虛函數(shù) template typename T virtual void process(T value) 0; };為什么虛函數(shù)機(jī)制依賴于虛函數(shù)表vtable每個(gè)有虛函數(shù)的類都有一個(gè) vtable其中包含了指向該類各個(gè)虛函數(shù)實(shí)現(xiàn)的指針。vtable 的大小和布局在編譯時(shí)就需要確定。而成員函數(shù)模板則意味著在編譯器看到類定義時(shí)并不知道會(huì)有多少個(gè)process函數(shù)的實(shí)例processint,processdouble,processMyClass...。這會(huì)導(dǎo)致 vtable 的大小無(wú)法確定破壞了C對(duì)象模型的根基。解決方案如果需要在繼承體系中實(shí)現(xiàn)基于類型的多態(tài)通常采用以下模式之一類型擦除Type Erasure如std::function內(nèi)部使用模板構(gòu)造函數(shù)和虛函數(shù)來(lái)實(shí)現(xiàn)。雙重分發(fā)Double Dispatch或訪問者模式Visitor Pattern。在基類中定義非模板的虛函數(shù)接口在派生類中實(shí)現(xiàn)具體操作該操作內(nèi)部可以調(diào)用模板函數(shù)。// 解決方案示例基類非模板虛函數(shù) 派生類模板輔助函數(shù) class Base { public: virtual ~Base() default; virtual void processInt(int) 0; virtual void processDouble(double) 0; // 或者使用一個(gè)統(tǒng)一的接口傳入類型標(biāo)識(shí)和void*但類型不安全。 }; template typename T class Derived : public Base { public: void processInt(int val) override { processImpl(val); // 委托給模板函數(shù) } void processDouble(double val) override { processImpl(val); } private: // 私有的成員函數(shù)模板實(shí)現(xiàn)具體處理邏輯 template typename U void processImpl(U value) { std::cout Processing value of type typeid(U).name() : value std::endl; // ... 具體的處理邏輯 } };4.3 CRTP奇異遞歸模板模式與成員函數(shù)模板CRTP 是一種將繼承與模板結(jié)合的高級(jí)模式常用于靜態(tài)多態(tài)和代碼注入。成員函數(shù)模板在其中可以扮演關(guān)鍵角色。// CRTP 基類模板提供對(duì)象計(jì)數(shù)功能 template typename Derived class ObjectCounter { protected: ObjectCounter() { count_; } ObjectCounter(const ObjectCounter) { count_; } ObjectCounter(ObjectCounter) noexcept { count_; } ~ObjectCounter() { --count_; } public: // 成員函數(shù)模板返回計(jì)數(shù)支持任何可轉(zhuǎn)換為 size_t 的類型 // 實(shí)際上這里更適合用靜態(tài)成員函數(shù)。 static size_t getCount() { return count_; } // 一個(gè)更通用的“打印信息”模板函數(shù)演示成員函數(shù)模板在CRTP中的使用 template typename Stream void printInfo(Stream os) const { os Class: typeid(Derived).name() , Instance count: getCount() \n; } private: inline static size_t count_ 0; // C17 內(nèi)聯(lián)靜態(tài)成員變量 }; // 具體類使用 CRTP class MyClass : public ObjectCounterMyClass { public: int value; MyClass(int v) : value(v) {} // 可以添加自己的成員函數(shù)模板 template typename T T convertTo() const { // 假設(shè)一些轉(zhuǎn)換邏輯這里簡(jiǎn)單返回T類型的默認(rèn)值 return static_castT(value); } }; class AnotherClass : public ObjectCounterAnotherClass {}; int main() { MyClass a(10), b(20); AnotherClass c; std::cout MyClass count: MyClass::getCount() std::endl; // 2 std::cout AnotherClass count: AnotherClass::getCount() std::endl; // 1 a.printInfo(std::cout); // 調(diào)用從CRTP基類繼承的成員函數(shù)模板 double d a.convertTodouble(); // 調(diào)用派生類自己的成員函數(shù)模板 std::cout Converted value: d std::endl; }在CRTP中基類ObjectCounterDerived通過(guò)模板參數(shù)Derived知道派生類的類型。這使得基類可以在編譯時(shí)使用typeid(Derived).name()或調(diào)用派生類的靜態(tài)方法如果存在?；愔械膒rintInfo是一個(gè)成員函數(shù)模板它接受任何輸出流類型提供了靈活性。同時(shí)派生類MyClass也可以定義自己的成員函數(shù)模板convertTo。CRTP模式結(jié)合成員函數(shù)模板能夠創(chuàng)造出非常靈活和高效的靜態(tài)多態(tài)結(jié)構(gòu)。5. 實(shí)戰(zhàn)構(gòu)建一個(gè)支持迭代器適配的泛型容器包裝器讓我們用一個(gè)綜合性的例子來(lái)結(jié)束本文設(shè)計(jì)一個(gè)ContainerWrapper它可以包裝任何符合標(biāo)準(zhǔn)容器接口提供begin(),end()的容器并為其添加一些通用的成員函數(shù)模板操作比如filter,transform等類似簡(jiǎn)陋版的 ranges 適配器。同時(shí)我們將使用模板類繼承來(lái)提供一個(gè)特化版本。#include iostream #include vector #include list #include algorithm #include type_traits // 主模板容器包裝器 template typename Container class ContainerWrapper { public: using value_type typename Container::value_type; using iterator typename Container::iterator; using const_iterator typename Container::const_iterator; ContainerWrapper(Container c) : container_(c) {} // 提供迭代器接口 iterator begin() { return container_.begin(); } iterator end() { return container_.end(); } const_iterator begin() const { return container_.begin(); } const_iterator end() const { return container_.end(); } // 成員函數(shù)模板1過(guò)濾返回新容器 template typename Predicate auto filter(Predicate pred) const { // 推導(dǎo)返回的容器類型與原容器相同 Container result; std::copy_if(container_.begin(), container_.end(), std::back_inserter(result), pred); return ContainerWrapperContainer(result); // 返回新的包裝器 } // 成員函數(shù)模板2轉(zhuǎn)換返回另一種類型的容器包裝器 template typename UnaryOp auto transform(UnaryOp op) const { // 推導(dǎo)新容器的 value_type using new_value_type decltype(op(*container_.begin())); // 使用與原容器同類型的容器來(lái)存儲(chǔ)結(jié)果例如 vector - vector std::vectornew_value_type result; result.reserve(container_.size()); std::transform(container_.begin(), container_.end(), std::back_inserter(result), op); // 注意返回的是 ContainerWrapperstd::vectornew_value_type // 這可能與原始容器類型不同。 return ContainerWrapperdecltype(result)(result); } // 一個(gè)通用的“應(yīng)用函數(shù)到每個(gè)元素”的模板 template typename Func void for_each(Func f) { for (auto elem : container_) { f(elem); } } protected: Container container_; }; // 特化/派生版本針對(duì) std::vector 的包裝器添加額外功能 template typename T class VectorWrapper : public ContainerWrapperstd::vectorT { using Base ContainerWrapperstd::vectorT; public: VectorWrapper(std::vectorT vec) : Base(vec) {} // 利用成員函數(shù)模板添加 vector 特有的操作比如批量賦值 template typename InputIt void assign(InputIt first, InputIt last) { this-container_.assign(first, last); // 注意使用 this- } // 添加一個(gè)安全的 at() 訪問返回可選類型模擬 template typename Index std::optionalT safe_at(Index idx) const { if (idx 0 static_castsize_t(idx) this-container_.size()) { return this-container_[idx]; } return std::nullopt; } }; // 一個(gè)簡(jiǎn)單的打印輔助函數(shù)模板非成員 template typename Wrapper void printWrapper(const Wrapper w) { for (const auto elem : w) { std::cout elem ; } std::cout \n; } int main() { std::vectorint vec {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; std::listdouble lst {1.1, 2.2, 3.3, 4.4}; // 使用通用包裝器 ContainerWrapper vecWrap(vec); ContainerWrapper lstWrap(lst); std::cout Original vector: ; printWrapper(vecWrap); // 使用成員函數(shù)模板 filter auto evenWrap vecWrap.filter([](int x) { return x % 2 0; }); std::cout Even numbers: ; printWrapper(evenWrap); // 使用成員函數(shù)模板 transform auto squaredWrap vecWrap.transform([](int x) { return x * x; }); std::cout Squared numbers (as double): ; // squaredWrap 包裝的是 std::vectorint因?yàn)?op 返回 int printWrapper(squaredWrap); // 使用派生類 VectorWrapper VectorWrapper vecWrapSpecial(vec); std::vectorint newData {100, 200, 300}; // 使用成員函數(shù)模板 assign vecWrapSpecial.assign(newData.begin(), newData.end()); std::cout After assign: ; printWrapper(vecWrapSpecial); // 使用成員函數(shù)模板 safe_at if (auto val vecWrapSpecial.safe_at(1)) { std::cout Element at index 1: *val std::endl; } if (auto val vecWrapSpecial.safe_at(10)) { // 越界 std::cout This wont print\n; } else { std::cout Index 10 is out of range.\n; } }這個(gè)實(shí)戰(zhàn)案例的精髓ContainerWrapper是類模板它接受任何容器類型Container。豐富的成員函數(shù)模板filter接受一個(gè)謂詞Predicate返回一個(gè)包含過(guò)濾后元素的新ContainerWrapper。注意它返回的是同類型容器的包裝器。transform接受一個(gè)一元操作UnaryOp返回一個(gè)包裝了std::vectornew_value_type的ContainerWrapper。這里展示了成員函數(shù)模板可以改變返回的容器類型非常靈活。for_each對(duì)每個(gè)元素應(yīng)用一個(gè)函數(shù)。模板類繼承VectorWrapper繼承自ContainerWrapperstd::vectorT。它特化了對(duì)于std::vector的包裝并添加了assign和safe_at這兩個(gè)額外的成員函數(shù)模板。assign模板可以接受任何輸入迭代器范圍。safe_at模板接受任何可轉(zhuǎn)換為整型的索引類型并返回std::optional提供安全訪問。依賴基類名稱訪問在VectorWrapper中我們使用this-container_來(lái)訪問基類的受保護(hù)成員container_這是處理依賴基類名稱的標(biāo)準(zhǔn)做法。編譯時(shí)多態(tài)與靈活性整個(gè)設(shè)計(jì)沒有使用任何虛函數(shù)所有多態(tài)行為如filter對(duì)vector和list的操作都在編譯時(shí)通過(guò)模板實(shí)例化確定效率極高。通過(guò)這個(gè)例子你可以看到成員函數(shù)模板如何為泛型類添加無(wú)限可能的算法操作而模板類繼承又如何讓我們可以針對(duì)特定類型進(jìn)行特化和功能增強(qiáng)。這兩者結(jié)合是構(gòu)建現(xiàn)代C泛型庫(kù)的強(qiáng)大工具。