C++ 智能指针学习

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;

}

时间： 2024-10-02 04:35:28

C++ 智能指针学习的相关文章

智能指针学习笔记

1. 介绍 本文介绍智能指针的使用.智能指针是c++ 中管理资源的一种方式,用智能指针管理资源,不必担心资源泄露,将c++ 程序员 从指针和内存管理中解脱出来,再者,这也是c++发展的趋势(这话不是我说的,见<Effective c++>和<c++实践编程>),应该认真学习一下. 智能指针中,最有名的应该数auto_ptr,该智能指针已经被纳入标准库,只需要包含<memory>头文件即可以使用,另外,TR1文档定义的shared_ptr和weak_ptr也已经实现(我用

[C/C++] 智能指针学习

一.简介 由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete.程序员忘记 delete,流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 delete 的情况并不罕见. 用智能指针便可以有效缓解这类问题,本文主要讲解参见的智能指针的用法.包括:std::auto_ptr.boost::scoped_ptr.boost::shared_ptr.boost::scoped_array.boost::shared_array.boost:

Qt 智能指针学习（7种QT智能指针和4种std智能指针）

从内存泄露开始? 很简单的入门程序,应该比较熟悉吧 ^_^ #include <QApplication> #include <QLabel> int main(int argc, char *argv[]) { QApplication app(argc, argv); QLabel *label = new QLabel("Hello Dbzhang800!"); label->show(); return app.exec(); } 在  从 Qt

Qt 智能指针学习（7种QT的特有指针）

从内存泄露开始? 很简单的入门程序,应该比较熟悉吧 ^_^ #include <QApplication> #include <QLabel> int main(int argc, char *argv[]) { QApplication app(argc, argv); QLabel *label = new QLabel("Hello Dbzhang800!"); label->show(); return app.exec(); } 在  从 Qt

Qt 智能指针学习

从内存泄露开始? 很简单的入门程序,应该比较熟悉吧 ^_^ #include <QApplication> #include <QLabel> int main(int argc, char *argv[]) { QApplication app(argc, argv); QLabel *label = new QLabel("Hello Dbzhang800!"); label->show(); return app.exec(); } 在  从 Qt

【C++深入浅出】智能指针之auto_ptr学习

起:  C++98标准加入auto_ptr,即智能指针,C++11加入shared_ptr和weak_ptr两种智能指针,先从auto_ptr的定义学习一下auto_ptr的用法. template<class _Ty> class auto_ptr { // wrap an object pointer to ensure destruction public: //定义_Myt类型,作用域局限于类中,便于书写和理解 typedef auto_ptr<_Ty> _Myt; typ

现代C++学习笔记之一入门篇：智能指针（C++ 11）

原始指针:通过new建立的*指针 智能指针:通过智能指针关键字(unique_ptr, shared_ptr ,weak_ptr)建立的指针 在现代 C++ 编程中,标准库包含智能指针,该指针用于确保程序不存在内存和资源泄漏且是异常安全的. 在现代 C++ 中,原始指针仅用于范围有限的小代码块.循环或者性能至关重要且不会混淆所有权的 Helper 函数中. 1 void UseRawPointer() 2 { 3 // Using a raw pointer -- not recommended

Binder学习笔记（十一）—— 智能指针

轻量级指针 Binder的学习历程爬到驱动的半山腰明显感觉越来越陡峭,停下业务层的学习,补补基础层知识吧,这首当其冲的就是智能指针了,智能指针的影子在Android源码中随处可见.打开frameworkds/rs/cpp/util,RefBase.h和StrongPointer.h两个文件,代码多读几遍都能读懂,可是串起来总感觉摸不到骨架,把不住主线.闭上眼零零星星的点串不成一条线.究其原因应该是此处使用了模式,最好先剔除掉业务层的皮肉,把模式的骨架摸个门清,再回来看代码就会势如破竹了. 不是多

【STL学习】智能指针之shared_ptr

前面已经学习过auto_ptr,这里补充另外一种智能指针,比auto_ptr要更强力更通用的shared_ptr. shared_ptr 简介及使用选择  几乎所有的程序都需要某种形式的引用计数智能指针,这种指针让我们不再需要为两个对象或更多对象共享的对象的生命周期而编写复杂的逻辑(写起来有点绕口),当被共享的对象引用计数降为0时,被共享对象被自动析构. 引用计数指针分为插入式(instrusive)和非插入式(non-instrusive)两种.前者要求它所管理的类提供明确的函数或数据成员用于