告別內(nèi)存煩惱，C++智能指針來救場
在 C++ 編程領(lǐng)域，內(nèi)存管理向來是棘手難題。手動內(nèi)存管理依靠new與delete操作符，開發(fā)者稍有疏忽，忘記釋放內(nèi)存，內(nèi)存泄漏便接踵而至。隨著程序持續(xù)運行，泄漏內(nèi)存不斷累積，不僅拖慢系統(tǒng)速度，甚至能讓程序直接崩潰。項目代碼量一旦增大，內(nèi)存管理的復雜度呈指數(shù)級上升。不同模塊間動態(tài)分配內(nèi)存縱橫交錯，哪塊內(nèi)存何時該釋放，錯綜復雜，難以厘清。更糟糕的是，異常處理過程中，正常代碼流程被打斷，原本規(guī)劃好的內(nèi)存釋放操作極易被跳過，讓內(nèi)存泄漏風險倍增。
手動內(nèi)存管理還常引發(fā)懸空指針問題，內(nèi)存釋放后指針未妥善處理，后續(xù)對指針的訪問，會觸發(fā)未定義行為，致使程序出現(xiàn)詭異錯誤，排查起來困難重重。好在 C++11 推出智能指針，為開發(fā)者帶來曙光。std::unique_ptr、std::shared_ptr和std::weak_ptr各有所長，基于 RAII 原則，將內(nèi)存分配與對象生命周期緊密關(guān)聯(lián)，對象生命周期結(jié)束，自動釋放內(nèi)存，極大簡化內(nèi)存管理流程，讓開發(fā)者能專注于核心代碼編寫。
Part1.C++ 編程的內(nèi)存困境
在 C++ 編程的世界里，內(nèi)存管理一直是讓人又愛又恨的難題。很多開發(fā)者都有過這樣的經(jīng)歷：辛苦寫好的程序，運行一段時間后，莫名其妙地變得越來越慢，甚至直接崩潰，排查之后才發(fā)現(xiàn)是內(nèi)存泄漏在搞鬼。
比如下面這段簡單的代碼：
void memoryLeakExample() {
int* ptr = new int(10);
// 這里忘記delete ptr了！
}在memoryLeakExample函數(shù)中，我們使用new分配了一塊內(nèi)存來存儲一個整數(shù)10 ，但函數(shù)結(jié)束時卻沒有使用delete釋放這塊內(nèi)存。隨著這個函數(shù)被多次調(diào)用，內(nèi)存泄漏就會越來越嚴重，程序占用的內(nèi)存會不斷增加，最終導致系統(tǒng)性能下降，甚至崩潰。
除了內(nèi)存泄漏，空指針引用也是一個常見的噩夢。空指針，就像是指向一個不存在地方的指針，如果不小心對它進行操作，就會引發(fā)程序崩潰。比如：
void nullPointerDereferenceExample() {
int* ptr = nullptr;
// 嘗試訪問空指針指向的內(nèi)存，這會導致未定義行為，通常會使程序崩潰
std::cout << *ptr << std::endl;
}在這個例子中，ptr被初始化為nullptr，表示空指針。當我們試圖解引用它（即訪問它指向的內(nèi)存）時，就會觸發(fā)未定義行為，程序很可能會直接崩潰。
這些內(nèi)存管理問題不僅難以調(diào)試，還會嚴重影響程序的穩(wěn)定性和性能。在大型項目中，代碼邏輯復雜，涉及大量的內(nèi)存分配和釋放操作，內(nèi)存問題就更容易隱藏其中，成為一顆隨時可能爆炸的定時炸彈。那么，有沒有什么好辦法來解決這些問題呢？答案就是 C++ 智能指針，它就像是一位貼心的內(nèi)存管家，能幫我們自動處理很多內(nèi)存管理的繁瑣事務，讓我們的編程之路更加順暢。
Part2.C++智能指針詳解
2.1智能指針是什么
智能指針是 C++ 中一種特殊的指針類型，它的出現(xiàn)，就像是給普通指針穿上了一層智能鎧甲。與傳統(tǒng)的裸指針不同，智能指針是基于 RAII（Resource Acquisition Is Initialization，資源獲取即初始化）機制實現(xiàn)的。簡單來說，RAII 機制利用對象的生命周期來管理資源，當對象被創(chuàng)建時，資源被獲取；當對象的生命周期結(jié)束時，資源會被自動釋放。智能指針正是借助這一機制，能夠自動管理內(nèi)存的生命周期 ，讓我們無需手動調(diào)用delete來釋放內(nèi)存，從而避免了手動管理內(nèi)存時可能出現(xiàn)的內(nèi)存泄漏和內(nèi)存訪問錯誤等問題。比如：
#include <memory>
#include <iostream>
void smartPtrExample() {
// 創(chuàng)建一個指向int類型的智能指針，初始值為10
std::unique_ptr<int> ptr = std::make_unique<int>(10);
// 這里無需手動delete ptr，當ptr離開作用域時，內(nèi)存會自動釋放
std::cout << *ptr << std::endl;
}在上述代碼中，std::unique_ptr<int> ptr = std::make_unique<int>(10);創(chuàng)建了一個std::unique_ptr類型的智能指針ptr，它指向一個動態(tài)分配的int型對象，初始值為10。當smartPtrExample函數(shù)執(zhí)行結(jié)束，ptr離開作用域時，它所指向的內(nèi)存會被自動釋放，無需我們手動調(diào)用delete。
C++ 中有四種智能指針：
- auto_ptr：已經(jīng)廢棄
- unique_ptr：獨占式指針，同一時刻只能有一個指針指向同一個對象
- shared_ptr：共享式指針，同一時刻可以有多個指針指向同一個對象
- weak_ptr：用來解決shared_ptr相互引用導致的死鎖問題
2.2智能指針存在的意義
智能指針的出現(xiàn)，極大地改變了 C++ 編程中內(nèi)存管理的方式，它的意義主要體現(xiàn)在以下幾個方面：
- 自動內(nèi)存管理：這是智能指針最顯著的優(yōu)勢。在傳統(tǒng)的 C++ 編程中，我們需要時刻記住哪些內(nèi)存是動態(tài)分配的，在合適的時候手動釋放，稍有不慎就會導致內(nèi)存泄漏。而智能指針能夠自動處理內(nèi)存的釋放，大大降低了內(nèi)存泄漏的風險，讓我們可以把更多的精力放在業(yè)務邏輯的實現(xiàn)上 。
- 防止空指針引用：智能指針通過重載operator->和operator*，在訪問指針指向的對象之前，會先檢查指針是否為空。如果指針為空，會拋出異常或者返回一個特定的錯誤值，避免了空指針引用導致的程序崩潰 。
- 引用計數(shù)機制：以std::shared_ptr為代表的智能指針使用了引用計數(shù)機制。多個std::shared_ptr可以共享同一個資源，當有新的std::shared_ptr指向該資源時，引用計數(shù)增加；當std::shared_ptr離開作用域或者被重置時，引用計數(shù)減少。當引用計數(shù)為 0 時，資源會被自動釋放。這種機制非常適合管理那些需要被多個對象共享的資源 。
- 類型安全：智能指針是類型相關(guān)的，它在編譯時就會進行類型檢查，確保指針操作的安全性，避免了因類型不匹配而導致的難以調(diào)試的錯誤 。
- 異常安全：在傳統(tǒng)的內(nèi)存管理中，如果在new和delete之間拋出異常，很容易導致內(nèi)存泄漏。而智能指針基于 RAII 機制，在對象構(gòu)造時獲取資源，析構(gòu)時釋放資源，即使在異常情況下，也能保證資源的正確釋放，提供了更好的異常安全性。
Part3.智能指針的核心原理
3.1 RAII 機制
RAII（Resource Acquisition Is Initialization），即資源獲取即初始化，是智能指針實現(xiàn)自動內(nèi)存管理的基石。其核心思想是將資源的獲取與對象的初始化緊密綁定，而資源的釋放則與對象的析構(gòu)函數(shù)關(guān)聯(lián)。當一個對象被創(chuàng)建時，它會獲取所需的資源（例如動態(tài)分配的內(nèi)存），并在對象的生命周期內(nèi)持有這些資源。一旦對象的生命周期結(jié)束，無論是因為函數(shù)執(zhí)行完畢導致局部對象超出作用域，還是因為對象被顯式銷毀，其析構(gòu)函數(shù)都會被自動調(diào)用，從而確保資源被正確釋放，避免了因程序員疏忽而導致的資源泄漏問題。
以下是一個簡單的示例代碼，展示了如何通過 RAII 機制實現(xiàn)一個簡單的智能指針：
template<typename T>
class MySmartPtr {
public:
// 構(gòu)造函數(shù)獲取資源
MySmartPtr(T* ptr) : m_ptr(ptr) {}
// 析構(gòu)函數(shù)釋放資源
~MySmartPtr() {
delete m_ptr;
}
// 重載解引用運算符，使其行為類似于普通指針
T& operator*() {
return *m_ptr;
}
// 重載箭頭運算符，使其行為類似于普通指針
T* operator->() {
return m_ptr;
}
private:
T* m_ptr;
};在上述代碼中，MySmartPtr類模板實現(xiàn)了一個基本的智能指針功能。構(gòu)造函數(shù)接受一個指針類型的參數(shù)，將其賦值給成員變量m_ptr，從而獲取資源。而析構(gòu)函數(shù)則在對象銷毀時，使用delete操作符釋放m_ptr指向的內(nèi)存資源，確保資源的正確回收。通過這種方式，我們將資源的管理封裝在了類中，利用對象的生命周期來自動管理資源，遵循了 RAII 機制的原則。
3.2引用計數(shù)技術(shù)
引用計數(shù)是智能指針實現(xiàn)資源共享和自動釋放的關(guān)鍵技術(shù)之一，尤其是在std::shared_ptr中得到了廣泛應用。其原理是為每個被管理的資源維護一個引用計數(shù)變量，用于記錄當前有多少個智能指針對象正在引用該資源。
當一個新的std::shared_ptr對象被創(chuàng)建并指向某一資源時，該資源的引用計數(shù)會增加。例如：
#include <memory>
#include <iostream>
int main() {
// 創(chuàng)建一個shared_ptr，此時資源的引用計數(shù)為1
std::shared_ptr<int> ptr1 = std::make_shared<int>(42);
std::cout << "ptr1引用計數(shù): " << ptr1.use_count() << std::endl;
// 拷貝構(gòu)造一個新的shared_ptr，引用計數(shù)增加為2
std::shared_ptr<int> ptr2 = ptr1;
std::cout << "ptr2引用計數(shù): " << ptr2.use_count() << std::endl;
// 賦值操作，引用計數(shù)不變（先減少左邊的引用計數(shù)，再增加右邊的引用計數(shù)）
std::shared_ptr<int> ptr3;
ptr3 = ptr2;
std::cout << "ptr3引用計數(shù): " << ptr3.use_count() << std::endl;
// 當一個shared_ptr超出作用域，引用計數(shù)減少
{
std::shared_ptr<int> ptr4 = ptr3;
std::cout << "ptr4引用計數(shù): " << ptr4.use_count() << std::endl;
}
std::cout << "ptr3引用計數(shù)（ptr4超出作用域后）: " << ptr3.use_count() << std::endl;
return 0;
}在上述代碼中，通過std::make_shared創(chuàng)建了一個std::shared_ptr<int>對象ptr1，此時資源的引用計數(shù)為 1。接著通過拷貝構(gòu)造和賦值操作創(chuàng)建了ptr2和ptr3，每次操作都會使引用計數(shù)相應增加。當ptr4超出其作用域時，其析構(gòu)函數(shù)被調(diào)用，引用計數(shù)減少。
當引用計數(shù)變?yōu)?0 時，表示沒有任何智能指針再引用該資源，此時資源會被自動釋放。這種機制確保了資源在不再被使用時能夠及時、正確地被回收，避免了內(nèi)存泄漏的發(fā)生，同時也支持了多個智能指針安全地共享同一資源，提高了資源的利用率和程序的靈活性。
Part4.常見智能指針類型詳解
4.1 unique_ptr：獨占資源的小衛(wèi)士
std::unique_ptr是 C++11 引入的一種智能指針，它采用獨占所有權(quán)語義，就像是一位獨占資源的小衛(wèi)士，在同一時間內(nèi)，只能有一個std::unique_ptr指向給定的資源 。當std::unique_ptr離開作用域時，它所管理的資源會被自動釋放，從而避免了內(nèi)存泄漏。
圖片
我們來看一下它的定義和初始化方式：
#include <memory>
#include <iostream>
int main() {
// 直接初始化，使用new創(chuàng)建一個int型對象，值為10
std::unique_ptr<int> ptr1(new int(10));
// 使用C++14引入的make_unique函數(shù)來初始化，更加簡潔安全
std::unique_ptr<int> ptr2 = std::make_unique<int>(20);
// 訪問智能指針指向的值
std::cout << "ptr1的值: " << *ptr1 << std::endl;
std::cout << "ptr2的值: " << *ptr2 << std::endl;
return 0;
}在上述代碼中，ptr1通過直接初始化的方式，指向一個動態(tài)分配的int型對象，值為10；ptr2則使用std::make_unique函數(shù)進行初始化，指向一個值為20的int型對象 。當main函數(shù)結(jié)束時，ptr1和ptr2離開作用域，它們所指向的內(nèi)存會被自動釋放。
std::unique_ptr不支持拷貝，但支持移動語義。這意味著我們可以將一個std::unique_ptr的所有權(quán)轉(zhuǎn)移給另一個std::unique_ptr 。比如：
#include <memory>
#include <iostream>
int main() {
std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
// 使用std::move將ptr1的所有權(quán)轉(zhuǎn)移給ptr2
std::unique_ptr<int> ptr2 = std::move(ptr1);
// 此時ptr1不再指向任何對象，為空指針
if (!ptr1) {
std::cout << "ptr1為空指針" << std::endl;
}
// ptr2指向原來ptr1指向的對象
if (ptr2) {
std::cout << "ptr2的值: " << *ptr2 << std::endl;
}
return 0;
}在這段代碼中，std::move(ptr1)將ptr1的所有權(quán)轉(zhuǎn)移給了ptr2 ，轉(zhuǎn)移后ptr1不再指向任何對象，變?yōu)榭罩羔槪鴓tr2則指向了原來ptr1指向的對象。
4.2 shared_ptr：資源共享的協(xié)調(diào)者
std::shared_ptr是一種可共享所有權(quán)的智能指針，它就像是資源共享的協(xié)調(diào)者，允許多個std::shared_ptr指向同一個資源。std::shared_ptr通過引用計數(shù)機制來管理資源，每個std::shared_ptr對象都維護著一個引用計數(shù)器，用于記錄指向同一資源的std::shared_ptr對象的數(shù)量。當有新的std::shared_ptr指向該資源時，引用計數(shù)增加；當std::shared_ptr離開作用域或者被重置時，引用計數(shù)減少。當引用計數(shù)為 0 時，資源會被自動釋放。
圖片
下面是std::shared_ptr的定義和初始化方式示例：
#include <memory>
#include <iostream>
int main() {
// 直接初始化，使用new創(chuàng)建一個int型對象，值為10
std::shared_ptr<int> ptr1(new int(10));
// 使用make_shared函數(shù)初始化，推薦這種方式，效率更高
std::shared_ptr<int> ptr2 = std::make_shared<int>(20);
// 輸出引用計數(shù)
std::cout << "ptr1的引用計數(shù): " << ptr1.use_count() << std::endl;
std::cout << "ptr2的引用計數(shù): " << ptr2.use_count() << std::endl;
// 讓ptr3也指向ptr1所指向的對象，引用計數(shù)增加
std::shared_ptr<int> ptr3 = ptr1;
std::cout << "ptr1的引用計數(shù): " << ptr1.use_count() << std::endl;
return 0;
}在上述代碼中，ptr1通過直接初始化指向一個值為10的int型對象，ptr2使用make_shared函數(shù)初始化指向一個值為20的int型對象 。一開始，ptr1和ptr2的引用計數(shù)都為1 。當ptr3 = ptr1時，ptr1所指向?qū)ο蟮囊糜嫈?shù)增加為2 ，因為現(xiàn)在有ptr1和ptr3兩個std::shared_ptr指向同一個對象。
再看一個更復雜的例子，展示std::shared_ptr在對象生命周期管理中的作用：
#include <memory>
#include <iostream>
class MyClass {
public:
MyClass() {
std::cout << "MyClass構(gòu)造函數(shù)被調(diào)用" << std::endl;
}
~MyClass() {
std::cout << "MyClass析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
int main() {
{
std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
std::shared_ptr<MyClass> ptr2 = ptr1;
// 輸出引用計數(shù)
std::cout << "ptr1的引用計數(shù): " << ptr1.use_count() << std::endl;
std::cout << "ptr2的引用計數(shù): " << ptr2.use_count() << std::endl;
}
// 這里ptr1和ptr2離開作用域，引用計數(shù)降為0，MyClass對象被銷毀
std::cout << "離開作用域后" << std::endl;
return 0;
}在這個例子中，MyClass類有構(gòu)造函數(shù)和析構(gòu)函數(shù)，用于輸出對象的創(chuàng)建和銷毀信息。在main函數(shù)中，創(chuàng)建了ptr1和ptr2兩個std::shared_ptr，它們都指向同一個MyClass對象 。當程序執(zhí)行到}時，ptr1和ptr2離開作用域，它們對MyClass對象的引用計數(shù)降為0 ，MyClass對象的析構(gòu)函數(shù)被調(diào)用，輸出MyClass析構(gòu)函數(shù)被調(diào)用。
4.3 weak_ptr：解決循環(huán)引用的利器
std::weak_ptr是一種可觀察std::shared_ptr所管理對象的智能指針，但它不會增加對象的引用計數(shù)，就像是一個默默觀察的旁觀者。std::weak_ptr主要用于解決std::shared_ptr可能出現(xiàn)的循環(huán)引用問題。
圖片
循環(huán)引用是指兩個或多個對象通過std::shared_ptr相互引用，導致它們的引用計數(shù)永遠無法降為 0，從而造成內(nèi)存泄漏。比如下面這個錯誤示例：
#include <memory>
#include <iostream>
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
~A() {
std::cout << "A的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
class B {
public:
std::shared_ptr<A> a_ptr;
~B() {
std::cout << "B的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// 這里a和b離開作用域，但由于循環(huán)引用，它們的引用計數(shù)不會降為0，A和B對象不會被銷毀
return 0;
}在上述代碼中，A類和B類通過std::shared_ptr相互引用，形成了循環(huán)引用。當main函數(shù)結(jié)束時，a和b離開作用域，但由于循環(huán)引用，它們的引用計數(shù)不會降為 0，A和B對象不會被銷毀，從而導致內(nèi)存泄漏。
為了解決這個問題，我們可以使用std::weak_ptr ，修改后的代碼如下：
#include <memory>
#include <iostream>
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
~A() {
std::cout << "A的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
class B {
public:
std::weak_ptr<A> a_ptr;
~B() {
std::cout << "B的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// 這里a和b離開作用域，由于b中的a_ptr是weak_ptr，不會增加引用計數(shù)，A和B對象會被正確銷毀
return 0;
}在修改后的代碼中，B類中的a_ptr改為了std::weak_ptr ，這樣就打破了循環(huán)引用。當main函數(shù)結(jié)束時，a和b離開作用域，A和B對象的引用計數(shù)能夠正確降為 0，它們的析構(gòu)函數(shù)被調(diào)用，對象被正確銷毀。
std::weak_ptr本身不能直接訪問所指向的對象，需要通過lock方法將其轉(zhuǎn)換為std::shared_ptr ，然后再訪問對象。比如：
#include <memory>
#include <iostream>
int main() {
std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
std::weak_ptr<int> weakPtr = sharedPtr;
// 使用lock方法將weak_ptr轉(zhuǎn)換為shared_ptr
if (std::shared_ptr<int> tempPtr = weakPtr.lock()) {
std::cout << "通過weak_ptr訪問的值: " << *tempPtr << std::endl;
} else {
std::cout << "對象已被銷毀" << std::endl;
}
return 0;
}在這段代碼中，首先創(chuàng)建了一個std::shared_ptr<int>對象sharedPtr，然后創(chuàng)建了一個std::weak_ptr<int>對象weakPtr，并讓它指向sharedPtr所指向的對象 。通過weakPtr.lock()方法將weakPtr轉(zhuǎn)換為std::shared_ptr<int> ，如果轉(zhuǎn)換成功（即對象未被銷毀），則可以通過返回的std::shared_ptr<int>訪問對象的值；如果對象已被銷毀，lock方法會返回一個空的std::shared_ptr 。
Part5.智能指針的使用技巧
5.1選擇合適的智能指針類型
在實際編程中，選擇合適的智能指針類型至關(guān)重要，它直接關(guān)系到程序的性能、資源管理的有效性以及代碼的穩(wěn)定性。
當我們需要獨占某個對象的所有權(quán)，確保在對象的生命周期內(nèi)只有一個指針能夠訪問和管理它時，std::unique_ptr是不二之選。例如，在一個函數(shù)內(nèi)部創(chuàng)建的對象，只在該函數(shù)內(nèi)部使用，并且不需要將其所有權(quán)傳遞給其他部分的代碼，就可以使用std::unique_ptr。像下面這樣的代碼場景：
#include <iostream>
#include <memory>
void processResource() {
// 使用std::unique_ptr獨占管理一個Resource對象
std::unique_ptr<int> ptr = std::make_unique<int>(42);
std::cout << *ptr << std::endl;
// 函數(shù)結(jié)束時，ptr自動析構(gòu)，所管理的int對象也被釋放
}
int main() {
processResource();
return 0;
}在上述代碼中，processResource函數(shù)內(nèi)部創(chuàng)建的int對象通過std::unique_ptr進行管理，當函數(shù)執(zhí)行完畢，ptr超出作用域，其析構(gòu)函數(shù)會自動釋放所指向的int對象，保證了資源的正確回收，同時避免了其他部分代碼對該對象的意外訪問和修改。
而當多個對象需要共享同一塊內(nèi)存資源時，std::shared_ptr就派上用場了。比如在一個多線程環(huán)境下，多個線程可能同時訪問和操作同一個對象，此時使用std::shared_ptr可以方便地實現(xiàn)資源的共享，并且保證對象在所有引用它的指針都銷毀后才被釋放。例如：
#include <iostream>
#include <memory>
#include <thread>
#include <vector>
class SharedResource {
public:
SharedResource() {
std::cout << "SharedResource constructed." << std::endl;
}
~SharedResource() {
std::cout << "SharedResource destroyed." << std::endl;
}
void doSomething() {
std::cout << "Doing something with the shared resource." << std::endl;
}
};
void threadFunction(std::shared_ptr<SharedResource> ptr) {
ptr->doSomething();
}
int main() {
// 創(chuàng)建一個指向SharedResource對象的shared_ptr
std::shared_ptr<SharedResource> sharedPtr = std::make_shared<SharedResource>();
std::vector<std::thread> threads;
// 創(chuàng)建多個線程，每個線程都傳入共享的shared_ptr
for (int i = 0; i < 5; ++i) {
threads.push_back(std::thread(threadFunction, sharedPtr));
}
// 等待所有線程完成
for (auto& th : threads) {
th.join();
}
return 0;
}在上述代碼中，SharedResource對象通過std::shared_ptr進行管理，在多個線程中都可以安全地訪問和操作這個共享對象。每個線程函數(shù)threadFunction都接受一個std::shared_ptr作為參數(shù)，這樣多個線程就可以共享同一個SharedResource對象，而對象的生命周期由std::shared_ptr的引用計數(shù)機制來自動管理，當所有線程都結(jié)束，不再有std::shared_ptr指向該對象時，對象會被自動銷毀。
然而，正如前面所提到的，std::shared_ptr在使用過程中可能會出現(xiàn)循環(huán)引用的問題。為了避免這種情況，當我們遇到對象之間存在相互引用，但又不希望因為這種引用關(guān)系導致內(nèi)存泄漏時，就需要引入std::weak_ptr。例如在一個樹形數(shù)據(jù)結(jié)構(gòu)中，節(jié)點之間可能存在父子節(jié)點的相互引用，如果使用std::shared_ptr來管理節(jié)點，就很容易出現(xiàn)循環(huán)引用，導致節(jié)點無法正常釋放。此時，我們可以將父節(jié)點對子節(jié)點的引用使用std::shared_ptr，而子節(jié)點對父節(jié)點的引用使用std::weak_ptr，這樣就可以打破循環(huán)引用，保證對象能夠在合適的時候被正確銷毀。
5.2選擇合適的智能指針類型
在實際編程中，選擇合適的智能指針類型至關(guān)重要，它直接關(guān)系到程序的性能、資源管理的有效性以及代碼的穩(wěn)定性。
當我們需要獨占某個對象的所有權(quán)，確保在對象的生命周期內(nèi)只有一個指針能夠訪問和管理它時，std::unique_ptr是不二之選。例如，在一個函數(shù)內(nèi)部創(chuàng)建的對象，只在該函數(shù)內(nèi)部使用，并且不需要將其所有權(quán)傳遞給其他部分的代碼，就可以使用std::unique_ptr。像下面這樣的代碼場景：
#include <iostream>
#include <memory>
void processResource() {
// 使用std::unique_ptr獨占管理一個Resource對象
std::unique_ptr<int> ptr = std::make_unique<int>(42);
std::cout << *ptr << std::endl;
// 函數(shù)結(jié)束時，ptr自動析構(gòu)，所管理的int對象也被釋放
}
int main() {
processResource();
return 0;
}在上述代碼中，processResource函數(shù)內(nèi)部創(chuàng)建的int對象通過std::unique_ptr進行管理，當函數(shù)執(zhí)行完畢，ptr超出作用域，其析構(gòu)函數(shù)會自動釋放所指向的int對象，保證了資源的正確回收，同時避免了其他部分代碼對該對象的意外訪問和修改。
而當多個對象需要共享同一塊內(nèi)存資源時，std::shared_ptr就派上用場了。比如在一個多線程環(huán)境下，多個線程可能同時訪問和操作同一個對象，此時使用std::shared_ptr可以方便地實現(xiàn)資源的共享，并且保證對象在所有引用它的指針都銷毀后才被釋放。例如：
#include <iostream>
#include <memory>
#include <thread>
#include <vector>
class SharedResource {
public:
SharedResource() {
std::cout << "SharedResource constructed." << std::endl;
}
~SharedResource() {
std::cout << "SharedResource destroyed." << std::endl;
}
void doSomething() {
std::cout << "Doing something with the shared resource." << std::endl;
}
};
void threadFunction(std::shared_ptr<SharedResource> ptr) {
ptr->doSomething();
}
int main() {
// 創(chuàng)建一個指向SharedResource對象的shared_ptr
std::shared_ptr<SharedResource> sharedPtr = std::make_shared<SharedResource>();
std::vector<std::thread> threads;
// 創(chuàng)建多個線程，每個線程都傳入共享的shared_ptr
for (int i = 0; i < 5; ++i) {
threads.push_back(std::thread(threadFunction, sharedPtr));
}
// 等待所有線程完成
for (auto& th : threads) {
th.join();
}
return 0;
}在上述代碼中，SharedResource對象通過std::shared_ptr進行管理，在多個線程中都可以安全地訪問和操作這個共享對象。每個線程函數(shù)threadFunction都接受一個std::shared_ptr作為參數(shù)，這樣多個線程就可以共享同一個SharedResource對象，而對象的生命周期由std::shared_ptr的引用計數(shù)機制來自動管理，當所有線程都結(jié)束，不再有std::shared_ptr指向該對象時，對象會被自動銷毀。
然而，正如前面所提到的，std::shared_ptr在使用過程中可能會出現(xiàn)循環(huán)引用的問題。為了避免這種情況，當我們遇到對象之間存在相互引用，但又不希望因為這種引用關(guān)系導致內(nèi)存泄漏時，就需要引入std::weak_ptr。例如在一個樹形數(shù)據(jù)結(jié)構(gòu)中，節(jié)點之間可能存在父子節(jié)點的相互引用，如果使用std::shared_ptr來管理節(jié)點，就很容易出現(xiàn)循環(huán)引用，導致節(jié)點無法正常釋放。此時，我們可以將父節(jié)點對子節(jié)點的引用使用std::shared_ptr，而子節(jié)點對父節(jié)點的引用使用std::weak_ptr，這樣就可以打破循環(huán)引用，保證對象能夠在合適的時候被正確銷毀。
5.3與容器的結(jié)合使用
智能指針與 C++ 標準容器的結(jié)合使用，為我們在管理對象集合時提供了極大的便利，同時也能有效地避免內(nèi)存泄漏和懸空指針等問題。
在容器中存儲智能指針時，我們可以像存儲普通對象一樣將智能指針放入容器中。例如，使用std::vector來存儲std::unique_ptr指向的對象：
#include <iostream>
#include <memory>
#include <vector>
class MyClass {
public:
MyClass(int num) : num_(num) {
std::cout << "MyClass " << num_ << " constructed." << std::endl;
}
~MyClass() {
std::cout << "MyClass " << num_ << " destroyed." << std::endl;
}
void print() const {
std::cout << "MyClass " << num_ << std::endl;
}
private:
int num_;
};
int main() {
std::vector<std::unique_ptr<MyClass>> vec;
// 創(chuàng)建多個MyClass對象，并通過unique_ptr管理，放入向量中
for (int i = 0; i < 5; ++i) {
vec.push_back(std::make_unique<MyClass>(i));
}
// 遍歷向量，調(diào)用每個對象的print函數(shù)
for (const auto& ptr : vec) {
ptr->print();
}
return 0;
}在上述代碼中，std::vector存儲了std::unique_ptr<MyClass>類型的元素，每個std::unique_ptr都獨占管理一個MyClass對象。通過這種方式，我們可以方便地管理一組對象，并且不用擔心對象的生命周期問題，因為當std::unique_ptr超出作用域時（例如從容器中移除或者容器本身被銷毀），它所管理的對象會自動被析構(gòu)，從而避免了內(nèi)存泄漏。
當使用std::shared_ptr與容器結(jié)合時，同樣可以實現(xiàn)對象的共享管理。例如，在一個std::list中存儲std::shared_ptr指向的對象：
#include <iostream>
#include <memory>
#include <list>
class SharedResource {
public:
SharedResource() {
std::cout << "SharedResource constructed." << std::endl;
}
~SharedResource() {
std::cout << "SharedResource destroyed." << std::endl;
}
void doSomething() {
std::cout << "Doing something with the shared resource." << std::endl;
}
};
int main() {
std::list<std::shared_ptr<SharedResource>> myList;
// 創(chuàng)建一個SharedResource對象，并通過shared_ptr管理，放入列表中
std::shared_ptr<SharedResource> sharedPtr = std::make_shared<SharedResource>();
myList.push_back(sharedPtr);
// 從列表中取出shared_ptr，并調(diào)用對象的方法
for (const auto& ptr : myList) {
ptr->doSomething();
}
return 0;
}在這個例子中，std::list中的多個元素可以共享同一個SharedResource對象，通過std::shared_ptr的引用計數(shù)機制來確保對象在所有引用它的指針都被銷毀后才被釋放，保證了資源的正確管理。
需要注意的是，在使用容器存儲智能指針時，要避免一些可能導致問題的操作。例如，不要在容器中存儲已經(jīng)被析構(gòu)的智能指針，否則可能會導致未定義行為。同時，當對容器進行插入、刪除或者修改操作時，要確保智能指針的生命周期仍然在有效的控制范圍內(nèi)，以防止出現(xiàn)懸空指針或者內(nèi)存泄漏的情況。
Part6.智能指針的性能分析
6.1內(nèi)存開銷
在分析智能指針的內(nèi)存開銷時，我們需要考慮多個因素，包括引用計數(shù)的存儲、控制塊的大小等。
std::shared_ptr的內(nèi)存占用相對較大。它除了要存儲指向?qū)ο蟮闹羔樛猓€需要維護一個引用計數(shù)，以及一個包含引用計數(shù)、弱引用計數(shù)、刪除器、分配器等信息的控制塊。在常見的編譯器和運行環(huán)境下，一個std::shared_ptr對象的大小通常是裸指針大小的兩倍。例如，在 64 位系統(tǒng)中，裸指針的大小為 8 字節(jié)，而std::shared_ptr的大小可能達到 16 字節(jié)左右。這是因為它需要額外的空間來存儲引用計數(shù)和控制塊信息，以實現(xiàn)資源的共享和生命周期的管理。
以下是一個簡單的代碼示例，用于展示std::shared_ptr的內(nèi)存占用情況：
#include <iostream>
#include <memory>
class MyClass {
public:
int data;
};
int main() {
std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
std::cout << "Size of std::shared_ptr: " << sizeof(ptr) << " bytes" << std::endl;
std::cout << "Size of raw pointer: " << sizeof(MyClass*) << " bytes" << std::endl;
return 0;
}在上述代碼中，通過sizeof運算符可以大致了解std::shared_ptr和裸指針的內(nèi)存占用情況。
相比之下，std::unique_ptr的內(nèi)存開銷則較小。它只需要存儲指向?qū)ο蟮闹羔槪恍枰~外的引用計數(shù)和控制塊，因此其大小與裸指針基本相同。在 64 位系統(tǒng)中，std::unique_ptr的大小通常也為 8 字節(jié)，與指向相同類型對象的裸指針大小一致。例如：
#include <iostream>
#include <memory>
class MyClass {
public:
int data;
};
int main() {
std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
std::cout << "Size of std::unique_ptr: " << sizeof(ptr) << " bytes" << std::endl;
std::cout << "Size of raw pointer: " << sizeof(MyClass*) << " bytes" << std::endl;
return 0;
}在對內(nèi)存敏感的場景中，如嵌入式系統(tǒng)開發(fā)或者對內(nèi)存使用要求極為嚴格的高性能計算場景，如果不需要資源的共享，應優(yōu)先考慮使用std::unique_ptr，以減少不必要的內(nèi)存開銷。
6.2運行時效率
在運行時效率方面，智能指針的不同操作會帶來不同程度的開銷。
std::shared_ptr的拷貝和賦值操作相對較為復雜，因為它們需要更新引用計數(shù)，這涉及到原子操作（在多線程環(huán)境下）或者簡單的計數(shù)增減（在單線程環(huán)境下），會帶來一定的性能開銷。例如，在一個頻繁進行對象拷貝和賦值的場景中，如果使用std::shared_ptr，可能會導致程序的執(zhí)行速度變慢。
#include <iostream>
#include <memory>
#include <vector>
class MyClass {
public:
MyClass() {}
~MyClass() {}
};
int main() {
std::vector<std::shared_ptr<MyClass>> vec;
for (int i = 0; i < 1000000; ++i) {
// 頻繁創(chuàng)建和拷貝shared_ptr
std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
vec.push_back(ptr);
}
return 0;
}在上述代碼中，創(chuàng)建了大量的std::shared_ptr并進行拷貝操作，會消耗一定的時間和資源來維護引用計數(shù)。
std::unique_ptr的移動操作則相對高效，因為它只是簡單地轉(zhuǎn)移了對象的所有權(quán)，不需要進行復雜的計數(shù)操作，類似于將一個指針賦值給另一個指針，開銷較小。例如：
#include <iostream>
#include <memory>
#include <vector>
class MyClass {
public:
MyClass() {}
~MyClass() {}
};
int main() {
std::vector<std::unique_ptr<MyClass>> vec;
for (int i = 0; i < 1000000; ++i) {
// 頻繁創(chuàng)建和移動unique_ptr
std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
vec.push_back(std::move(ptr));
}
return 0;
}在多線程環(huán)境下，std::shared_ptr的引用計數(shù)操作是原子性的，這保證了在多個線程同時對同一個std::shared_ptr進行拷貝、賦值或者析構(gòu)等操作時，引用計數(shù)的正確性，避免了數(shù)據(jù)競爭和內(nèi)存泄漏等問題。但原子操作本身會帶來一定的性能開銷，相比之下，std::unique_ptr在多線程環(huán)境下，如果不需要共享資源，其獨占所有權(quán)的特性使得它在并發(fā)場景中更加高效，不需要額外的同步機制來保證引用計數(shù)的正確性。
為了優(yōu)化智能指針的性能，可以考慮以下幾點：
- 在不需要共享資源的情況下，盡量使用std::unique_ptr，避免std::shared_ptr的引用計數(shù)開銷。
- 對于std::shared_ptr，盡量減少不必要的拷貝和賦值操作，可以通過合理的對象設計和編程邏輯，減少對象的生命周期交叉，從而降低引用計數(shù)的更新頻率。
- 在多線程環(huán)境下，如果使用std::shared_ptr，要注意避免頻繁的線程切換和競爭，盡量將共享資源的訪問和操作集中在一個線程或者通過合適的同步機制進行協(xié)調(diào)，以減少原子操作的開銷。
通過實際的性能測試數(shù)據(jù)可以更直觀地了解智能指針的性能差異。例如，使用專業(yè)的性能測試工具，對不同智能指針在相同操作場景下的執(zhí)行時間、內(nèi)存使用情況等指標進行測量，可以發(fā)現(xiàn)std::unique_ptr在簡單的對象生命周期管理場景中，執(zhí)行速度通常比std::shared_ptr快，尤其是在對象頻繁創(chuàng)建和銷毀的情況下。而std::shared_ptr在需要資源共享的場景中，雖然存在一定的性能開銷，但它提供的共享機制是std::unique_ptr無法替代的，在實際應用中需要根據(jù)具體的需求來權(quán)衡選擇合適的智能指針類型，并結(jié)合適當?shù)膬?yōu)化策略，以達到最佳的性能表現(xiàn)。
Part7.實際場景應用案例
案例一：資源管理
在實際開發(fā)中，很多時候我們需要管理一些系統(tǒng)資源，比如文件句柄、數(shù)據(jù)庫連接等。如果這些資源沒有被正確釋放，會導致資源浪費，甚至影響整個系統(tǒng)的穩(wěn)定性。智能指針在這方面能發(fā)揮很大的作用。
假設我們開發(fā)一個文件處理程序，需要讀取文件內(nèi)容并進行一些處理。在傳統(tǒng)的方式中，我們需要手動打開文件、讀取內(nèi)容，最后關(guān)閉文件。如果在讀取過程中出現(xiàn)異常，很容易忘記關(guān)閉文件，導致文件句柄泄漏。使用std::unique_ptr結(jié)合自定義刪除器，可以很好地解決這個問題。代碼示例如下：
#include <iostream>
#include <memory>
#include <fstream>
// 自定義文件關(guān)閉函數(shù)
void closeFile(std::ifstream* file) {
if (file->is_open()) {
file->close();
}
delete file;
}
void processFile(const std::string& filename) {
// 使用std::unique_ptr管理文件句柄，傳入自定義刪除器closeFile
std::unique_ptr<std::ifstream, decltype(&closeFile)> file(new std::ifstream(filename), closeFile);
if (!file) {
std::cerr << "無法打開文件: " << filename << std::endl;
return;
}
std::string line;
while (std::getline(*file, line)) {
// 處理文件內(nèi)容，這里簡單打印每一行
std::cout << line << std::endl;
}
}
int main() {
processFile("example.txt");
return 0;
}在上述代碼中，std::unique_ptr<std::ifstream, decltype(&closeFile)> file(new std::ifstream(filename), closeFile);創(chuàng)建了一個std::unique_ptr對象file，用于管理std::ifstream類型的文件句柄。第二個參數(shù)decltype(&closeFile)指定了自定義刪除器closeFile，當file離開作用域時，會自動調(diào)用closeFile函數(shù)來關(guān)閉文件并釋放內(nèi)存，確保文件句柄被正確釋放，避免了資源泄漏。
再來看一個數(shù)據(jù)庫連接的例子。在一個簡單的數(shù)據(jù)庫操作程序中，使用std::unique_ptr管理數(shù)據(jù)庫連接對象，確保連接在不再需要時被正確關(guān)閉。假設我們使用 MySQL C++ Connector 庫，示例代碼如下：
#include <memory>
#include <mysql/mysqlx.hpp>
// 自定義數(shù)據(jù)庫連接關(guān)閉函數(shù)
void closeConnection(mysqlx::Session* session) {
session->close();
delete session;
}
void performDatabaseOperations() {
// 建立數(shù)據(jù)庫連接，這里的連接參數(shù)是示例，實際中需要根據(jù)數(shù)據(jù)庫配置修改
std::unique_ptr<mysqlx::Session, decltype(&closeConnection)> session(new mysqlx::Session("localhost", 33060, "user", "password"), closeConnection);
// 使用session進行數(shù)據(jù)庫操作，這里簡單查詢一個表
auto schema = session->getSchema("test_schema");
auto table = schema.getTable("test_table");
auto result = table.select("*").execute();
while (auto row = result.fetchOne()) {
// 處理查詢結(jié)果，這里簡單打印每一行
std::cout << row[0] << " " << row[1] << std::endl;
}
}
int main() {
performDatabaseOperations();
return 0;
}在這個例子中，std::unique_ptr<mysqlx::Session, decltype(&closeConnection)> session(new mysqlx::Session("localhost", 33060, "user", "password"), closeConnection);創(chuàng)建了一個std::unique_ptr對象session來管理數(shù)據(jù)庫連接。當session離開作用域時，自定義刪除器closeConnection會被調(diào)用，關(guān)閉數(shù)據(jù)庫連接并釋放內(nèi)存，有效避免了數(shù)據(jù)庫連接泄漏。
案例二：對象生命周期管理
在游戲開發(fā)中，管理游戲角色對象的生命周期是一個常見且重要的任務。每個游戲角色都有自己的屬性和行為，并且在游戲運行過程中，角色可能會被創(chuàng)建、銷毀或者切換狀態(tài)。如果使用傳統(tǒng)的裸指針來管理這些角色對象，很容易出現(xiàn)內(nèi)存泄漏和懸空指針的問題，影響游戲的性能和穩(wěn)定性。而智能指針可以幫助我們輕松地管理游戲角色對象的生命周期，讓開發(fā)者能夠更加專注于游戲邏輯的實現(xiàn)。
以一個簡單的角色扮演游戲（RPG）為例，我們有一個Character類來表示游戲角色，每個角色有名字、生命值、攻擊力等屬性，以及移動、攻擊等行為。使用std::shared_ptr來管理Character對象，這樣多個游戲系統(tǒng)（如戰(zhàn)斗系統(tǒng)、場景系統(tǒng)等）可以共享同一個角色對象，而不用擔心對象的生命周期問題。示例代碼如下：
#include <iostream>
#include <memory>
#include <string>
class Character {
public:
Character(const std::string& name, int health, int attack)
: name(name), health(health), attack(attack) {}
void move(int x, int y) {
std::cout << name << " 移動到坐標 (" << x << ", " << y << ")" << std::endl;
}
void attack(Character& target) {
target.health -= attack;
std::cout << name << " 攻擊了 " << target.name << "，" << target.name << " 的生命值剩余: " << target.health << std::endl;
}
private:
std::string name;
int health;
int attack;
};
void battle(std::shared_ptr<Character> attacker, std::shared_ptr<Character> target) {
attacker->attack(*target);
}
int main() {
// 創(chuàng)建兩個游戲角色
std::shared_ptr<Character> player1 = std::make_shared<Character>("戰(zhàn)士", 100, 20);
std::shared_ptr<Character> player2 = std::make_shared<Character>("法師", 80, 15);
// 進行戰(zhàn)斗
battle(player1, player2);
return 0;
}在上述代碼中，std::shared_ptr<Character> player1 = std::make_shared<Character>("戰(zhàn)士", 100, 20);和std::shared_ptr<Character> player2 = std::make_shared<Character>("法師", 80, 15);分別創(chuàng)建了兩個std::shared_ptr對象player1和player2，指向兩個Character對象。在battle函數(shù)中，attacker->attack(*target);通過std::shared_ptr來調(diào)用角色的攻擊方法，實現(xiàn)了戰(zhàn)斗邏輯。當player1和player2離開作用域時，由于std::shared_ptr的引用計數(shù)機制，只有當沒有任何std::shared_ptr指向?qū)腃haracter對象時，對象才會被銷毀，從而確保了游戲角色對象的生命周期被正確管理。
再考慮一種更復雜的情況，游戲中存在一個場景，場景中包含多個游戲角色，并且角色可能會進入或離開場景。我們可以使用std::vector<std::shared_ptr<Character>>來管理場景中的角色。示例代碼如下：
#include <iostream>
#include <memory>
#include <string>
#include <vector>
class Character {
public:
Character(const std::string& name, int health, int attack)
: name(name), health(health), attack(attack) {}
void move(int x, int y) {
std::cout << name << " 移動到坐標 (" << x << ", " << y << ")" << std::endl;
}
void attack(Character& target) {
target.health -= attack;
std::cout << name << " 攻擊了 " << target.name << "，" << target.name << " 的生命值剩余: " << target.health << std::endl;
}
private:
std::string name;
int health;
int attack;
};
class Scene {
public:
void addCharacter(const std::shared_ptr<Character>& character) {
characters.push_back(character);
std::cout << character->name << " 進入了場景" << std::endl;
}
void removeCharacter(const std::shared_ptr<Character>& character) {
for (auto it = characters.begin(); it != characters.end(); ++it) {
if (*it == character) {
characters.erase(it);
std::cout << character->name << " 離開了場景" << std::endl;
return;
}
}
}
void displayCharacters() {
std::cout << "場景中的角色有: ";
for (const auto& character : characters) {
std::cout << character->name << " ";
}
std::cout << std::endl;
}
private:
std::vector<std::shared_ptr<Character>> characters;
};
int main() {
std::shared_ptr<Character> player1 = std::make_shared<Character>("戰(zhàn)士", 100, 20);
std::shared_ptr<Character> player2 = std::make_shared<Character>("法師", 80, 15);
Scene scene;
scene.addCharacter(player1);
scene.addCharacter(player2);
scene.displayCharacters();
scene.removeCharacter(player1);
scene.displayCharacters();
return 0;
}在這個例子中，Scene類使用std::vector<std::shared_ptr<Character>>來存儲場景中的角色。addCharacter方法用于將角色添加到場景中，removeCharacter方法用于將角色從場景中移除，displayCharacters方法用于顯示場景中的所有角色。通過std::shared_ptr，我們可以方便地管理角色在場景中的生命周期，并且可以在不同的場景和游戲系統(tǒng)中共享角色對象，大大簡化了游戲開發(fā)中對象生命周期管理的復雜性 。
Part8.智能指針避坑指南
8.1循環(huán)引用問題
在使用std::shared_ptr時，循環(huán)引用是一個需要特別注意的問題。當兩個或多個對象通過std::shared_ptr相互引用時，就會形成循環(huán)引用。這種情況下，對象的引用計數(shù)永遠不會降為 0，導致內(nèi)存無法釋放，從而造成內(nèi)存泄漏。
我們來看一個具體的示例：
#include <memory>
#include <iostream>
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
~A() {
std::cout << "A的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
class B {
public:
std::shared_ptr<A> a_ptr;
~B() {
std::cout << "B的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// 這里a和b離開作用域，但由于循環(huán)引用，它們的引用計數(shù)不會降為0，A和B對象不會被銷毀
return 0;
}在上述代碼中，A類和B類通過std::shared_ptr相互引用，形成了循環(huán)引用。當main函數(shù)結(jié)束時，a和b離開作用域，但由于循環(huán)引用，它們的引用計數(shù)不會降為 0，A和B對象不會被銷毀，從而導致內(nèi)存泄漏。
為了解決循環(huán)引用問題，我們可以使用std::weak_ptr 。std::weak_ptr是一種弱引用指針，它不會增加對象的引用計數(shù)。當std::weak_ptr指向的對象被銷毀時，std::weak_ptr會自動失效。我們將上述代碼修改如下：
#include <memory>
#include <iostream>
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
~A() {
std::cout << "A的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
class B {
public:
std::weak_ptr<A> a_ptr;
~B() {
std::cout << "B的析構(gòu)函數(shù)被調(diào)用" << std::endl;
}
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// 這里a和b離開作用域，由于b中的a_ptr是weak_ptr，不會增加引用計數(shù)，A和B對象會被正確銷毀
return 0;
}在修改后的代碼中，B類中的a_ptr改為了std::weak_ptr ，這樣就打破了循環(huán)引用。當main函數(shù)結(jié)束時，a和b離開作用域，A和B對象的引用計數(shù)能夠正確降為 0，它們的析構(gòu)函數(shù)被調(diào)用，對象被正確銷毀。
8.2性能考慮
在使用智能指針時，性能也是一個需要考慮的因素。不同類型的智能指針在性能上有一定的差異，尤其是std::shared_ptr，由于其引用計數(shù)機制，會帶來一些額外的開銷。
std::shared_ptr使用引用計數(shù)來管理對象的生命周期，每次復制或銷毀std::shared_ptr時，都需要更新引用計數(shù)。這個過程需要進行原子操作，以確保在多線程環(huán)境下的正確性，這就會帶來一定的性能開銷。例如，在一個性能敏感的循環(huán)中，如果頻繁地創(chuàng)建、復制和銷毀std::shared_ptr，可能會對程序的性能產(chǎn)生較大的影響。
我們來看一個簡單的性能測試示例，比較使用std::unique_ptr和std::shared_ptr在大量對象創(chuàng)建和銷毀時的性能差異：
#include <iostream>
#include <memory>
#include <chrono>
const int numObjects = 1000000;
void testUniquePtrPerformance() {
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < numObjects; ++i) {
std::unique_ptr<int> ptr = std::make_unique<int>(i);
// 這里可以進行一些對ptr的操作，為了簡單，此處省略
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
std::cout << "使用std::unique_ptr的時間: " << duration << " 毫秒" << std::endl;
}
void testSharedPtrPerformance() {
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < numObjects; ++i) {
std::shared_ptr<int> ptr = std::make_shared<int>(i);
// 這里可以進行一些對ptr的操作，為了簡單，此處省略
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
std::cout << "使用std::shared_ptr的時間: " << duration << " 毫秒" << std::endl;
}
int main() {
testUniquePtrPerformance();
testSharedPtrPerformance();
return 0;
}在這個示例中，testUniquePtrPerformance函數(shù)使用std::unique_ptr進行了numObjects次對象的創(chuàng)建和銷毀操作，testSharedPtrPerformance函數(shù)則使用std::shared_ptr進行相同的操作。通過測量這兩個函數(shù)的執(zhí)行時間，可以直觀地看到std::shared_ptr由于引用計數(shù)帶來的性能開銷。
在實際應用中，如果對性能要求較高，并且對象的所有權(quán)關(guān)系明確，不需要共享所有權(quán)，那么優(yōu)先使用std::unique_ptr會是更好的選擇。std::unique_ptr的實現(xiàn)相對簡單，沒有引用計數(shù)的開銷，性能更高，內(nèi)存占用也更小。只有在確實需要共享對象所有權(quán)的情況下，才使用std::shared_ptr，并且要注意避免不必要的復制和銷毀操作，以減少引用計數(shù)帶來的性能影響。
