1. 從“能用”到“好用”成員函數(shù)模板與模板類繼承的進(jìn)階價(jià)值在C的日常開發(fā)中我們經(jīng)常會遇到一些看似“能用”但總覺得不夠優(yōu)雅或不夠通用的場景。比如你寫了一個(gè)容器類MyVector它有一個(gè)push_back方法可以接受int類型。后來你需要支持double于是你重載了一個(gè)push_back(double)。再后來你需要支持std::string、自定義的MyClass……代碼里很快就會出現(xiàn)一堆功能幾乎相同、只是參數(shù)類型不同的函數(shù)。這不僅是代碼冗余更是維護(hù)的噩夢。另一種情況是你設(shè)計(jì)了一個(gè)基類模板BaseT希望派生出不同的子類但子類在處理某些操作時(shí)其邏輯可能與基類模板參數(shù)T不完全綁定或者需要引入新的類型維度。這時(shí)僅僅依靠普通的類模板繼承就會顯得力不從心。這正是成員函數(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)“一次編寫支持無限類型”的泛化操作。而模板類的繼承則將面向?qū)ο蟮亩鄳B(tài)性與泛型編程的靈活性結(jié)合起來讓你可以構(gòu)建出層次分明、可擴(kuò)展性極強(qiáng)的類型體系。理解并熟練運(yùn)用這兩者尤其是它們的結(jié)合是區(qū)分普通C程序員和資深架構(gòu)師的一道分水嶺。接下來我將結(jié)合具體場景深入探討它們的原理、用法以及那些容易踩坑的細(xì)節(jié)。2. 成員函數(shù)模板為你的類注入泛型活力成員函數(shù)模板顧名思義就是在類無論是普通類還是類模板內(nèi)部定義的函數(shù)模板。它的模板參數(shù)獨(dú)立于其所屬類的模板參數(shù)如果類有的話。這賦予了單個(gè)成員函數(shù)超越其類本身類型限制的能力。2.1 基本語法與動機(jī)讓我們從一個(gè)簡單的“智能指針”雛形開始看看為什么需要成員函數(shù)模板。// 一個(gè)簡單的、僅支持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ù)模板來實(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)換安全。 // 如果無關(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ò)誤示例無關(guān)類型轉(zhuǎn)換將導(dǎo)致編譯錯(cuò)誤 // SimplePtrint iPtr(new int(10)); // SimplePtrBase errorPtr iPtr; // 錯(cuò)誤無法從 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無關(guān)或者繼承關(guān)系不是公有的對于指針向下/向上轉(zhuǎn)換編譯器會報(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對象的內(nèi)部指針我們提供了get()這個(gè)公共接口。這是一種常見的模式在實(shí)現(xiàn)諸如智能指針的轉(zhuǎn)換時(shí)非常有用。注意上面的實(shí)現(xiàn)為了清晰省略了移動語義、自定義刪除器等現(xiàn)代智能指針的必要特性。在實(shí)際項(xià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 { // 對于不直接支持的類型可以拋出異?；蜢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類本身不是模板但它通過成員函數(shù)模板toString和fromString提供了處理多種算術(shù)類型的通用接口。這避免了為int,double,float等類型分別編寫重載函數(shù)極大地減少了代碼重復(fù)。使用std::enable_if進(jìn)行約束在toString和fromString中我們使用了std::enable_if_t和std::is_arithmetic_v來約束模板參數(shù)T必須是算術(shù)類型。這是一種SFINAE替換失敗不是錯(cuò)誤技術(shù)確保這些函數(shù)模板只對符合條件的類型參與重載決議防止用戶誤用。這是編寫健壯的成員函數(shù)模板時(shí)常用的技巧。3. 模板類的繼承構(gòu)建泛型層次結(jié)構(gòu)當(dāng)類模板遇到繼承時(shí)情況變得有趣且復(fù)雜。模板類的繼承允許我們創(chuàng)建基于類型參數(shù)的類層次結(jié)構(gòu)這在設(shè)計(jì)泛型庫、框架時(shí)至關(guān)重要。3.1 基本語法與“模板參數(shù)傳遞”最簡單的形式是一個(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。這意味著對于每一個(gè)Derived2的實(shí)例化類型T它都繼承自對應(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。在非依賴名稱查找階段編譯器無法確定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ò)誤對非依賴名稱 ‘print’ 的查找在定義點(diǎn)完成此時(shí)BaseT中無print。 // print(); // 方法1使用 this-將 print 變?yōu)橐蕾嚸Q this-print(); // 編譯錯(cuò)誤會推遲到實(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í)編譯器會嘗試查找this-print。由于Baseint中沒有print成員此時(shí)才會產(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è)泛型的“工廠”基類模板其子類可以通過成員函數(shù)模板來注冊不同類型的創(chuàng)建器。#include iostream #include string #include map #include memory #include functional // 基類泛型工廠 template typename BaseProductType class GenericFactory { public: using Creator std::functionstd::unique_ptrBaseProductType(); // 注冊創(chuàng)建函數(shù) - 成員函數(shù)模板 // 可以注冊任何返回 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ù)模板注冊無需為每個(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)品類型。通過std::is_base_of_v進(jìn)行編譯期檢查確保類型安全。Lambda 表達(dá)式的類型轉(zhuǎn)換在注冊時(shí)我們存儲一個(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ù)所以存儲成功。高度解耦與擴(kuò)展性要新增一種Shape只需定義新的派生類然后調(diào)用registerCreatorNewShape(key)即可。工廠基類GenericFactory完全不需要修改。這完美符合開閉原則。這個(gè)例子展示了成員函數(shù)模板如何與模板類繼承協(xié)同工作創(chuàng)建一個(gè)既類型安全又極其靈活的泛型框架。registerCreator這個(gè)成員函數(shù)模板是連接泛型工廠基類和具體產(chǎn)品派生類的橋梁。4. 深入陷阱與高級模式掌握了基本用法后我們來看看一些更復(fù)雜、更容易出錯(cuò)的情況和高級技巧。4.1 派生類中的成員函數(shù)模板與基類函數(shù)的重載/隱藏當(dāng)派生類定義了與基類同名的成員函數(shù)模板時(shí)會發(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; } // 這會隱藏基類中所有名為 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í)際上會調(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ù)模板會隱藏基類中所有同名的名稱無論參數(shù)是否匹配也無論是否是模板。如果要讓基類的重載函數(shù)/函數(shù)模板在派生類作用域中可見需要在派生類中使用using Base::func;聲明。成員函數(shù)模板也參與重載決議。當(dāng)調(diào)用發(fā)生時(shí)編譯器會在可見的函數(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í)并不知道會有多少個(gè)process函數(shù)的實(shí)例processint,processdouble,processMyClass...。這會導(dǎo)致 vtable 的大小無法確定破壞了C對象模型的根基。解決方案如果需要在繼承體系中實(shí)現(xiàn)基于類型的多態(tài)通常采用以下模式之一類型擦除Type Erasure如std::function內(nèi)部使用模板構(gòu)造函數(shù)和虛函數(shù)來實(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)識和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é)合的高級模式常用于靜態(tài)多態(tài)和代碼注入。成員函數(shù)模板在其中可以扮演關(guān)鍵角色。// CRTP 基類模板提供對象計(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)換邏輯這里簡單返回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通過模板參數(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è)綜合性的例子來結(jié)束本文設(shè)計(jì)一個(gè)ContainerWrapper它可以包裝任何符合標(biāo)準(zhǔn)容器接口提供begin(),end()的容器并為其添加一些通用的成員函數(shù)模板操作比如filter,transform等類似簡陋版的 ranges 適配器。同時(shí)我們將使用模板類繼承來提供一個(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過濾返回新容器 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())); // 使用與原容器同類型的容器來存儲結(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_; }; // 特化/派生版本針對 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è)簡單的打印輔助函數(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è)包含過濾后元素的新ContainerWrapper。注意它返回的是同類型容器的包裝器。transform接受一個(gè)一元操作UnaryOp返回一個(gè)包裝了std::vectornew_value_type的ContainerWrapper。這里展示了成員函數(shù)模板可以改變返回的容器類型非常靈活。for_each對每個(gè)元素應(yīng)用一個(gè)函數(shù)。模板類繼承VectorWrapper繼承自ContainerWrapperstd::vectorT。它特化了對于std::vector的包裝并添加了assign和safe_at這兩個(gè)額外的成員函數(shù)模板。assign模板可以接受任何輸入迭代器范圍。safe_at模板接受任何可轉(zhuǎn)換為整型的索引類型并返回std::optional提供安全訪問。依賴基類名稱訪問在VectorWrapper中我們使用this-container_來訪問基類的受保護(hù)成員container_這是處理依賴基類名稱的標(biāo)準(zhǔn)做法。編譯時(shí)多態(tài)與靈活性整個(gè)設(shè)計(jì)沒有使用任何虛函數(shù)所有多態(tài)行為如filter對vector和list的操作都在編譯時(shí)通過模板實(shí)例化確定效率極高。通過這個(gè)例子你可以看到成員函數(shù)模板如何為泛型類添加無限可能的算法操作而模板類繼承又如何讓我們可以針對特定類型進(jìn)行特化和功能增強(qiáng)。這兩者結(jié)合是構(gòu)建現(xiàn)代C泛型庫的強(qiáng)大工具。