一文掌握C++ 智能指針全部用法
為什么要學習智能指針？
咳咳，這個問題不是問大家的，是詢問我自己的！
我依稀記得剛離校出來找實習工作那會，去面試一份工作，其中有一個環(huán)節(jié)需要答題；有一道題目就是問什么是智能指針？臥槽？當時我就懵逼，智能指針我壓根就沒有聽說過…
最后，面試的這份工作理所應當?shù)狞S了。
差不多是一年前左右吧，現(xiàn)在趁有閑余時間，學習一下智能指針，豐富一下自己！
一、為什么要使用智能指針
一句話帶過：智能指針就是幫我們C++程序員管理動態(tài)分配的內(nèi)存的，它會幫助我們自動釋放new出來的內(nèi)存，從而避免內(nèi)存泄漏！
如下例子就是內(nèi)存泄露的例子：
#include <iostream>
#include <string>
#include <memory>
using namespace std;
// 動態(tài)分配內(nèi)存，沒有釋放就return
void memoryLeak1() {
string *str = new string("動態(tài)分配內(nèi)存！");
return;
}
// 動態(tài)分配內(nèi)存，雖然有些釋放內(nèi)存的代碼，但是被半路截胡return了
int memoryLeak2() {
string *str = new string("內(nèi)存泄露！");
// ...此處省略一萬行代碼
// 發(fā)生某些異常，需要結(jié)束函數(shù)
if (1) {
return -1;
}
delete str; // 雖然寫了釋放內(nèi)存的代碼，但是遭到函數(shù)中段返回，使得指針沒有得到釋放
return 1;
}
int main(void) {
memoryLeak1();
memoryLeak2();
return 0;
}
memoryLeak1函數(shù)中，new了一個字符串指針，但是沒有delete就已經(jīng)return結(jié)束函數(shù)了，導致內(nèi)存沒有被釋放，內(nèi)存泄露！
memoryLeak2函數(shù)中，new了一個字符串指針，雖然在函數(shù)末尾有些釋放內(nèi)存的代碼delete str，但是在delete之前就已經(jīng)return了，所以內(nèi)存也沒有被釋放，內(nèi)存泄露！
使用指針，我們沒有釋放，就會造成內(nèi)存泄露。但是我們使用普通對象卻不會！
思考：如果我們分配的動態(tài)內(nèi)存都交由有生命周期的對象來處理，那么在對象過期時，讓它的析構函數(shù)刪除指向的內(nèi)存，這看似是一個 very nice 的方案？
智能指針就是通過這個原理來解決指針自動釋放的問題！
- C++98 提供了 auto_ptr 模板的解決方案
- C++11 增加unique_ptr、shared_ptr 和weak_ptr
二、auto_ptr
auto_ptr 是c++ 98定義的智能指針模板，其定義了管理指針的對象，可以將new 獲得（直接或間接）的地址賦給這種對象。當對象過期時，其析構函數(shù)將使用delete 來釋放內(nèi)存！
用法:
頭文件: #include < memory >
用 法: auto_ptr<類型> 變量名(new 類型)
例 如:
auto_ptr< string > str(new string(“我要成為大牛~ 變得很牛逼！”));
auto_ptr<vector< int >> av(new vector< int >());
auto_ptr< int > array(new int[10]);
例：
我們先定義一個類，類的構造函數(shù)和析構函數(shù)都輸出一個字符串用作提示！
定義一個私有成員變量，賦值20.
再定義一個私有成員方法用于返回這個私有成員變量。
class Test {
public:
Test() { cout << "Test的構造函數(shù)..." << endl; }
~Test() { cout << "Test的析構函數(shù)..." << endl; }
int getDebug() { return this->debug; }
private:
int debug = 20;
};
當我們直接new這個類的對象，卻沒有釋放時。。。
int main(void) {
Test *test = new Test;
return 0;
}
可以看到，只是打印了構造函數(shù)這個字符串，而析構函數(shù)的字符卻沒有被打印，說明并沒有調(diào)用析構函數(shù)！這就導致了內(nèi)存泄露！
解決內(nèi)存泄露的辦法，要么手動delete，要么使用智能指針！
使用智能指針：
// 定義智能指針 auto_ptr<Test> test(new Test);
智能指針可以像普通指針那樣使用：
cout << "test->debug：" << test->getDebug() << endl; cout << "(*test).debug：" << (*test).getDebug() << endl;
這時再試試：
int main(void) {
//Test *test = new Test;
auto_ptr<Test> test(new Test);
cout << "test->debug：" << test->getDebug() << endl;
cout << "(*test).debug：" << (*test).getDebug() << endl;
return 0;
}
自動調(diào)用了析構函數(shù)。
為什么智能指針可以像普通指針那樣使用？？？
因為其里面重載了 * 和 -> 運算符， * 返回普通對象，而 -> 返回指針對象。
具體原因不用深究，只需知道他為什么可以這樣操作就像！
函數(shù)中返回的是調(diào)用get()方法返回的值，那么這個get()是什么呢？
智能指針的三個常用函數(shù)：
get() 獲取智能指針托管的指針地址
// 定義智能指針 auto_ptr<Test> test(new Test); Test *tmp = test.get(); // 獲取指針返回 cout << "tmp->debug：" << tmp->getDebug() << endl;
但我們一般不會這樣使用，因為都可以直接使用智能指針去操作，除非有一些特殊情況。
函數(shù)原型：
_NODISCARD _Ty * get() const noexcept
{ // return wrapped pointer
return (_Myptr);
}
release() 取消智能指針對動態(tài)內(nèi)存的托管
// 定義智能指針 auto_ptr<Test> test(new Test); Test *tmp2 = test.release(); // 取消智能指針對動態(tài)內(nèi)存的托管 delete tmp2; // 之前分配的內(nèi)存需要自己手動釋放
也就是智能指針不再對該指針進行管理，改由管理員進行管理！
函數(shù)原型：
_Ty * release() noexcept
{ // return wrapped pointer and give up ownership
_Ty * _Tmp = _Myptr;
_Myptr = nullptr;
return (_Tmp);
}
reset() 重置智能指針托管的內(nèi)存地址，如果地址不一致，原來的會被析構掉
// 定義智能指針 auto_ptr<Test> test(new Test); test.reset(); // 釋放掉智能指針托管的指針內(nèi)存，并將其置NULL test.reset(new Test()); // 釋放掉智能指針托管的指針內(nèi)存，并將參數(shù)指針取代之
reset函數(shù)會將參數(shù)的指針(不指定則為NULL)，與托管的指針比較，如果地址不一致，那么就會析構掉原來托管的指針，然后使用參數(shù)的指針替代之。然后智能指針就會托管參數(shù)的那個指針了。
函數(shù)原型：
void reset(_Ty * _Ptr = nullptr)
{ // destroy designated object and store new pointer
if (_Ptr != _Myptr)
delete _Myptr;
_Myptr = _Ptr;
}
使用建議：
盡可能不要將auto_ptr 變量定義為全局變量或指針；
// 沒有意義，全局變量也是一樣 auto_ptr<Test> *tp = new auto_ptr<Test>(new Test);
除非自己知道后果，不要把auto_ptr 智能指針賦值給同類型的另外一個 智能指針；
auto_ptr<Test> t1(new Test); auto_ptr<Test> t2(new Test); t1 = t2; // 不要這樣操作...
C++11 后auto_ptr 已經(jīng)被“拋棄”，已使用unique_ptr替代！C++11后不建議使用auto_ptr。
auto_ptr 被C++11拋棄的主要原因
1). 復制或者賦值都會改變資源的所有權
// auto_ptr 被C++11拋棄的主要原因
auto_ptr<string> p1(new string("I'm Li Ming!"));
auto_ptr<string> p2(new string("I'm age 22."));
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;
// p2賦值給p1后，首先p1會先將自己原先托管的指針釋放掉，然后接收托管p2所托管的指針，
// 然后p2所托管的指針制NULL，也就是p1托管了p2托管的指針，而p2放棄了托管。
p1 = p2;
cout << "p1 = p2 賦值后：" << endl;
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;
2). 在STL容器中使用auto_ptr存在著重大風險，因為容器內(nèi)的元素必須支持可復制和可賦值
vector<auto_ptr<string>> vec;
auto_ptr<string> p3(new string("I'm P3"));
auto_ptr<string> p4(new string("I'm P4"));
// 必須使用std::move修飾成右值，才可以進行插入容器中
vec.push_back(std::move(p3));
vec.push_back(std::move(p4));
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
// 風險來了：
vec[0] = vec[1]; // 如果進行賦值，問題又回到了上面一個問題中。
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
訪問越界了！
3). 不支持對象數(shù)組的內(nèi)存管理
auto_ptr<int[]> array(new int[5]); // 不能這樣定義
所以，C++11用更嚴謹?shù)膗nique_ptr 取代了auto_ptr！
測試代碼：
#include <iostream>
#include <string>
#include <memory>
#include <vector>
using namespace std;
class Test {
public:
Test() { cout << "Test的構造函數(shù)..." << endl; }
~Test() { cout << "Test的析構函數(shù)..." << endl; }
int getDebug() { return this->debug; }
private:
int debug = 20;
};
// 不要定義為全局變量，沒有意義
//auto_ptr<Test> test(new Test);
void memoryLeak1() {
//Test *test = new Test;
// 定義智能指針
auto_ptr<Test> test(new Test);
cout << "test->debug：" << test->getDebug() << endl;
cout << "(*test).debug：" << (*test).getDebug() << endl;
// get方法
Test *tmp = test.get(); // 獲取指針返回
cout << "tmp->debug：" << tmp->getDebug() << endl;
// release方法
Test *tmp2 = test.release(); // 取消智能指針對動態(tài)內(nèi)存的托管
delete tmp2; // 之前分配的內(nèi)存需要自己手動釋放
// reset方法：重置智能指針托管的內(nèi)存地址，如果地址不一致，原來的會被析構掉
test.reset(); // 釋放掉智能指針托管的指針內(nèi)存，并將其置NULL
test.reset(new Test()); // 釋放掉智能指針托管的指針內(nèi)存，并將參數(shù)指針取代之
// 忠告：不要將智能指針定義為指針
//auto_ptr<Test> *tp = new auto_ptr<Test>(new Test);
// 忠告：不要定義指向智能指針對象的指針變量
//auto_ptr<Test> t1(new Test);
//auto_ptr<Test> t2(new Test);
//t1 = t2;
return;
}
int memoryLeak2() {
//Test *test = new Test();
// 定義智能指針
auto_ptr<Test> test(new Test);
// ...此處省略一萬行代碼
// 發(fā)生某些異常，需要結(jié)束函數(shù)
if (1) {
return -1;
}
//delete test;
return 1;
}
int main1(void) {
//memoryLeak1();
//memoryLeak2();
//Test *test = new Test;
//auto_ptr<Test> test(new Test);
//cout << "test->debug：" << test->getDebug() << endl;
//cout << "(*test).debug：" << (*test).getDebug() << endl;
auto_ptr 被C++11拋棄的主要原因
//auto_ptr<string> p1(new string("I'm Li Ming!"));
//auto_ptr<string> p2(new string("I'm age 22."));
//
//cout << "p1：" << p1.get() << endl;
//cout << "p2：" << p2.get() << endl;
//p1 = p2;
//cout << "p1 = p2 賦值后：" << endl;
//cout << "p1：" << p1.get() << endl;
//cout << "p2：" << p2.get() << endl;
// 弊端2.在STL容器中使用auto_ptr存在著重大風險，因為容器內(nèi)的元素必須支持可復制
vector<auto_ptr<string>> vec;
auto_ptr<string> p3(new string("I'm P3"));
auto_ptr<string> p4(new string("I'm P4"));
vec.push_back(std::move(p3));
vec.push_back(std::move(p4));
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
// 風險來了：
vec[0] = vec[1];
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
// 弊端3.不支持對象數(shù)組的內(nèi)存管理
//auto_ptr<int[]> array(new int[5]); // 不能這樣定義
return 0;
}
三、unique_ptr
auto_ptr是用于C++11之前的智能指針。由于 auto_ptr 基于排他所有權模式：兩個指針不能指向同一個資源，復制或賦值都會改變資源的所有權。auto_ptr 主要有三大問題：
- 復制和賦值會改變資源的所有權，不符合人的直覺。
- 在 STL 容器中使用auto_ptr存在重大風險，因為容器內(nèi)的元素必需支持可復制（copy constructable）和可賦值（assignable）。
- 不支持對象數(shù)組的操作
以上問題已經(jīng)在上面體現(xiàn)出來了，下面將使用unique_ptr解決這些問題。
所以，C++11用更嚴謹?shù)膗nique_ptr 取代了auto_ptr！
unique_ptr 和 auto_ptr用法幾乎一樣，除了一些特殊。
unique_ptr特性
- 基于排他所有權模式：兩個指針不能指向同一個資源
- 無法進行左值unique_ptr復制構造，也無法進行左值復制賦值操作，但允許臨時右值賦值構造和賦值
- 保存指向某個對象的指針，當它本身離開作用域時會自動釋放它指向的對象。
- 在容器中保存指針是安全的
A. 無法進行左值復制賦值操作，但允許臨時右值賦值構造和賦值
unique_ptr<string> p1(new string("I'm Li Ming!"));
unique_ptr<string> p2(new string("I'm age 22."));
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;
p1 = p2; // 禁止左值賦值
unique_ptr<string> p3(p2); // 禁止左值賦值構造
unique_ptr<string> p3(std::move(p1));
p1 = std::move(p2); // 使用move把左值轉(zhuǎn)成右值就可以賦值了，效果和auto_ptr賦值一樣
cout << "p1 = p2 賦值后：" << endl;
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;
運行截圖：
B. 在 STL 容器中使用unique_ptr，不允許直接賦值
vector<unique_ptr<string>> vec;
unique_ptr<string> p3(new string("I'm P3"));
unique_ptr<string> p4(new string("I'm P4"));
vec.push_back(std::move(p3));
vec.push_back(std::move(p4));
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
vec[0] = vec[1]; /* 不允許直接賦值 */
vec[0] = std::move(vec[1]); // 需要使用move修飾，使得程序員知道后果
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
當然，運行后是直接報錯的，因為vec[1]已經(jīng)是NULL了，再繼續(xù)訪問就越界了。
C. 支持對象數(shù)組的內(nèi)存管理
// 會自動調(diào)用delete [] 函數(shù)去釋放內(nèi)存 unique_ptr<int[]> array(new int[5]); // 支持這樣定義
除了上面ABC三項外，unique_ptr的其余用法都與auto_ptr用法一致。
構造
class Test {
public:
Test() { cout << "Test的構造函數(shù)..." << endl; }
~Test() { cout << "Test的析構函數(shù)..." << endl; }
void doSomething() { cout << "do something......" << endl; }
};
// 自定義一個內(nèi)存釋放其
class DestructTest {
public:
void operator()(Test *pt) {
pt->doSomething();
delete pt;
}
};
// unique_ptr<T> up; 空的unique_ptr，可以指向類型為T的對象
unique_ptr<Test> t1;
// unique_ptr<T> up1(new T()); 定義unique_ptr,同時指向類型為T的對象
unique_ptr<Test> t2(new Test);
// unique_ptr<T[]> up; 空的unique_ptr，可以指向類型為T[的數(shù)組對象
unique_ptr<int[]> t3;
// unique_ptr<T[]> up1(new T[]); 定義unique_ptr,同時指向類型為T的數(shù)組對象
unique_ptr<int[]> t4(new int[5]);
// unique_ptr<T, D> up(); 空的unique_ptr，接受一個D類型的刪除器D，使用D釋放內(nèi)存
unique_ptr<Test, DestructTest> t5;
// unique_ptr<T, D> up(new T()); 定義unique_ptr,同時指向類型為T的對象，接受一個D類型的刪除器D，使用刪除器D來釋放內(nèi)存
unique_ptr<Test, DestructTest> t6(new Test);
賦值
unique_ptr<Test> t7(new Test); unique_ptr<Test> t8(new Test); t7 = std::move(t8); // 必須使用移動語義，結(jié)果，t7的內(nèi)存釋放，t8的內(nèi)存交給t7管理 t7->doSomething();
主動釋放對象
unique_ptr<Test> t9(new Test); t9 = NULL; t9 = nullptr; t9.reset();
放棄對象的控制權
Test *t10 = t9.release();
重置
t9.reset(new Test);
auto_ptr 與 unique_ptr智能指針的內(nèi)存管理陷阱
auto_ptr<string> p1;
string *str = new string("智能指針的內(nèi)存管理陷阱");
p1.reset(str); // p1托管str指針
{
auto_ptr<string> p2;
p2.reset(str); // p2接管str指針時，會先取消p1的托管，然后再對str的托管
}
// 此時p1已經(jīng)沒有托管內(nèi)容指針了，為NULL，在使用它就會內(nèi)存報錯！
cout << "str：" << *p1 << endl;
這是由于auto_ptr 與 unique_ptr的排他性所導致的！
為了解決這樣的問題，我們可以使用shared_ptr指針指針！
四、shared_ptr
熟悉了unique_ptr 后，其實我們發(fā)現(xiàn)unique_ptr 這種排他型的內(nèi)存管理并不能適應所有情況，有很大的局限！如果需要多個指針變量共享怎么辦？
如果有一種方式，可以記錄引用特定內(nèi)存對象的智能指針數(shù)量，當復制或拷貝時，引用計數(shù)加1，當智能指針析構時，引用計數(shù)減1，如果計數(shù)為零，代表已經(jīng)沒有指針指向這塊內(nèi)存，那么我們就釋放它！這就是 shared_ptr 采用的策略！
例：
class Person {
public:
Person(int v) {
this->no = v;
cout << "構造函數(shù) \t no = " << this->no << endl;
}
~Person() {
cout << "析構函數(shù) \t no = " << this->no << endl;
}
private:
int no;
};
// 仿函數(shù)，內(nèi)存刪除
class DestructPerson {
public:
void operator() (Person *pt) {
cout << "DestructPerson..." << endl;
delete pt;
}
};
引用計數(shù)的使用
調(diào)用use_count函數(shù)可以獲得當前托管指針的引用計數(shù)。
shared_ptr<Person> sp1; shared_ptr<Person> sp2(new Person(2)); // 獲取智能指針管控的共享指針的數(shù)量 use_count()：引用計數(shù) cout << "sp1 use_count() = " << sp1.use_count() << endl; cout << "sp2 use_count() = " << sp2.use_count() << endl << endl; // 共享 sp1 = sp2; cout << "sp1 use_count() = " << sp1.use_count() << endl; cout << "sp2 use_count() = " << sp2.use_count() << endl << endl; shared_ptr<Person> sp3(sp1); cout << "sp1 use_count() = " << sp1.use_count() << endl; cout << "sp2 use_count() = " << sp2.use_count() << endl; cout << "sp2 use_count() = " << sp3.use_count() << endl << endl;
如上代碼，sp1 = sp2; 和 shared_ptr< Person > sp3(sp1);就是在使用引用計數(shù)了。
sp1 = sp2; --> sp1和sp2共同托管同一個指針，所以他們的引用計數(shù)為2；
shared_ptr< Person > sp3(sp1); --> sp1和sp2和sp3共同托管同一個指針，所以他們的引用計數(shù)為3；
構造
1). shared_ptr< T > sp1; 空的shared_ptr，可以指向類型為T的對象
shared_ptr<Person> sp1; Person *person1 = new Person(1); sp1.reset(person1); // 托管person1
2). shared_ptr< T > sp2(new T()); 定義shared_ptr,同時指向類型為T的對象
shared_ptr<Person> sp2(new Person(2)); shared_ptr<Person> sp3(sp1);
3). shared_ptr<T[]> sp4; 空的shared_ptr，可以指向類型為T[]的數(shù)組對象 C++17后支持
shared_ptr<Person[]> sp4;
4). shared_ptr<T[]> sp5(new T[] { … }); 指向類型為T的數(shù)組對象 C++17后支持
shared_ptr<Person[]> sp5(new Person[5] { 3, 4, 5, 6, 7 });
5). shared_ptr< T > sp6(NULL, D()); //空的shared_ptr，接受一個D類型的刪除器，使用D釋放內(nèi)存
shared_ptr<Person> sp6(NULL, DestructPerson());
6). shared_ptr< T > sp7(new T(), D()); //定義shared_ptr,指向類型為T的對象，接受一個D類型的刪除器，使用D刪除器來釋放內(nèi)存
shared_ptr<Person> sp7(new Person(8), DestructPerson());
初始化
1). 方式一：構造函數(shù)
shared_ptr<int> up1(new int(10)); // int(10) 的引用計數(shù)為1 shared_ptr<int> up2(up1); // 使用智能指針up1構造up2, 此時int(10) 引用計數(shù)為2
2). 方式二：使用make_shared 初始化對象，分配內(nèi)存效率更高(推薦使用)
make_shared函數(shù)的主要功能是在動態(tài)內(nèi)存中分配一個對象并初始化它，返回指向此對象的shared_ptr; 用法：
make_shared<類型>(構造類型對象需要的參數(shù)列表);
shared_ptr<int> up3 = make_shared<int>(2); // 多個參數(shù)以逗號','隔開，最多接受十個
shared_ptr<string> up4 = make_shared<string>("字符串");
shared_ptr<Person> up5 = make_shared<Person>(9);
賦值
shared_ptrr<int> up1(new int(10)); // int(10) 的引用計數(shù)為1 shared_ptr<int> up2(new int(11)); // int(11) 的引用計數(shù)為1 up1 = up2; // int(10) 的引用計數(shù)減1,計數(shù)歸零內(nèi)存釋放，up2共享int(11)給up1, int(11)的引用計數(shù)為2
主動釋放對象
shared_ptrr<int> up1(new int(10)); up1 = nullptr ; // int(10) 的引用計數(shù)減1,計數(shù)歸零內(nèi)存釋放 // 或 up1 = NULL; // 作用同上
重置
p.reset() ; 將p重置為空指針，所管理對象引用計數(shù) 減1
p.reset(p1); 將p重置為p1（的值）,p 管控的對象計數(shù)減1，p接管對p1指針的管控
p.reset(p1,d); 將p重置為p1（的值），p 管控的對象計數(shù)減1并使用d作為刪除器
p1是一個指針！
交換
p1 和 p2 是智能指針
std::swap(p1,p2); // 交換p1 和p2 管理的對象，原對象的引用計數(shù)不變 p1.swap(p2); // 交換p1 和p2 管理的對象，原對象的引用計數(shù)不變
shared_ptr使用陷阱
shared_ptr作為被管控的對象的成員時，小心因循環(huán)引用造成無法釋放資源!
如下代碼：
Boy類中有Girl的智能指針；
Girl類中有Boy的智能指針；
當他們交叉互相持有對方的管理對象時…
#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Girl;
class Boy {
public:
Boy() {
cout << "Boy 構造函數(shù)" << endl;
}
~Boy() {
cout << "~Boy 析構函數(shù)" << endl;
}
void setGirlFriend(shared_ptr<Girl> _girlFriend) {
this->girlFriend = _girlFriend;
}
private:
shared_ptr<Girl> girlFriend;
};
class Girl {
public:
Girl() {
cout << "Girl 構造函數(shù)" << endl;
}
~Girl() {
cout << "~Girl 析構函數(shù)" << endl;
}
void setBoyFriend(shared_ptr<Boy> _boyFriend) {
this->boyFriend = _boyFriend;
}
private:
shared_ptr<Boy> boyFriend;
};
void useTrap() {
shared_ptr<Boy> spBoy(new Boy());
shared_ptr<Girl> spGirl(new Girl());
// 陷阱用法
spBoy->setGirlFriend(spGirl);
spGirl->setBoyFriend(spBoy);
// 此時boy和girl的引用計數(shù)都是2
}
int main(void) {
useTrap();
system("pause");
return 0;
}
運行截圖：
可以看出，程序結(jié)束了，但是并沒有釋放內(nèi)存，這是為什么呢？？？
如下圖：
當我們執(zhí)行useTrap函數(shù)時，注意，是沒有結(jié)束此函數(shù)，boy和girl指針其實是被兩個智能指針托管的，所以他們的引用計數(shù)是2
useTrap函數(shù)結(jié)束后，函數(shù)中定義的智能指針被清掉，boy和girl指針的引用計數(shù)減1，還剩下1，對象中的智能指針還是托管他們的，所以函數(shù)結(jié)束后沒有將boy和gilr指針釋放的原因就是于此。
所以在使用shared_ptr智能指針時，要注意避免對象交叉使用智能指針的情況！ 否則會導致內(nèi)存泄露！
當然，這也是有辦法解決的，那就是使用weak_ptr弱指針。
針對上面的情況，還講一下另一種情況。如果是單方獲得管理對方的共享指針，那么這樣著是可以正常釋放掉的！
例如：
void useTrap() {
shared_ptr<Boy> spBoy(new Boy());
shared_ptr<Girl> spGirl(new Girl());
// 單方獲得管理
//spBoy->setGirlFriend(spGirl);
spGirl->setBoyFriend(spBoy);
}
反過來也是一樣的！
這是什么原理呢？
- 首先釋放spBoy，但是因為girl對象里面的智能指針還托管著boy，boy的引用計數(shù)為2，所以釋放spBoy時，引用計數(shù)減1，boy的引用計數(shù)為1；
- 在釋放spGirl，girl的引用計數(shù)減1，為零，開始釋放girl的內(nèi)存，因為girl里面還包含有托管boy的智能指針對象，所以也會進行boyFriend的內(nèi)存釋放，boy的引用計數(shù)減1，為零，接著開始釋放boy的內(nèi)存。最終所有的內(nèi)存都釋放了。
五、weak_ptr
weak_ptr 設計的目的是為配合 shared_ptr 而引入的一種智能指針來協(xié)助 shared_ptr 工作, 它只可以從一個 shared_ptr 或另一個 weak_ptr 對象構造, 它的構造和析構不會引起引用記數(shù)的增加或減少。 同時weak_ptr 沒有重載*和->但可以使用 lock 獲得一個可用的 shared_ptr 對象。
- 弱指針的使用；
weak_ptr wpGirl_1; // 定義空的弱指針
weak_ptr wpGirl_2(spGirl); // 使用共享指針構造
wpGirl_1 = spGirl; // 允許共享指針賦值給弱指針
- 弱指針也可以獲得引用計數(shù)；
wpGirl_1.use_count()
- 弱指針不支持 * 和 -> 對指針的訪問；
在必要的使用可以轉(zhuǎn)換成共享指針 lock()；
shared_ptr<Girl> sp_girl; sp_girl = wpGirl_1.lock(); // 使用完之后，再將共享指針置NULL即可 sp_girl = NULL;
使用代碼：
shared_ptr<Boy> spBoy(new Boy()); shared_ptr<Girl> spGirl(new Girl()); // 弱指針的使用 weak_ptr<Girl> wpGirl_1; // 定義空的弱指針 weak_ptr<Girl> wpGirl_2(spGirl); // 使用共享指針構造 wpGirl_1 = spGirl; // 允許共享指針賦值給弱指針 cout << "spGirl \t use_count = " << spGirl.use_count() << endl; cout << "wpGirl_1 \t use_count = " << wpGirl_1.use_count() << endl; // 弱指針不支持 * 和 -> 對指針的訪問 /*wpGirl_1->setBoyFriend(spBoy); (*wpGirl_1).setBoyFriend(spBoy);*/ // 在必要的使用可以轉(zhuǎn)換成共享指針 shared_ptr<Girl> sp_girl; sp_girl = wpGirl_1.lock(); cout << sp_girl.use_count() << endl; // 使用完之后，再將共享指針置NULL即可 sp_girl = NULL;
當然這只是一些使用上的小例子，具體用法如下：
請看Boy類
#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Girl;
class Boy {
public:
Boy() {
cout << "Boy 構造函數(shù)" << endl;
}
~Boy() {
cout << "~Boy 析構函數(shù)" << endl;
}
void setGirlFriend(shared_ptr<Girl> _girlFriend) {
this->girlFriend = _girlFriend;
// 在必要的使用可以轉(zhuǎn)換成共享指針
shared_ptr<Girl> sp_girl;
sp_girl = this->girlFriend.lock();
cout << sp_girl.use_count() << endl;
// 使用完之后，再將共享指針置NULL即可
sp_girl = NULL;
}
private:
weak_ptr<Girl> girlFriend;
};
class Girl {
public:
Girl() {
cout << "Girl 構造函數(shù)" << endl;
}
~Girl() {
cout << "~Girl 析構函數(shù)" << endl;
}
void setBoyFriend(shared_ptr<Boy> _boyFriend) {
this->boyFriend = _boyFriend;
}
private:
shared_ptr<Boy> boyFriend;
};
void useTrap() {
shared_ptr<Boy> spBoy(new Boy());
shared_ptr<Girl> spGirl(new Girl());
spBoy->setGirlFriend(spGirl);
spGirl->setBoyFriend(spBoy);
}
int main(void) {
useTrap();
system("pause");
return 0;
}
在類中使用弱指針接管共享指針，在需要使用時就轉(zhuǎn)換成共享指針去使用即可！
自此問題完美解決！
六、智能指針的使用陷阱
不要把一個原生指針給多個智能指針管理;
int *x = new int(10);
unique_ptr< int > up1(x);
unique_ptr< int > up2(x);
// 警告! 以上代碼使up1 up2指向同一個內(nèi)存,非常危險
或以下形式：
up1.reset(x);
up2.reset(x);
記得使用u.release()的返回值;
在調(diào)用u.release()時是不會釋放u所指的內(nèi)存的，這時返回值就是對這塊內(nèi)存的唯一索引，如果沒有使用這個返回值釋放內(nèi)存或是保存起來，這塊內(nèi)存就泄漏了.
禁止delete 智能指針get 函數(shù)返回的指針;
如果我們主動釋放掉get 函數(shù)獲得的指針，那么智能 指針內(nèi)部的指針就變成野指針了，析構時造成重復釋放，帶來嚴重后果!
禁止用任何類型智能指針get 函數(shù)返回的指針去初始化另外一個智能指針！
shared_ptr< int > sp1(new int(10));
// 一個典型的錯誤用法 shared_ptr< int > sp4(sp1.get());
七、總結(jié)
智能指針雖然使用起來很方便，但是要注意使用智能指針的一些陷阱，否則會造成嚴重的內(nèi)存報錯或者內(nèi)存泄露等問題！
到此這篇關于一文掌握C++ 智能指針全部用法的文章就介紹到這了,更多相關c++智能指針用法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
C/C++?判斷計算機存儲器字節(jié)序（端序）的幾種方式
字節(jié)序是計算機存儲數(shù)據(jù)的格式,主存儲器（主存）的字節(jié)序?qū)Τ绦虻囊浦残院图嫒菪灾陵P重要,利用聯(lián)合體、指針、位移和掩碼等方法可以檢測和處理字節(jié)序問題,對于內(nèi)存數(shù)據(jù)操作重要,也關系到跨平臺和網(wǎng)絡通信的數(shù)據(jù)處理2024-10-10
C++實現(xiàn)LeetCode(88.混合插入有序數(shù)組)
這篇文章主要介紹了C++實現(xiàn)LeetCode(88.混合插入有序數(shù)組),本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內(nèi)容,需要的朋友可以參考下2021-07-07
這篇文章主要介紹了基于C++實現(xiàn)簡單日期計算器，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-05-05
OpenCV reshape函數(shù)實現(xiàn)矩陣元素序列化
reshape函數(shù)是OpenCV中一個很有用的函數(shù)，不僅可以改變矩陣的通道數(shù)，還可以對矩陣元素進行序列化。本文將主要介紹如何通過reshape實現(xiàn)矩陣元素序列化，需要的小伙伴可以參考一下2021-12-12
本文，將一步一步引導初學者來學習socket，所有編程思路都結(jié)合在socket API里面，以及提供socket的疑問和基礎知識點，同時在最后給出多個例程，下面可以和小編一起學習2019-05-05
這篇文章主要介紹了QString的常用方法(小結(jié))，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-12-12
項目之C++如何實現(xiàn)數(shù)據(jù)庫連接池
這篇文章主要介紹了項目之C++如何實現(xiàn)數(shù)據(jù)庫連接池問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-03-03
這篇文章主要為大家詳細介紹了C語言實現(xiàn)簡單三子棋游戲，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-09-09
在數(shù)學中,函數(shù)是一種基本的數(shù)學對象,它建立了一個集合（稱為定義域）中的每個元素與另一個集合（稱為值域）中的唯一元素之間的對應關系,這篇文章主要介紹了C++自定義函數(shù)示例詳解,需要的朋友可以參考下2025-03-03
這篇文章主要介紹了C++中的最小生成樹算法超詳細教程,最小生成樹的最著名的算法有兩個, 一個是Prim算法, 另一個當然就是Kruskal算法, 接下來, 我將盡我所能的介紹這兩個算法, 也算是對自己學習的一個回顧吧,需要的朋友可以參考下2023-08-08