目录
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;
#include <iostream>
#include <string>
using namespace std;
class Test
{
int i;
public:
Test(int i)
{
this->i = i;
}
int value()
{
return i;
}
~Test()
{
}
};
int main()
{
for(int i=0; i<5; i++)
{
Test* p = new Test(i);
cout << p->value() << endl;
}
return 0;
}
关于内存泄漏的案列
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);
75 cout << pt1->value() << endl;
76 cout << (*pt1).value() << endl;
77
78 cout << "-------2-------------" << endl;
79 Pointer pt2 = new Test(5);
80 cout << pt2->value() << endl;
81
82 cout << "-------3-------------" << endl;
83 Pointer pt3 = pt2;
84 cout << pt2.isNull() << endl;
85 cout << pt3->value() << endl;
86
87 cout << "-------4-------------" << endl;
88 pt3 = pt1;
89 cout << pt1.isNull() << endl;
90
91 cout << "-------5-------------" << endl;
92 Pointer pt4;
93 pt4 = pt3;
94 cout << pt3.isNull() << endl;
95
96 return 0;
97 }
98
99
智能指针的实现
注:这个案列只实现了一个类的内存回收,关于任意类的内存回收,会在后续的模板技术中介绍。
智能指针类模板
知识回顾
由于智能指针相关的类重载了指针操作符 ,所以其对象可以像原生的指针一样使用,本质上智能指针对象就是类对象。但是,此时的智能指针对象有很大的局限性,不能灵活的指向任意的类对象。为了解决这个问题,智能指针类模板就出现了。
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 的进化版,没有使用权的转移);
#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Test
{
string m_name;
public:
Test(const char* name)
{
cout << "construct @" << name << endl;
m_name = name;
}
void print()
{
cout << "member @" << m_name << endl;
}
~Test()
{
cout << "destruct @" << m_name << endl;
}
};
int main()
{
auto_ptr<Test> pt(new Test("smartPoint"));
cout << "pt = " << pt.get() << endl;
pt->print();
cout << endl;
auto_ptr<Test> pt1(pt);
cout << "pt = " << pt.get() << endl;
cout << "pt1 = " << pt1.get() << endl;
pt1->print();
return 0;
}
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 才开发自己的智能指针类模板。
#include <QPointer>
#include <QSharedPointer>
#include <QDebug>
class Test : public QObject
{
QString m_name;
public:
Test(const char* name)
{
qDebug() << "construct @" << name;
m_name = name;
}
void print()
{
qDebug() << "member @" << m_name;
}
~Test()
{
qDebug() << "destruct @" << m_name ;
}
};
int main()
{
QPointer<Test> pt(new Test("smartPoint"));
QPointer<Test> pt1(pt);
QPointer<Test> pt2(pt);
pt->print();
pt1->print();
pt2->print();
delete pt;
qDebug() << "pt = " << pt;
qDebug() << "pt1 = " << pt1;
qDebug() << "pt2 = " << pt2;
qDebug() << "QPointer 与 QSharedPointer 的区别" << endl;
QSharedPointer<Test> spt(new Test("smartPoint"));
QSharedPointer<Test> spt1(spt);
QSharedPointer<Test> spt2(spt);
spt->print();
spt1->print();
spt2->print();
return 0;
}
QPointer 和 QSharedPointer 使用案列
4、智能指针模板类的实现
参照 auto_ptr 的设计,同样会在拷贝构造函数和赋值操作符中发生堆空间控制权的转移。
#ifndef SMARTPOINTER_H
#define SMARTPOINTER_H
template
<typename T>
class SmartPointer
{
private:
T *mp;
public:
SmartPointer(T *p = 0);
SmartPointer(const SmartPointer<T>& obj);
SmartPointer<T>& operator=(const SmartPointer<T>& obj);
T* operator->();
T& operator*();
bool isNull();
T* get();
~SmartPointer();
};
template
<typename T>
SmartPointer<T>::SmartPointer(T *p)
{
mp = p;
}
template
<typename T>
SmartPointer<T>::SmartPointer(const SmartPointer<T>& obj)
{
mp = obj.mp;
const_cast<SmartPointer&>(obj).mp = 0;
}
template
<typename T>
SmartPointer<T>& SmartPointer<T>::operator=(const SmartPointer<T>& obj)
{
if(this != &obj)
{
if(mp != 0)
{
delete mp;
}
mp = obj.mp;
const_cast<SmartPointer<T>&>(obj).mp = 0;
}
return *this;
}
template
<typename T>
T* SmartPointer<T>::operator->()
{
return mp;
}
template
<typename T>
T& SmartPointer<T>::operator*()
{
return *mp;
}
template
<typename T>
bool SmartPointer<T>::isNull()
{
return (mp == 0);
}
template
<typename T>
T* SmartPointer<T>::get()
{
return mp;
}
template
<typename T>
SmartPointer<T>::~SmartPointer()
{
delete mp;
}
#endif
#include <iostream>
#include "smartPointer.hpp"
using namespace std;
class Test
{
string m_name;
public:
Test(const char* name)
{
cout << "construct @" << name << endl;
m_name = name;
}
void print()
{
cout << "member @" << m_name << endl;
}
~Test()
{
cout << "destruct @" << m_name << endl;
}
};
class Demo
{
string m_name;
public:
Demo(const char* name)
{
cout << "construct @" << name << endl;
m_name = name;
}
void print()
{
cout << "member @" << m_name << endl;
}
~Demo()
{
cout << "destruct @" << m_name << endl;
}
};
int main(int argc, char const *argv[])
{
SmartPointer<Test> pt(new Test("SmartPointer Template <Test>"));
cout << "pt = " << pt.get() << endl;
pt->print();
cout << endl;
SmartPointer<Test> pt1(pt);
cout << "pt = " << pt.get() << endl;
cout << "pt1 = " << pt1.get() << endl;
pt1->print();
cout << "--------------------------------------------" << endl;
SmartPointer<Demo> spt(new Demo("SmartPointer Template <Demo>"));
cout << "spt = " << spt.get() << endl;
spt->print();
cout << endl;
SmartPointer<Demo> spt1(spt);
cout << "spt = " << spt.get() << endl;
cout << "spt1 = " << spt1.get() << endl;
spt1->print();
return 0;
}
auto_ptr 类模板实现案列
本节总结:
智能指针能够尽可能的避开内存相关的问题,主要表现在:
(1)内存泄漏
(2)多次释放