C++復習核心精華

一、內存管理與智能指針

內存管理是C++區別于其他高級語言的關鍵特性，掌握好它就掌握了C++的靈魂。

1.?原始指針與內存泄漏

先來看看傳統C++的內存管理方式：

void?oldWay()?{int*?p?=?new?int(42);??//?分配內存//?如果這里發生異常或提前return，下面的delete可能不會執行//?其他代碼...delete?p;??//?釋放內存p?=?nullptr;??//?避免懸空指針}

這種方式有什么問題呢？太容易出錯了！忘記delete、出現異常、提前返回...都會導致內存泄漏。就像你把菜做到一半，突然停電了，灶臺上的火忘了關，后果很嚴重啊！

2. RAII原則與智能指針詳解

C++引入了RAII原則(Resource Acquisition Is?Initialization)，資源的獲取與初始化同時進行，資源的釋放與對象銷毀同時進行。這就像是給你的廚房裝了個自動滅火器，不管發生什么，都能自動處理。

智能指針就是RAII的典型應用：

std::unique_ptr

獨占所有權的智能指針，不能復制，但可以移動。

void?betterWay()?{std::unique_ptr<int>?p1?=?std::make_unique<int>(42);??//?C++14引入//?或者在C++11中：std::unique_ptr<int>?p1(new?int(42));//?即使這里發生異常，p1也會自動釋放內存//?獨占所有權，不能復制//?std::unique_ptr<int>?p2?=?p1;??//?編譯錯誤！//?但可以轉移所有權std::unique_ptr<int>?p3?=?std::move(p1);??//?p1現在為空//?離開作用域時，p3自動釋放內存}

unique_ptr的內部實現非常輕量，幾乎沒有性能開銷，是最常用的智能指針。就像是你的私人助手，只為你一個人服務，效率極高。

std::shared_ptr與引用計數

共享所有權的智能指針，通過引用計數機制實現。

void?sharedOwnership()?{//?創建一個shared_ptrstd::shared_ptr<int>?sp1?=?std::make_shared<int>(100);std::cout?<<?"引用計數:?"?<<?sp1.use_count()?<<?std::endl;??//?輸出：1{//?創建sp1的副本，共享所有權std::shared_ptr<int>?sp2?=?sp1;std::cout?<<?"引用計數:?"?<<?sp1.use_count()?<<?std::endl;??//?輸出：2//?修改值，兩個指針指向同一個對象*sp2?=?200;std::cout?<<?"sp1指向的值:?"?<<?*sp1?<<?std::endl;??//?輸出：200}??//?sp2離開作用域，引用計數減1std::cout?<<?"引用計數:?"?<<?sp1.use_count()?<<?std::endl;??//?輸出：1}??//?sp1離開作用域，引用計數減為0，內存被釋放

shared_ptr內部維護兩塊內存：一個是數據本身，一個是控制塊（包含引用計數等信息）。這有點像合租房子，大家共同負責，最后一個離開的人負責關燈鎖門。

std::weak_ptr與循環引用問題

weak_ptr不增加引用計數，用于解決循環引用問題。

class?Node?{public:std::string?name;std::shared_ptr<Node>?next;??//?指向下一個節點std::weak_ptr<Node>?prev;????//?指向前一個節點（弱引用）Node(const?std::string&?n)?:?name(n)?{}~Node()?{std::cout?<<?"銷毀節點:?"?<<?name?<<?std::endl;}};void?circularReference()?{auto?node1?=?std::make_shared<Node>("Node1");auto?node2?=?std::make_shared<Node>("Node2");//?創建循環引用node1->next?=?node2;node2->prev?=?node1;??//?弱引用不會增加引用計數//?使用弱引用if?(auto?temp?=?node2->prev.lock())?{??//?轉換為shared_ptrstd::cout?<<?"前一個節點是:?"?<<?temp->name?<<?std::endl;}}??//?函數結束時，兩個節點都能被正確釋放

如果prev也使用shared_ptr，就會形成循環引用，導致內存泄漏。這就像兩個人互相等對方先離開，結果誰也走不了。

3. 自定義刪除器

有時我們需要在釋放資源時執行特定操作，可以使用自定義刪除器：

//?文件資源管理void?customDeleter()?{//?自定義刪除器，確保文件正確關閉auto?fileCloser?=?[](FILE*?fp)?{if?(fp)?{std::cout?<<?"關閉文件"?<<?std::endl;fclose(fp);}};//?使用自定義刪除器的智能指針std::unique_ptr<FILE,?decltype(fileCloser)>?filePtr(fopen("data.txt",?"r"),?fileCloser);if?(filePtr)?{//?使用文件...char?buffer[100];fread(buffer,?1,?sizeof(buffer),?filePtr.get());}//?離開作用域時，fileCloser會被調用}

這個例子完美展示了RAII的威力，無論函數如何退出，文件都會被正確關閉。就像雇了專業保潔員，走的時候一定會把屋子打掃干凈。

二、模板編程的藝術

模板是C++最強大的特性之一，讓你寫出既通用又高效的代碼。它不僅僅是代碼復用工具，更是元編程的基礎。

1. 函數模板深入理解

基本函數模板我們都了解，但你知道模板還能做這些事嗎？

//?可變參數模板template<typename?T>T?sum(T?value)?{return?value;}template<typename?T,?typename...?Args>T?sum(T?first,?Args...?args)?{return?first?+?sum(args...);}//?使用int?total?=?sum(1,?2,?3,?4,?5);??//?返回15std::string?s?=?sum(std::string("Hello"),?"?",?"World");??//?返回"Hello?World"

遞歸模板展開是一個非常強大的技術，這段代碼的展開過程就像俄羅斯套娃，層層展開，最終計算出結果。

2. 類模板特化

模板特化允許我們為特定類型提供特殊實現：

//?主模板template<typename?T>class?DataHandler?{public:void?process(T?data)?{std::cout?<<?"處理通用數據:?"?<<?data?<<?std::endl;}};//?針對std::string的完全特化template<>class?DataHandler<std::string>?{public:void?process(std::string?data)?{std::cout?<<?"處理字符串:?"?<<?data?<<?std::endl;//?字符串特有的處理邏輯...}};//?部分特化（針對指針類型）template<typename?T>class?DataHandler<T*>?{public:void?process(T*?data)?{if?(data)?{std::cout?<<?"處理指針指向的數據:?"?<<?*data?<<?std::endl;}?else?{std::cout?<<?"空指針!"?<<?std::endl;}}};

模板特化就像餐廳里的"定制菜單"，根據不同的"食客"（類型）提供量身定制的"服務"（實現）。

3. SFINAE與類型萃取

SFINAE (Substitution Failure Is Not An Error) 是模板元編程的重要技術，允許編譯器在模板實例化失敗時繼續嘗試其他重載。

//?檢查類型是否有size()成員函數template<typename?T>struct?has_size?{private:template<typename?C>?static?constexpr?auto?test(int)?->?decltype(std::declval<C>().size(),?bool())?{?return?true;?}template<typename?C>?static?constexpr?bool?test(...)?{?return?false;?}public:static?constexpr?bool?value?=?test<T>(0);};//?根據類型特性選擇不同實現template<typename?Container>typename?std::enable_if<has_size<Container>::value,?void>::typeprintSize(const?Container&?c)?{std::cout?<<?"容器大小:?"?<<?c.size()?<<?std::endl;}template<typename?T>typename?std::enable_if<!has_size<T>::value,?void>::typeprintSize(const?T&)?{std::cout?<<?"此類型沒有size()方法"?<<?std::endl;}

在C++17中，我們可以使用if constexpr簡化這種代碼：

template<typename?Container>void?printSize(const?Container&?c)?{if?constexpr?(has_size<Container>::value)?{std::cout?<<?"容器大小:?"?<<?c.size()?<<?std::endl;}?else?{std::cout?<<?"此類型沒有size()方法"?<<?std::endl;}}

這種技術就像是編譯時的"魔法偵探"，能夠根據類型的特性自動選擇最合適的實現路徑。

三、STL深度剖析

STL是C++標準庫的核心部分，掌握它可以避免重復造輪子，大幅提高開發效率。

1. 容器性能對比與選擇指南

不同容器有不同的性能特點，選擇合適的容器至關重要：

容器	隨機訪問	插入 / 刪除 (中間)	插入 / 刪除 (首 / 尾)	查找	特點
vector	O(1)	O(n)	O(1) 尾部	O(n)	連續內存，緩存友好
list	O(n)	O(1)	O(1)	O(n)	雙向鏈表，穩定迭代器
deque	O(1)	O(n)	O(1) 首尾	O(n)	分段連續內存
set/map	O(log n)	O(log n)	O(log n)	O(log n)	紅黑樹實現，有序
unordered_set/map	O(1) 平均	O(1) 平均	O(1) 平均	O(1) 平均	哈希表實現，無序

//?性能敏感場景選擇指南void?containerChoice()?{//?1.?頻繁隨機訪問，較少插入刪除?->?vectorstd::vector<int>?v;//?2.?頻繁在兩端操作?->?dequestd::deque<int>?d;//?3.?頻繁在中間插入刪除?->?liststd::list<int>?l;//?4.?需要有序并快速查找?->?set/mapstd::map<std::string,?int>?m;//?5.?需要最快的查找，不要求有序?->?unordered_set/mapstd::unordered_map<std::string,?int>?um;}

選擇合適的容器就像選擇合適的工具，木匠不會用錘子切木頭，也不會用鋸子釘釘子。

2. 算法與迭代器配合使用

STL的強大在于算法與容器的解耦，通過迭代器連接：

void?algorithmDemo()?{std::vector<int>?numbers?=?{1,?5,?3,?4,?2};//?查找auto?it?=?std::find(numbers.begin(),?numbers.end(),?3);if?(it?!=?numbers.end())?{std::cout?<<?"找到:?"?<<?*it?<<?"?位置:?"?<<?std::distance(numbers.begin(),?it)?<<?std::endl;}//?排序std::sort(numbers.begin(),?numbers.end());//?二分查找（要求已排序）bool?exists?=?std::binary_search(numbers.begin(),?numbers.end(),?3);//?變換std::vector<int>?squared;std::transform(numbers.begin(),?numbers.end(),?std::back_inserter(squared),[](int?x)?{?return?x?*?x;?});//?累加int?sum?=?std::accumulate(numbers.begin(),?numbers.end(),?0);//?自定義排序std::sort(numbers.begin(),?numbers.end(),?[](int?a,?int?b)?{return?std::abs(a)?<?std::abs(b);??//?按絕對值排序});}

3. 自定義容器的迭代器

理解迭代器設計可以幫助我們更好地使用STL，甚至為自定義容器實現迭代器：

//?簡單的環形緩沖區template<typename?T,?size_t?Size>class?CircularBuffer?{private:T?data_[Size];size_t?head_?=?0;size_t?tail_?=?0;size_t?size_?=?0;public://?迭代器實現class?iterator?{private:CircularBuffer<T,?Size>*?buffer_;size_t?index_;size_t?count_;public://?迭代器類型定義（滿足STL要求）using?iterator_category?=?std::forward_iterator_tag;using?value_type?=?T;using?difference_type?=?std::ptrdiff_t;using?pointer?=?T*;using?reference?=?T&;iterator(CircularBuffer<T,?Size>*?buffer,?size_t?index,?size_t?count):?buffer_(buffer),?index_(index),?count_(count)?{}//?迭代器操作T&?operator*()?{?return?buffer_->data_[index_];?}iterator&?operator++()?{index_?=?(index_?+?1)?%?Size;++count_;return?*this;}bool?operator!=(const?iterator&?other)?const?{return?count_?!=?other.count_;}};//?容器方法void?push(const?T&?value)?{data_[tail_]?=?value;tail_?=?(tail_?+?1)?%?Size;if?(size_?<?Size)?{++size_;}?else?{head_?=?(head_?+?1)?%?Size;??//?覆蓋最老的元素}}//?提供迭代器iterator?begin()?{?return?iterator(this,?head_,?0);?}iterator?end()?{?return?iterator(this,?head_,?size_);?}};//?使用示例void?customContainerDemo()?{CircularBuffer<int,?5>?buffer;for?(int?i?=?0;?i?<?7;?++i)?{buffer.push(i);}//?此時緩沖區包含：2,?3,?4,?5,?6//?使用for-each循環（需要begin/end支持）for?(const?auto&?value?:?buffer)?{std::cout?<<?value?<<?"?";??//?輸出：2?3?4?5?6}//?也可以與STL算法配合使用auto?sum?=?std::accumulate(buffer.begin(),?buffer.end(),?0);std::cout?<<?"\n總和:?"?<<?sum?<<?std::endl;??//?輸出：20}

自定義迭代器需要滿足特定的接口要求，這樣才能與STL算法無縫配合。就像設計插頭和插座，只要遵循標準，任何設備都能正常工作。

四、現代C++特性(C++11/14/17/20)

現代C++引入了大量新特性，極大提升了開發效率和代碼質量。

1. 移動語義與右值引用

移動語義允許我們在不需要深拷貝的情況下轉移資源所有權，大幅提升性能：

class?BigData?{private:int*?data_;size_t?size_;public://?構造函數BigData(size_t?size)?:?size_(size)?{data_?=?new?int[size];std::cout?<<?"分配?"?<<?size?<<?"?個整數"?<<?std::endl;}//?析構函數~BigData()?{delete[]?data_;std::cout?<<?"釋放內存"?<<?std::endl;}//?拷貝構造函數（深拷貝）BigData(const?BigData&?other)?:?size_(other.size_)?{data_?=?new?int[size_];std::memcpy(data_,?other.data_,?size_?*?sizeof(int));std::cout?<<?"拷貝?"?<<?size_?<<?"?個整數（昂貴操作）"?<<?std::endl;}//?移動構造函數BigData(BigData&&?other)?noexcept?:?data_(other.data_),?size_(other.size_)?{other.data_?=?nullptr;??//?防止源對象釋放內存other.size_?=?0;std::cout?<<?"移動資源（快速操作）"?<<?std::endl;}//?移動賦值運算符BigData&?operator=(BigData&&?other)?noexcept?{if?(this?!=?&other)?{delete[]?data_;??//?釋放當前資源//?竊取資源data_?=?other.data_;size_?=?other.size_;//?將源對象置于有效但可析構狀態other.data_?=?nullptr;other.size_?=?0;std::cout?<<?"移動賦值（快速操作）"?<<?std::endl;}return?*this;}};//?演示移動語義優勢void?moveSemantics()?{std::vector<BigData>?v;std::cout?<<?"創建臨時對象并添加到vector:"?<<?std::endl;v.push_back(BigData(1000000));??//?使用移動構造函數，避免深拷貝std::cout?<<?"\n創建命名對象:"?<<?std::endl;BigData?d1(1000000);std::cout?<<?"\n復制添加到vector:"?<<?std::endl;v.push_back(d1);??//?使用拷貝構造函數，進行深拷貝std::cout?<<?"\n移動添加到vector:"?<<?std::endl;v.push_back(std::move(d1));??//?顯式使用移動語義//?注意：此時d1已被移動，處于有效但未指定狀態，不應再使用它的值}

移動語義就像是把一整本書直接交給別人，而不是復印一份再給他。在處理大型資源時，這種差異極其顯著。

2. 完美轉發與通用引用

完美轉發允許函數模板精確地傳遞參數，保持其值類別（左值/右值）：

//?工廠函數示例template<typename?T,?typename...?Args>std::unique_ptr<T>?make_unique(Args&&...?args)?{return?std::unique_ptr<T>(new?T(std::forward<Args>(args)...));}//?完美轉發包裝器template<typename?Func,?typename...?Args>auto?forwardingWrapper(Func&&?func,?Args&&...?args)?->?decltype(func(std::forward<Args>(args)...))?{std::cout?<<?"轉發參數到函數"?<<?std::endl;return?func(std::forward<Args>(args)...);}void?perfectForwarding()?{auto?print?=?[](const?std::string&?s)?{?std::cout?<<?"左值:?"?<<?s?<<?std::endl;?return?s.length();};auto?printRValue?=?[](std::string&&?s)?{?std::cout?<<?"右值:?"?<<?s?<<?std::endl;?return?s.length();};std::string?str?=?"Hello";//?轉發左值forwardingWrapper(print,?str);//?轉發右值forwardingWrapper(printRValue,?std::move(str));//?創建對象并完美轉發參數auto?p?=?make_unique<std::vector<int>>(5,?10);??//?創建包含5個10的vector}

完美轉發就像是一個完美的中間人，既不添加任何東西，也不減少任何東西，原封不動地傳遞參數。

3. Lambda表達式與捕獲技巧

Lambda表達式讓函數式編程在C++中變得簡單優雅：

void?lambdaExamples()?{int?x?=?10;//?基本lambdaauto?add?=?[](int?a,?int?b)?{?return?a?+?b;?};std::cout?<<?"5?+?3?=?"?<<?add(5,?3)?<<?std::endl;//?捕獲變量auto?addX?=?[x](int?a)?{?return?a?+?x;?};std::cout?<<?"5?+?x?=?"?<<?addX(5)?<<?std::endl;//?引用捕獲（可修改外部變量）auto?incrementX?=?[&x]()?{?x++;?};incrementX();std::cout?<<?"x現在是:?"?<<?x?<<?std::endl;??//?輸出：11//?混合捕獲int?y?=?20;auto?calculate?=?[x,?&y](int?a)?{?y?+=?a;??//?修改yreturn?x?*?y;??//?使用x的副本};std::cout?<<?"計算結果:?"?<<?calculate(5)?<<?std::endl;std::cout?<<?"y現在是:?"?<<?y?<<?std::endl;??//?y被修改//?捕獲this指針struct?Counter?{int?value?=?0;auto?increment()?{//?捕獲this指針，可訪問成員變量return?[this]()?{?++value;?};}void?print()?{std::cout?<<?"計數:?"?<<?value?<<?std::endl;}};Counter?c;auto?inc?=?c.increment();inc();inc();c.print();??//?輸出：計數:?2//?初始化捕獲（C++14）auto?sum?=?[sum?=?0](int?value)?mutable?{sum?+=?value;return?sum;};std::cout?<<?sum(1)?<<?std::endl;??//?1std::cout?<<?sum(2)?<<?std::endl;??//?3std::cout?<<?sum(3)?<<?std::endl;??//?6}

Lambda表達式就像是隨手寫下的小紙條，簡潔而直接，讓代碼更加緊湊易讀。

4. constexpr與編譯期計算

constexpr允許在編譯期執行計算，提高運行時性能：

//?編譯期計算斐波那契數列constexpr?int?fibonacci(int?n)?{return?(n?<=?1)???n?:?fibonacci(n-1)?+?fibonacci(n-2);}//?編譯期計算階乘constexpr?int?factorial(int?n)?{return?(n?<=?1)???1?:?n?*?factorial(n-1);}void?constexprDemo()?{//?編譯期計算constexpr?int?fib10?=?fibonacci(10);constexpr?int?fact5?=?factorial(5);std::cout?<<?"斐波那契(10)?=?"?<<?fib10?<<?std::endl;std::cout?<<?"階乘(5)?=?"?<<?fact5?<<?std::endl;//?編譯期數組大小constexpr?int?size?=?factorial(5);int?arr[size];??//?使用編譯期常量作為數組大小//?C++17:?constexpr?iftemplate<typename?T>auto?getValue(T?t)?{if?constexpr?(std::is_pointer_v<T>)?{return?*t;??//?指針類型}?else?{return?t;???//?非指針類型}}int?x?=?42;int*?p?=?&x;std::cout?<<?getValue(x)?<<?std::endl;??//?42std::cout?<<?getValue(p)?<<?std::endl;??//?42}

constexpr就像是提前做好的作業，編譯器在編譯時就把結果算出來了，運行時直接使用結果，不需要再計算。