c++中的智能指针

0
11

目录

  1. 初识智能指针

    1.1内存泄漏的原因分析

    1.2内存泄漏的解决方案

  2.智能指针类模板

    2.1智能指针的意义

    2.2STL 中的智能指针应用

    2.3 QT 中的智能指针应用

    2.4智能指针模板类的实现

初识智能指针

  在c++语言中没有垃圾回收机制,内存泄漏这个问题就不得不让程序员自己来解决,稍有不慎就会给软件带来Bug,幸运的是我们可以使用智能指针去解决内存泄漏的问题。

1、 内存泄漏的原因分析

  (1)动态申请堆空间,用完后不归还;

  (2)C++ 语言中没有垃圾回收的机制;

  1)Java、C# 语言中都引入了垃圾回收机制,定期检测内存,若发现没有使用,则回收;

    2)垃圾回收机制可以很好的避免内存泄漏;

    3)C++ 中的动态内存申请和归还完全依赖开发者,稍有不慎就会出错;

  (3)指针无法控制所指堆空间的生命周期;(根本原因)

    1)通过指针可以指向动态内存空间,但是却不能够控制动态内存空间的生命周期;

    2)也就是指针和动态内存空间没有必然联系,即使指针变量销毁了,动态内存空间还可以存在;

  补充:多次释放多个指针指向的同一块堆空间也会使软件出现Bug;

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Test
 7 {
 8     int i;
 9 public:
10     Test(int i)
11     {
12         this->i = i;
13     }
14     int value()
15     {
16         return i;
17     }
18     ~Test()
19     {
20     }
21 };
22 
23 int main()
24 {
25     for(int i=0; i<5; i++)
26     {  
27          // 指针p指向所申请的堆空间,但是并没有手动归还这块内存;当进行下一次循环时,指针p又指向了一块新的堆空间,这样前一次的堆空间就永远无法归还了,
28          // 同时,指针p是一个局部变量,for循环结束后指针P就销毁了,这就意味着这片空间永远无法归还了;
29         Test* p = new Test(i); 
30         
31         cout << p->value() << endl;
32 
33         // delete p; // 正确做法:每次用完之后记得归还所申请的堆空间,否则就会造成内存泄漏
34     }
35     
36     return 0;
37 }

关于内存泄漏的案列

2、内存泄漏的解决方案

  需求分析 -> 解决方案:(结合案列更容易理解)

  (1)需要一个特殊的指针,即智能指针对象(普通类对象,通过重载指针操作符就可以使对象指向堆空间),通过类的构造函数完成;

  (2)指针生命周期结束时主动释放堆空间,可以通过类的析构函数完成;

  (3)一片堆空间最多只能由一个指针标识,为的是避免多次释放内存,通过拷贝构造函数和赋值操作符完成;

  (4)杜绝指针运算和指针比较;

    1)杜绝指针运算可以避免指针越界和野指针;

    2)上面的第三个需求满足了,指针比较就没有意义了;

    3)不重载类的运算符(算术运算符、关系运算符、++、–),当进行指针(类对象)运算与比较时,程序会编译失败。

  (5)重载指针特征操作符(-> 和 *);

 1)通过重载指针操作符使得类对象具备了指针的行为;

 2)创建一个类对象,让这个对象通过操作符重载模拟真正的指针行为;

    注:只能通过类的成员函数重载指针操作符,且该重载函数不能使用参数;

  通过类的成员函数重载指针特征操作符,从而使得类对象可以模拟指针的行为,这个类对象称为智能指针。

  使用智能指针的注意事项:只能指向堆空间的对象或变量,不允许指向堆数组、栈对象或变量。

  智能指针的表现形式:使用类对象来取代指针。

  1 #include <iostream>
  2 
  3 using namespace std;
  4 
  5 class Test
  6 {
  7     int i;
  8 public:
  9     Test(int i)
 10     {
 11         cout << "Test(int i)::" << i  << endl;
 12         this->i = i;
 13     }
 14     int value()
 15     {
 16         return i;
 17     }
 18     ~Test()
 19     {
 20         cout << "~Test()::" << i << endl;
 21     }
 22 };
 23 
 24 class Pointer
 25 {
 26 private:
 27     Test *mp;
 28 public:
 29     Pointer(Test *p = NULL)
 30     {
 31         mp = p;
 32     }
 33     Pointer(const Pointer& obj)
 34     {
 35         mp = obj.mp;
 36         const_cast<Pointer&>(obj).mp = NULL;
 37     }
 38     Pointer& operator=(const Pointer& obj)
 39     {
 40         if(this != &obj)
 41         {
 42             if(mp != NULL)
 43             {
 44                 delete mp;
 45             }
 46             mp = obj.mp;
 47             const_cast<Pointer&>(obj).mp = NULL;
 48         }
 49 
 50         return *this;
 51     }
 52     Test* operator->()
 53     {
 54         return mp;
 55     }
 56     Test& operator*()
 57     {
 58         return *mp;
 59     }
 60     bool isNull()
 61     {
 62         return (mp == NULL);
 63     }
 64     ~Pointer()
 65     {
 66         delete mp;
 67     }       
 68 
 69 };
 70 
 71 int main(int argc, char const *argv[])
 72 {
 73     cout << "-------1-------------" << endl;
 74     Pointer pt1 = new Test(10);     // Test(int i)::10
 75     cout << pt1->value() << endl;   // 10
 76     cout << (*pt1).value() << endl; // 10
 77 
 78     cout << "-------2-------------" << endl;
 79     Pointer pt2 = new Test(5);      // Test(int i)::5
 80     cout << pt2->value() << endl;   // 5
 81     
 82     cout << "-------3-------------" << endl;
 83     Pointer pt3 = pt2;              // 将指针pt2的使用权交给指针pt3
 84     cout << pt2.isNull() << endl;   // 1
 85     cout << pt3->value() << endl;   // 5
 86 
 87     cout << "-------4-------------" << endl;
 88     pt3 = pt1;                      // 将指针pt1的使用权交给指针pt3   // ~Test()::5
 89     cout << pt1.isNull() << endl;   // 1
 90 
 91     cout << "-------5-------------" << endl;
 92     Pointer pt4;
 93     pt4 = pt3;                      // 将指针pt3的使用权交给指针pt4   // ~Test()::10
 94     cout << pt3.isNull() << endl;   // 1
 95 
 96     return 0;
 97 }
 98 
 99 /**
100  *  智能指针的需求:
101  *  指针的生命周期结束时,主动的释放堆空间
102  *  一片堆空间最多只能由一个指针标识 
103  *  杜绝指针运算和指针比较
104  * 
105  *  使用智能指针的注意事项:只能指向堆空间的对象或变量,不允许指向堆数组、栈对象或变量
106  *  智能指针的表现形象:使用类对象来取代指针
107  *  
108  */

智能指针的实现

  注:这个案列只实现了一个类的内存回收,关于任意类的内存回收,会在后续的模板技术中介绍。

智能指针类模板

  知识回顾

  由于智能指针相关的类重载了指针操作符,所以其对象可以像原生的指针一样使用,本质上智能指针对象就是类对象。但是,此时的智能指针对象有很大的局限性,不能灵活的指向任意的类对象。为了解决这个问题,智能指针类模板就出现了。

1、智能指针的意义

  (1)现代 C++ 开发库中最重要的类模板之一;(如 STL 标准库、Qt)

  (2)是C++开发中自动内存管理的主要手段;

  (3)能够在很大程度上避开内存相关的问题。

2、STL中的智能指针应用

  (1)auto_ptr

    1)生命周期结束时,销毁指向的内存空间;(避免只借不还的现象出现)

    2)不能指向堆数组,只能指向堆对象(变量);(若需要使用堆数组,我们可以自己实现内存回收机制)

    3)一片堆空间只属于一个智能指针对象;或者,多个智能指针对象不能指向同一片堆空间;(避免多次释放同一个指针;)

  (2)shared_ptr

  带有引用计数机制,支持多个指针对象指向同一片内存;

  (3)weak_ptr

    配合 shared_ptr 而引入的一种智能指针;

  (4)unique_ptr

    一个指针对象指向一片内存空间,不能拷贝构造和赋值(auto_ptr 的进化版,没有使用权的转移);

 1 #include <iostream>
 2 #include <string>
 3 #include <memory>  // 智能指针类模板的头文件
 4 
 5 using namespace std;
 6 
 7 class Test
 8 {
 9     string m_name;
10 public:
11     Test(const char* name)
12     {
13         cout << "construct @" << name << endl;
14         
15         m_name = name;
16     }
17     
18     void print()
19     {
20         cout << "member @" << m_name << endl;
21     }
22     
23     ~Test()
24     {
25         cout << "destruct @" << m_name << endl;
26     }
27 };
28 
29 int main()
30 {
31     auto_ptr<Test> pt(new Test("smartPoint"));
32     
33     cout << "pt = " << pt.get() << endl;    // pt.get() 返回所申请堆空间的地址
34     
35     pt->print();
36     
37     cout << endl;
38     
39     auto_ptr<Test> pt1(pt); // pt 转移了对堆空间的控制权,指向 NULL;
40     
41     cout << "pt = " << pt.get() << endl;  
42     cout << "pt1 = " << pt1.get() << endl;
43     
44     pt1->print();
45     
46     return 0;
47 }
48 /**
49  * 运行结果:
50  * construct @smartPoint
51  * pt = 0x1329c20
52  * member @smartPoint
53  * 
54  * pt = 0
55  * pt1 = 0x1329c20
56  * member @smartPoint
57  * destruct @smartPoint
58  * /

auto_ptr 使用案列

3、QT 中的智能指针应用

  (1)QPointer

  1)当其指向的对象被销毁(释放)时,它会被自动置空;

   可以使用多个 QPointer 智能指针指向同一个对象,当这个对象被销毁的时候,所有的智能指针对象都变为空,这可以避免多次释放和野指针的问题。

  2)析构时不会自动销毁所指向的对象;(!!!)

  也就是当 QPointer 对象生命周期完结的时候,不会自动销毁堆空间中的对象,需要手动销毁;

  (2)QSharedPointer(和 STL中shared_ptr 相似)

  1)引用计数型智能指针(引用计数的对象是堆空间申请的对象);

    2)可以被自由地拷贝和赋值;

   3)当引用计数为 0 时,才删除指向的对象;(这个智能指针对象生命周期结束后,引用计数减一)

  (3)其它的智能指针(QweakPointer;QScopedPointer;QScopedArrayPointer;QSharedDataPointer;QExplicitlySharedDataPointer;)

  为什么QT要重新开发自己的内存管理机制,而不直接使用已有的STL中智能指针?

  这个和它的架构开发思想相关,因为 Qt 有自己的内存管理思想,但是这些思想并没有在 STL 中实现,为了将这种内存管理思想贯彻到 Qt 中的方方面面,所以Qt 才开发自己的智能指针类模板。  

 1 #include <QPointer>
 2 #include <QSharedPointer>
 3 #include <QDebug>
 4 
 5 class Test : public QObject  // Qt 开发中都要将类继承自 QObject
 6 {
 7     QString m_name;
 8 public:
 9     Test(const char* name)
10     {
11         qDebug() << "construct @" << name;
12 
13         m_name = name;
14     }
15 
16     void print()
17     {
18         qDebug() << "member @" << m_name;
19     }
20 
21     ~Test()
22     {
23         qDebug() << "destruct @" << m_name ;
24     }
25 };
26 
27 int main()
28 {
29     QPointer<Test> pt(new Test("smartPoint"));
30     QPointer<Test> pt1(pt);
31     QPointer<Test> pt2(pt);
32 
33     pt->print();
34     pt1->print();
35     pt2->print();
36 
37     delete pt;  // 手工删除,这里只用删除一次就可,上述三个指针都指向NULL;
38 
39     qDebug() << "pt = " << pt;  
40     qDebug() << "pt1 = " << pt1; 
41     qDebug() << "pt2 = " << pt2;
42 
43     qDebug() << "QPointer 与 QSharedPointer 的区别" << endl;
44 
45     QSharedPointer<Test> spt(new Test("smartPoint")); // 引用计数是相对于 Test("smartPoint") 对象而言;
46     QSharedPointer<Test> spt1(spt);
47     QSharedPointer<Test> spt2(spt);
48 
49     spt->print();
50     spt1->print();
51     spt2->print();
52 
53     return 0;
54 }
55 
56 /**
57  * 运行结果:
58  * construct @ smartPoint
59  * member @ "smartPoint"
60  * member @ "smartPoint"
61  * member @ "smartPoint"
62  * destruct @ "smartPoint"
63  * pt =  QObject(0x0)
64  * pt1 =  QObject(0x0)
65  * pt2 =  QObject(0x0)
66  * 
67  * QPointer 与 QSharedPointer 的区别 
68  * 
69  * construct @ smartPoint
70  * member @ "smartPoint"
71  * member @ "smartPoint"
72  * member @ "smartPoint"
73  * destruct @ "smartPoint"
74  * /

QPointer 和 QSharedPointer 使用案列

4、智能指针模板类的实现

  参照 auto_ptr 的设计,同样会在拷贝构造函数和赋值操作符中发生堆空间控制权的转移。

  1 // smartPointer.hpp 智能指针模板类
  2 #ifndef SMARTPOINTER_H
  3 #define SMARTPOINTER_H
  4 
  5 template
  6 <typename T>
  7 class SmartPointer
  8 {
  9 private:
 10     T *mp;
 11 public:
 12     SmartPointer(T *p = 0);
 13     SmartPointer(const SmartPointer<T>& obj);
 14     SmartPointer<T>& operator=(const SmartPointer<T>& obj);
 15     T* operator->();
 16     T& operator*();
 17     bool isNull();
 18     T* get();
 19     ~SmartPointer();
 20     
 21 };
 22 
 23 template
 24 <typename T>
 25 SmartPointer<T>::SmartPointer(T *p)
 26 {
 27     mp = p;
 28 }
 29 
 30 template
 31 <typename T>
 32 SmartPointer<T>::SmartPointer(const SmartPointer<T>& obj)
 33 {
 34     mp = obj.mp;
 35     const_cast<SmartPointer&>(obj).mp = 0;
 36 }
 37 
 38 template
 39 <typename T>
 40 SmartPointer<T>& SmartPointer<T>::operator=(const SmartPointer<T>& obj)
 41 {
 42     if(this != &obj)
 43     {
 44         if(mp != 0)
 45         {
 46             delete mp;
 47         }
 48         mp = obj.mp;
 49         const_cast<SmartPointer<T>&>(obj).mp = 0;
 50     }
 51 
 52     return *this;
 53 }
 54 
 55 template
 56 <typename T>
 57 T* SmartPointer<T>::operator->()
 58 {
 59     return mp;
 60 }
 61 
 62 template
 63 <typename T>
 64 T& SmartPointer<T>::operator*()
 65 {
 66     return *mp;
 67 }
 68 
 69 template
 70 <typename T>
 71 bool SmartPointer<T>::isNull()
 72 {
 73     return (mp == 0);
 74 }
 75 
 76 template
 77 <typename T>
 78 T* SmartPointer<T>::get()
 79 {
 80     return mp;
 81 }
 82 
 83 template
 84 <typename T>
 85 SmartPointer<T>::~SmartPointer()
 86 {
 87     delete mp;
 88 }       
 89 
 90 #endif
 91 
 92 // main.cpp 测试文件
 93 
 94 #include <iostream>
 95 #include "smartPointer.hpp"
 96 
 97 using namespace std;
 98 
 99 class Test
100 {
101     string m_name;
102 public:
103     Test(const char* name)
104     {
105         cout << "construct @" << name << endl;
106         
107         m_name = name;
108     }
109     
110     void print()
111     {
112         cout << "member @" << m_name << endl;
113     }
114     
115     ~Test()
116     {
117         cout << "destruct @" << m_name << endl;
118     }
119 };
120 
121 class Demo
122 {
123     string m_name;
124 public:
125     Demo(const char* name)
126     {
127         cout << "construct @" << name << endl;
128         
129         m_name = name;
130     }
131     
132     void print()
133     {
134         cout << "member @" << m_name << endl;
135     }
136     
137     ~Demo()
138     {
139         cout << "destruct @" << m_name << endl;
140     }
141 };
142 
143 
144 
145 int main(int argc, char const *argv[])
146 {
147     SmartPointer<Test> pt(new Test("SmartPointer Template <Test>"));
148     
149     cout << "pt = " << pt.get() << endl;
150     
151     pt->print();
152     
153     cout << endl;
154     
155     SmartPointer<Test> pt1(pt);
156     
157     cout << "pt = " << pt.get() << endl;
158     cout << "pt1 = " << pt1.get() << endl;
159     
160     pt1->print();
161     
162     //---------------------------------------------------------------
163     cout << "--------------------------------------------" << endl;
164     
165     SmartPointer<Demo> spt(new Demo("SmartPointer Template <Demo>"));
166     
167     cout << "spt = " << spt.get() << endl;
168     
169     spt->print();
170     
171     cout << endl;
172     
173     SmartPointer<Demo> spt1(spt);
174     
175     cout << "spt = " << spt.get() << endl;
176     cout << "spt1 = " << spt1.get() << endl;
177     
178     spt1->print();
179     
180     return 0;
181 }
182 /**
183  * 运行结果:
184  * construct @SmartPointer Template <Test>
185  * pt = 0x17bcc20
186  * member @SmartPointer Template <Test>
187  * 
188  * pt = 0
189  * pt1 = 0x17bcc20
190  * member @SmartPointer Template <Test>
191  * -----------------------------------------
192  * construct @SmartPointer Template <Demo>
193  * spt = 0x17bd090
194  * member @SmartPointer Template <Demo>
195  * 
196  * spt = 0
197  * spt1 = 0x17bd090
198  * member @SmartPointer Template <Demo>
199  * destruct @SmartPointer Template <Demo>
200  * destruct @SmartPointer Template <Test>
201  */

auto_ptr 类模板实现案列

  

本节总结:

智能指针能够尽可能的避开内存相关的问题,主要表现在:

(1)内存泄漏

(2)多次释放

<

发布回复

请输入评论!
请输入你的名字