目录
1. 初识智能指针
1.1 内存泄漏的原因分析
1.2 内存泄漏的解决方案
2. 智能指针类模板
2.1 智能指针的意义
2.2 STL 中的智能指针应用
2.3 QT 中的智能指针应用
2.4 智能指针模板类的实现
初识智能指针
在c++语言中没有垃圾回收机制，内存泄漏这个问题就不得不让程序员自己来解决，稍有不慎就会给软件带来Bug，幸运的是我们可以使用智能指针去解决内存泄漏的问题。
1、 内存泄漏的原因分析
（1）动态申请堆空间，用完后不归还；
（2）C++ 语言中没有垃圾回收的机制；
1）Java、C# 语言中都引入了垃圾回收机制，定期检测内存，若发现没有使用，则回收；
2）垃圾回收机制可以很好的避免内存泄漏；
3）C++ 中的动态内存申请和归还完全依赖开发者，稍有不慎就会出错；
（3）指针无法控制所指堆空间的生命周期；（根本原因）
1）通过指针可以指向动态内存空间，但是却不能够控制动态内存空间的生命周期；
2）也就是指针和动态内存空间没有必然联系，即使指针变量销毁了，动态内存空间还可以存在；
补充：多次释放多个指针指向的同一块堆空间也会使软件出现Bug；
1 #include 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 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(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(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 2 #include <string> 3 #include// 智能指针类模板的头文件 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_ptrpt(new Test("smartPoint"));32 33 cout << "pt = " << pt.get() << endl; // pt.get() 返回指针所指向数组的首地址34 35 pt->print();36 37 cout << endl;38 39 auto_ptrpt1(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 @smartPoint51 * pt = 0x1329c2052 * member @smartPoint53 *
54 * pt = 055 * pt1 = 0x1329c2056 * member @smartPoint57 * destruct @smartPoint58 * /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 2 #include 3 #include 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 QPointerpt(new Test("smartPoint"));30 QPointer pt1(pt);31 QPointer 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 QSharedPointerspt(new Test("smartPoint")); // 引用计数是相对于 Test("smartPoint") 对象而言；46 QSharedPointer spt1(spt);47 QSharedPointer spt2(spt);48 49 spt->print();50 spt1->print();51 spt2->print();52 53 return 0;54 }55 56 /**57 * 运行结果：58 * construct @ smartPoint59 * 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 @ smartPoint70 * member @ "smartPoint"71 * member @ "smartPoint"72 * member @ "smartPoint"73 * destruct @ "smartPoint"74 * /4、智能指针模板类的实现
参照 auto_ptr 的设计，同样会在拷贝构造函数和赋值操作符中发生堆空间控制权的转移。
1 // smartPointer.hpp 智能指针模板类 2 #ifndef SMARTPOINTER_H 3 #define SMARTPOINTER_H 4 5 template 6 7 class SmartPointer 8 { 9 private: 10 T *mp; 11 public: 12 SmartPointer(T *p = 0); 13 SmartPointer(const SmartPointer& obj); 14 SmartPointer& operator=(const SmartPointer& obj); 15 T* operator->(); 16 T& operator*(); 17 bool isNull(); 18 T* get(); 19 ~SmartPointer(); 20 21 }; 22 23 template 24 25 SmartPointer::SmartPointer(T *p) 26 { 27 mp = p; 28 } 29 30 template 31 32 SmartPointer::SmartPointer(const SmartPointer& obj) 33 { 34 mp = obj.mp; 35 const_cast(obj).mp = 0; 36 } 37 38 template 39 40 SmartPointer& SmartPointer::operator=(const SmartPointer& obj) 41 { 42 if(this != &obj) 43 { 44 if(mp != 0) 45 { 46 delete mp; 47 } 48 mp = obj.mp; 49 const_cast<SmartPointer&>(obj).mp = 0; 50 } 51 52 return *this; 53 } 54 55 template 56 57 T* SmartPointer::operator->() 58 { 59 return mp; 60 } 61 62 template 63 64 T& SmartPointer::operator*() 65 { 66 return *mp; 67 } 68 69 template 70 71 bool SmartPointer::isNull() 72 { 73 return (mp == 0); 74 } 75 76 template 77 78 T* SmartPointer::get() 79 { 80 return mp; 81 } 82 83 template 84 85 SmartPointer::~SmartPointer() 86 { 87 delete mp; 88 }
89 90 #endif 91 92 // main.cpp 测试文件 93 94 #include 95 #include "test.hpp" 96 97 using namespace std; 98 99 class Test100 {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 Demo122 {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 SmartPointerpt(new Test("SmartPointer Template"));148 149 cout << "pt = " << pt.get() << endl;150 151 pt->print();152 153 cout << endl;154 155 SmartPointer 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 SmartPointerspt(new Demo("SmartPointer Template"));166 167 cout << "spt = " << spt.get() << endl;168 169 spt->print();170 171 cout << endl;172 173 SmartPointer 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 Template185 * pt = 0x17bcc20186 * member @SmartPointer Template187 *
188 * pt = 0189 * pt1 = 0x17bcc20190 * member @SmartPointer Template191 * -----------------------------------------192 * construct @SmartPointer Template193 * spt = 0x17bd090194 * member @SmartPointer Template195 *
196 * spt = 0197 * spt1 = 0x17bd090198 * member @SmartPointer Template199 * destruct @SmartPointer Template200 * destruct @SmartPointer Template201 */
本节总结：
智能指针能够尽可能的避开内存相关的问题，主要表现在：
（1）内存泄漏
（2）多次释放
Copyright © 2004-2024 Ynicp.com 版权所有 法律顾问:建纬(昆明)律师事务所 昆明市网翼通科技有限公司 滇ICP备08002592号-4
