2. 程式人生 > >C++ 智能指針學習

C++ 智能指針學習

阿新 • • 發佈：2017-06-07
release new div str 我們 指針的引用 機制 cin 轉化

C++ Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176 		/*
SmartPtr.cpp
Author: Michael Joessy
Date： 2017-06-07
Marks: C++裏面的四個智能指針: auto_ptr, shared_ptr, weak_ptr, unique_ptr;
其中後三個是C++11支持，並且第一個已經被C++11棄用。

為什麽要使用智能指針：
我們知道C++的內存管理是讓很多人頭疼的事，當我們寫一個new語句時，一般就會立即把delete語句直接也寫了;
但是我們不能避免程序還未執行到delete時就跳轉了或者在函數中沒有執行到最後的delete語句就返回了;
如果我們不在每一個可能跳轉或者返回的語句前釋放資源，就會造成內存泄露。
使用智能指針可以很大程度上的避免這個問題:
因為智能指針就是一個類，當超出了類的作用域是，類會自動調用析構函數，析構函數會自動釋放資源。
*/


#include <memory>
#include <iostream>
#include <string>

using namespace std;
using namespace std::tr1;

//auto_ptr http://www.cplusplus.com/reference/memory/auto_ptr/
//unique_ptr http://www.cplusplus.com/reference/memory/unique_ptr/
//share_ptr http://www.cplusplus.com/reference/memory/share_ptr/
//weak_ptr http://www.cplusplus.com/reference/memory/weak_ptr/
class TestSmartPtr
{
public:
TestSmartPtr(string str)
{
m_str = str;
cout << "TestSmartPtr creat\n";
}
~TestSmartPtr()
{
cout << "TestSmartPtr delete:" << m_str <<endl;
}
string& getStr()
{
return m_str;
}
void setStr(string str)
{
m_str = str;
}
void print()
{
cout << m_str << endl;
}
private:
string m_str;
};


class classB;
class classA
{
public:
//shared_ptr<classB> pB_;
 weak_ptr<classB> pB_;
~classA()
{
cout << "classA delete\n";
}
};
class classB
{
public:
shared_ptr<classA> pA_;
~classB()
{
cout << "classB delete\n";
}
};


int main(void)
{
//auto_ptr
 /*成員函數get()返回一個原始的指針，成員函數reset()重新綁定指向的對象，而原來的對象則會被釋放
判斷一個智能指針是否為空應該使用if(pTestAutoPtr.get() == NULL)
成員函數release()只是把智能指針賦值為空，但是它原來指向的內存並沒有被釋放，相當於它只是釋放了對資源的所有權
當我們想要在中途釋放資源，而不是等到智能指針被析構時才釋放，我們可以使用pTestAutoPtr.reset(); 語句。
*/
#if 0
auto_ptr<TestSmartPtr> pTestAutoPtr(new TestSmartPtr("315"));
if(pTestAutoPtr.get() == NULL)
{
cout << "pTestAutoPtr = NULL\n";
}
pTestAutoPtr->setStr("Michael ");
pTestAutoPtr->print();
pTestAutoPtr.get()->print();
pTestAutoPtr->getStr() += "Joessy !";
(*pTestAutoPtr).print();
pTestAutoPtr.reset(new TestSmartPtr("315"));
pTestAutoPtr->print();
pTestAutoPtr.release();
#endif
//unique_ptr
 /*unique_ptr 是一個獨享所有權的智能指針，它提供了嚴格意義上的所有權，包括：
1、擁有它指向的對象
2、無法進行復制構造，無法進行復制賦值操作。即無法使兩個unique_ptr指向同一個對象。但是可以進行移動構造和移動賦值操作
3、保存指向某個對象的指針，當它本身被刪除釋放的時候，會使用給定的刪除器釋放它指向的對象
unique_ptr 可以實現如下功能：
1、為動態申請的內存提供異常安全
2、動態申請的內存所有權傳遞給某函數
3、從某個函數返回動態申請內存的所有權
4、在容器中保存指針
5、auto_ptr應該具有的功能
*/
#if 0
unique_ptr<int> up(p);
unique_ptr<TestSmartPtr> pTestUniquePtr1(new TestSmartPtr("123"));
unique_ptr<TestSmartPtr> pTestUniquePtr2(new TestSmartPtr("456"));
pTestUniquePtr1->print();
pTestUniquePtr2 = std::move(pTestUniquePtr1); //不能直接pTestUniquePtr2 = pTestUniquePtr1
 if(pTestUniquePtr1 == NULL)
{
cout << "pTestUniquePtr1 = NULL\n";
}
TestSmartPtr* p = pTestUniquePtr2.release();
p->print();
pTestUniquePtr1.reset(p);
pTestUniquePtr1->print();
#endif
//share_ptr
 /* 從share中就可以看出資源可以被多個指針共享，它使用計數機制來表明資源被幾個指針共享。
可以通過成員函數use_count()來查看資源的所有者個數。
除了可以通過new來構造，還可以通過傳入auto_ptr, unique_ptr,weak_ptr來構造。
當我們調用release()時，當前指針會釋放資源所有權，計數減一。
當計數等於0時，資源會被釋放。
*/
#if 0
shared_ptr<TestSmartPtr> pTestSharePtr1(new TestSmartPtr("123"));
shared_ptr<TestSmartPtr> pTestSharePtr2(new TestSmartPtr("456"));
cout << pTestSharePtr2->getStr()<<endl;
cout << pTestSharePtr2.use_count()<<endl;
pTestSharePtr1 = pTestSharePtr2; //"456"引用次數加1，"123"銷毀
 pTestSharePtr1->print();
cout << pTestSharePtr2.use_count() << endl;
cout << pTestSharePtr1.use_count() << endl;
pTestSharePtr1.reset();
pTestSharePtr2.reset(); //此時"456"銷毀
#endif
//weak_ptr
 /*weak_ptr是用來解決shared_ptr相互引用時的死鎖問題;
如果說兩個shared_ptr相互引用,那麽這兩個指針的引用計數永遠不可能下降為0,資源永遠不會釋放。
它是對對象的一種弱引用，不會增加對象的引用計數，和shared_ptr之間可以相互轉化;
shared_ptr可以直接賦值給它，它可以通過調用lock函數來獲得shared_ptr。
*/
#if 0
shared_ptr<classB> pB(new classB());
shared_ptr<classA> pA(new classA());
pB->pA_ = pA;
pA->pB_ = pB;
cout << pB.use_count() << endl;
cout << pA.use_count() << endl;
#endif
/*說明：
pA與pB之間互相引用，兩個資源的引用計數為2;
當要跳出函數時，智能指針pA與pB析構時兩個資源引用計數會減一;
但是兩者引用計數還是為1，導致跳出函數時資源沒有被釋放（classA與classB的析構函數沒有被調用）.

如果把其中一個改為weak_ptr就可以了，我們把類A裏面的shared_ptr<B> pB_; 改為weak_ptr<B> pb_;
這樣的話，資源classB的引用開始就只有1;
當pB析構時，B的計數變為0，B得到釋放;
B釋放的同時也會使A的計數減一;
同時pa析構時使A的計數減一，那麽A的計數為0，A得到釋放。
*/


cin.get();
return 0;
}

C++ 智能指針學習

相關推薦

C++ 智能指針學習

release new div str 我們 指針的引用 機制 cin 轉化 C++ Code 1234567891011121314151617181920212223242526272829303132333435363738394041424344454

深入學習c++--智能指針

typedef mem stream obj ptr oid const class () 1. 幾種智能指針 1. auto_ptr: c++11中推薦不使用他 2. shared_ptr: 每添加一次引用 就+1，減少一次引用，就-1；做到指針進行共享 3. un

深入學習c++--智能指針(二) weak_ptr（打破shared_ptr循環引用）

aud nbsp else 之間 沒有 kobject 智能 one 訪問 1. 幾種智能指針 1. auto_ptr: c++11中推薦不使用他(放棄) 2. shared_ptr: 每添加一次引用 就+1，減少一次引用，就-1；做到指針進行共享 3. unique

深入學習c++--智能指針(四)--使用建議

入學 接口 isp -- div 分享 技術 nbsp 析構函數 1. 不要自己手動管理資源 2. 一個裸指針不要用兩個shared_ptr管理，unique_ptr 3. 使用shared_ptr作為函數的接口，如果有可能用 const shared_ptr&am

C++智能指針剖析（下）boost::shared_ptr&其他

剖析 smart_ptr mage open log gin 內部使用 聲明 虛基類 1. boost::shared_ptr 前面我已經講解了兩個比較簡單的智能指針，它們都有各自的優缺點。由於 boost::scoped_ptr 獨享所有權，當我們真真需要復制智能指針時，

C++ 智能指針詳解（轉）

include 復雜 測試類 信息 思想 編譯 應該 其他 eas C++ 智能指針詳解 一、簡介 由於 C++ 語言沒有自動內存回收機制，程序員每次 new 出來的內存都要手動 delete。程序員忘記 delete，流程太復雜，最終導致沒有 delete，異常導致程

Qt 智能指針學習

賦值 寫時復制 qlabel rcu 無法 .exe exec 4.3 g++ 從內存泄露開始？ 很簡單的入門程序，應該比較熟悉吧 ^_^ #include <QApplication> #include <QLabel> int main(int

C++智能指針

ring 標準 [] image space 創建 配對 優點 object 智能指針模板類 智能指針是行為類似於指針的類對象，但這種對象還有其他功能。本文章介紹三個可幫助管理動態內存分配的只能指針模板。先來看需要哪些功能以及這些功能是如何實現的。請看下面的函數 v

C++智能指針和普通指針轉換需要註意的問題

情況 問題 ret 臨時 share 沒有 崩潰 ostream 初始 指針是柄雙刃劍，用的好，就會威力倍增；用的稍有閃失，就會造成悲劇。 自從c++11引入智能指針shared_ptr後，我們似乎再也不用擔心new的內存沒有釋放之類的問題了，但是，這樣就萬無一失了嗎？ 答

c++ 智能指針（轉）

intent boost uniq get() 不支持 句柄 另一個 ces c++ 智能指針 智能指針的使用 智能指針是在 <memory> 標頭文件中的 std 命名空間中定義的。 它們對 RAII 或“獲取資源即初始化”編程慣用法至關重要。 此習慣用法的主

你說你會C++? —— 智能指針

tro eset 釋放內存 拷貝 blog 成員 一個棧 屏蔽 lease 智能指針的設計初衷是： C++中沒有提供自己主動回收內存的機制，每次new對象之後都須要手動delete。稍不註意就

27.C++- 智能指針

隱式 ++ public auto_ptr val new 文件 weak pre 智能指針 在C++庫中最重要的類模板之一 智能指針實際上是將指針封裝在一個類裏,通過對象來管理指針. STL中的智能指針auto_ptr 頭文件: <memory

C++智能指針,指針容器原理及簡單實現(auto_ptr,scoped_ptr,ptr_vector).

同時 構造對象 pop 所有 main 操作 bject str 運算 目錄 C++智能指針,指針容器原理及簡單實現(auto_ptr,scoped_ptr,ptr_vector). auto_ptr scoped_ptr ptr_vector C++智能指針,指針容器

C++ 智能指針的簡單實現

lse temp 如何實現 template 負責 delete 具體實現 inf 直接 智能指針的用處：在c++中，使用普通指針容易造成堆內存的泄露問題，即程序員會忘記釋放，以及二次釋放，程序發生異常時內存泄漏等問題，而使用智能指針可以更好的管理堆內存。註意，在這裏智能

c/c++ 智能指針 unique_ptr 使用

而不是 eve reset str work table tab cout com 智能指針 unique_ptr 使用 和shared_ptr不同，可以有多個shared_ptr指向同一個內存，只能有1個unique_ptr指向某個內存。因此unique_ptr不支持普通

C++智能指針的實現

cnblogs 智能 new blog tor nbsp urn operator log 轉自 C++11中智能指針的原理、使用、實現 #include <iostream> #include <memory> template<

c++智能指針和二叉樹(1): 圖解層序遍歷和逐層打印二叉樹

發生 子節點 lse 局部對象 根節點 縮進 nts 思路 layer 二叉樹是極為常見的數據結構，關於如何遍歷其中元素的文章更是數不勝數。 然而大多數文章都是講解的前序/中序/後序遍歷，有關逐層打印元素的文章並不多，已有文章的講解也較為晦澀讀起來不得要領。本文將用形象的圖

C++學習筆記5_智能指針

ret 使用 delete 智能 模板 public del () let 1. 一般的指針int main(void){ int *p=new int; *p=20; delete p; return 0;}智能指針能自動回收#include<memory>

C++筆記(12)：動態內存和智能指針

style round 運算 span tro 運算符 delet 庫函數 針對 　　　　　　　　　　　　　　　　　　　　　　　　　　動態內存和智能指針 動態內存： 　　1.針對堆裏面存放的對象 　　2.使用new delete運算符 　　3.智能指針：shared_ptr

C++11中智能指針的原理、使用、實現

his animal something include expire another .cn 表現 oid 目錄 理解智能指針的原理 智能指針的使用 智能指針的設計和實現 1.智能指針的作用 C++程序設計中使用堆內存是非