1.为什么需要智能指针?(引入)
void func()
{
int* p1 = new int;
int* p2 = new int;
int* p3 = new int;
delete p1;
delete p2;
delete p3;
}
int main()
{
try {
func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
在p1,p2和p3的new中,可能会导致失败,那么我们按照
C++异常的处理方式
那就只能调用大量的 try catch 语句
2. 内存泄漏
2.1 什么是内存泄漏,内存泄漏的危害
什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存的浪费。
内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死。
2.2 内存泄漏分类(了解)
C/C++程序中一般我们关心两种方面的内存泄漏:
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存,用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源,比方套接字、文件描述符、管道等没有使用对应的函数释放掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。
2.3 如何检测内存泄漏(了解)
在linux下内存泄漏检测:linux下几款内存泄漏检测工具
在windows下使用第三方工具:VLD工具说明
其他工具:内存泄漏工具比较
2.4如何避免内存泄漏
- 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps:不过很多工具都不够靠谱,或者收费昂贵。
总结一下:
内存泄漏非常常见,解决方案分为两种:1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具
3.智能指针的使用及原理
3.1 RAII
RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。
在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处:
不需要显式地释放资源。
采用这种方式,对象所需的资源在其生命期内始终保持有效
解决 引入 问题(大量try,catch):(SmartPtr)
template<class T>
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
private:
T* _ptr;
};
void func()
{
int* p1 = new int;
SmartPtr<int> sp1(p1);
int* p2 = new int;
SmartPtr<int> sp2(p2);
SmartPtr<int> sp3(new int);
}
int main()
{
try {
func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
3.2 智能指针的原理
上述的SmartPtr还不能将其称为智能指针,因为它还不具有指针的行为。指针可以解引用,也可以通过->去访问所指空间中的内容,因此:AutoPtr模板类中还得需要将* 、->重载下,才可让其像指针一样去使用。
如何像指针一样使用,解引用,->
template<class T>
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
总结一下智能指针的原理:
- RAII特性
- 重载operator*和opertaor->,具有像指针一样的行为
3.3 std::auto_ptr
3.3.1引入拷贝问题
template<class T>
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
int main()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(sp1);
return 0;
}
问题原因:delete了两次
3.3.2解决拷贝问题:
auto_ptr不能解决
namespace sakeww
{
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
//管理权转移
sp._ptr = nullptr;
}
~auto_ptr()
{
if(_ptr){
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
int main()
{
sakeww::auto_ptr<int> sp1(new int);
sakeww::auto_ptr<int> sp2(sp1);//管理权转移
return 0;
}
新问题:
这样会让sp1悬空
当我们解引用sp1的时候,就会失败
结论:
auto_ptr是一个失败的设计,很多公司明确要求不能使用auto_ptr
3.4unique_ptr 直接不让拷贝
scoped_ptr boost库里面的
unique_ptr C++吸取boost里面的精华部分
这两个区别只有名字不同,内容是相同的
#include<memory> //unique_ptr
namespace sakeww
{
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
if (_ptr) {
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
unique_ptr(const unique_ptr<T>& sp) = delete;
private:
T* _ptr;
};
}
int main()
{
sakeww::unique_ptr<int> upp1(new int);
sakeww::unique_ptr<int> upp2(upp1);
return 0;
}
3.5shared_ptr
3.5.1shared_ptr 可以拷贝 shared_ptr简单模拟
拷贝构造:引用计数支持多个拷贝管理同一个资源,最后一个析构对象释放资源
赋值:
namespace sakeww
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pRefCount(new int(1))
{}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pRefCount(sp._pRefCount)
{
++(*_pRefCount);
}
void Release()
{
if (--(*_pRefCount) == 0)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
delete _pRefCount;
}
}
//增加计数
void AddRef()
{
++(*_pRefCount);
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//if (this != &sp)
if (_ptr != sp._ptr)//防止 sp1 = sp2
{
Release();
_ptr = sp._ptr;
_pRefCount = sp._pRefCount;
AddRef();
}
return *this;
}
~shared_ptr()
{
Release();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pRefCount;
};
}
int main()
{
sakeww::shared_ptr<int> sp1(new int);
sakeww::shared_ptr<int> sp2(sp1);
sakeww::shared_ptr<int> sp3(sp1);
sakeww::shared_ptr<int> sp4(new int);
sakeww::shared_ptr<int> sp5(sp4);
sp1 = sp4;
sp2 = sp4;
sp3 = sp4;
sp1 = sp1;//没有问题
sp1 = sp2;//?
return 0;
}
3.5.2shared_ptr线程安全问题
问题:
指向堆上资源的线程安全问题是访问的人处理的,智能指针不管,也管不了
引用计数的线程安全问题,是智能指针要处理的
多个线程中对同一个智能指针对象进行拷贝和析构时,++和–引用计数引用计数存在线程安全问题
#include<mutex>
namespace sakeww
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pRefCount(new int(1))
, _pmtx(new mutex)
{}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pRefCount(sp._pRefCount)
, _pmtx(sp._pmtx)
{
AddRef();
}
void Release()
{
_pmtx->lock();
bool flag = false;
if (--(*_pRefCount) == 0 && _ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
delete _pRefCount;
flag = true;
}
_pmtx->unlock();
if (flag == true)
{
delete _pmtx;
}
}
//增加计数
void AddRef()
{
_pmtx->lock();
++(*_pRefCount);
_pmtx->unlock();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//if (this != &sp)
if (_ptr != sp._ptr)//防止 sp1 = sp2
{
Release();
_ptr = sp._ptr;
_pRefCount = sp._pRefCount;
_pmtx = sp._pmtx;
AddRef();
}
return *this;
}
int use_count()
{
return *_pRefCount;
}
~shared_ptr()
{
Release();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pRefCount;
mutex* _pmtx;
};
}
补充问题:
shared_ptr智能指针是线程安全的吗?
是的,引用计数的加减是加锁保护的。但是指向资源不是线程安全的。
3.5.3shared_ptr 循环引用问题 (weak_ptr)
weak_ptr的next和prev对象,可以访问指向节点资源,但是不参与节点资源释放管理,其实就是不增加计数
库里的:
struct ListNode
{
int _val;
//std::shared_ptr<ListNode> _next;
//std::shared_ptr<ListNode> _prev;
std::weak_ptr<ListNode> _next;
std::weak_ptr<ListNode> _prev;
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
int main()
{
std::shared_ptr<ListNode> n1(new ListNode);
std::shared_ptr<ListNode> n2(new ListNode);
//循环引用
n1->_next = n2;
n2->_prev = n1;
return 0;
}
自己模拟实现的:
namespace sakeww
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pRefCount(new int(1))
, _pmtx(new mutex)
{}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pRefCount(sp._pRefCount)
, _pmtx(sp._pmtx)
{
AddRef();
}
void Release()
{
_pmtx->lock();
bool flag = false;
if (--(*_pRefCount) == 0 && _ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
delete _pRefCount;
flag = true;
}
_pmtx->unlock();
if (flag == true)
{
delete _pmtx;
}
}
//增加计数
void AddRef()
{
_pmtx->lock();
++(*_pRefCount);
_pmtx->unlock();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//if (this != &sp)
if (_ptr != sp._ptr)//防止 sp1 = sp2
{
Release();
_ptr = sp._ptr;
_pRefCount = sp._pRefCount;
_pmtx = sp._pmtx;
AddRef();
}
return *this;
}
int use_count()
{
return *_pRefCount;
}
~shared_ptr()
{
Release();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get() const
{
return _ptr;
}
private:
T* _ptr;
int* _pRefCount;
mutex* _pmtx;
};
template<class T>
class weak_ptr
{
public:
weak_ptr()
:_ptr(nullptr)
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
struct ListNode
{
int _val;
sakeww::weak_ptr<ListNode> _next;
sakeww::weak_ptr<ListNode> _prev;
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
int main()
{
sakeww::shared_ptr<ListNode> n1(new ListNode);
sakeww::shared_ptr<ListNode> n2(new ListNode);
//循环引用
n1->_next = n2;
n2->_prev = n1;
return 0;
}
3.6定制删除器
默认情况下,智能指针底层都是delete资源
如果你的资源不是new出来的呢?(new[],malloc,fopen)
定制删除器–可调用对象
namespace sakeww
{
template<class T>
class DefaultDelete
{
public:
void operator()(const T* ptr)
{
cout << "delete:" << ptr << endl;
delete ptr;
}
};
//释放方式 由D删除器决定
template<class T, class D = DefaultDelete<T>>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
//if (_ptr) {
// cout << "delete:" << _ptr << endl;
// delete _ptr;
//}
D del;
del(_ptr);
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
unique_ptr(const unique_ptr<T>& sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
private:
T* _ptr;
};
}
class A
{
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
private:
int _a1 = 0;
int _a2 = 0;
};
template<class T>
struct DeleteArray
{
void operator()(const T* ptr)
{
cout << "delete[]:" << ptr << endl;
delete[] ptr;
}
};
struct DeleteFile
{
void operator()(FILE* ptr)
{
cout << "fclose:" << ptr << endl;
fclose(ptr);
}
};
int main()
{
// 删除器在类模板参数给 -- 类型
sakeww::unique_ptr<A> up1(new A);
sakeww::unique_ptr<A, DeleteArray<A>> up2(new A[10]);
sakeww::unique_ptr<FILE, DeleteFile> up3(fopen("test.txt", "w"));
// 删除器在构造函数的参数给 -- 对象
std::shared_ptr<A> sp1(new A);
std::shared_ptr<A> sp2(new A[10], DeleteArray<A>());
std::shared_ptr<FILE> sp3(fopen("test.txt", "w"), DeleteFile());
std::shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });
std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p) {fclose(p); });
return 0;
}
4.C++11和boost中智能指针的关系
- C++ 98 中产生了第一个智能指针auto_ptr.
- C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
- C++ TR1,引入了shared_ptr等。不过注意的是TR1并不是标准版。
- C++ 11,引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的