【C++】 智能指针
一、为什么需要智能指针？
下面我们先分析一下下面这段程序有没有什么内存方面的问题？
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void f()
{
pair<string, string>* p1 = new pair<string, string>;
pair<string, string>* p2 = new pair<string, string>;
pair<string, string>* p3 = new pair<string, string>;
pair<string, string>* p4 = new pair<string, string>;
try
{
div();
}
catch (...)
{
delete p1;
cout << "delete:" << p1 << endl;
throw;
}
delete p1;
cout << "delete:" << p1 << endl;
}
int main()
{
try
{
f();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
如果p1正常new正常delete，那么就不会产生内存泄漏，但如果出现抛异常，那么会影响执行流，即使delete也不会正常释放内存。
因此我们引出try catch捕获异常，并将p1正常delete。但如果我们new了多个，p2、p3、p4，如果p1出现异常，p2、p3、p4就没有办法得到正常释放，我们又要使用更多的try catch，这样会变得非常麻烦。
所以，我们这一章要引入智能指针来解决这个问题。
下面先讲一下内存泄漏
二、内存泄漏
2.1 什么是内存泄漏，内存泄漏的危害
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}
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.1 RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr
{
public:
// RAII
// 资源交给对象管理，对象生命周期内，资源有效，对象生命周期到了，释放资源
// 1、RAII管控资源释放
// 2、像指针一样
// 3、拷贝问题
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete:" << _ptr << endl;
delete(_ptr);
}
private:
T* _ptr;
};
void f()
{
SmartPtr<pair<string, string>> sp1(new pair<string, string>("11111", "22222"));
div();
SmartPtr<pair<string, string>> sp2(new pair<string, string>);
SmartPtr<pair<string, string>> sp3(new pair<string, string>);
SmartPtr<string> sp4(new string("xxxxx"));
div();
}
int main()
{
try
{
f();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
运行示例：
第一个div()执行错误，我们可以看到成功将sp1释放，并且退出程序，后面的就没有进行new了，也不用释放了。
第二个div()执行错误，我们可以看到成功将所有的指针释放。
3.2 智能指针的原理
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
template<class T>
class SmartPtr
{
public:
// RAII
// 资源交给对象管理，对象生命周期内，资源有效，对象生命周期到了，释放资源
// 1、RAII管控资源释放
// 2、像指针一样
// 3、拷贝问题
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete:" << _ptr << endl;
delete(_ptr);
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
void f()
{
SmartPtr<pair<string, string>> sp1(new pair<string, string>("11111", "22222"));
div();
SmartPtr<pair<string, string>> sp2(new pair<string, string>);
SmartPtr<pair<string, string>> sp3(new pair<string, string>);
SmartPtr<string> sp4(new string("xxxxx"));
div();
cout << *sp4 << endl;
cout << sp1->first << endl;
cout << sp1->second << endl;
}
int main()
{
try
{
f();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
运行结果：
重载了*和->符号并成功使用
总结一下智能指针的原理：
- RAII特性
- 重载operator*和opertaor->，具有像指针一样的行为。
3.3 std::auto_ptr
std::auto_ptr文档
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理
// C++98 管理权转移 auto_ptr
namespace gty
{
template<class T>
class auto_ptr
{
public:
//RAII
//像指针一样
auto_ptr(T* ptr)
:_ptr(ptr)
{}
~auto_ptr()
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
// ap3(ap1)
// 管理权转移
auto_ptr(auto_ptr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;
}
private:
T* _ptr;
};
}
int main()
{
// C++98 一般实践中，很多公司明确规定不要用这个
gty::auto_ptr<A> ap1(new A(1));
gty::auto_ptr<A> ap2(new A(2));
// 管理权转移，拷贝时，会把被拷贝对象的资源管理权转移给拷贝对象
// 隐患：导致被拷贝对象悬空，访问就会出问题
gty::auto_ptr<A> ap3(ap1);
// 崩溃
ap1->_a++;
ap3->_a++;
return 0;
}
运行报错：
管理权转移，拷贝时，会把被拷贝对象的资源管理权转移给拷贝对象
隐患：导致被拷贝对象悬空，访问就会出问题
管理权转让后ap1的指针已经置为nullptr，这里再访问ap1进行++就会报错
3.4 std::unique_ptr
C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理
// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace gty
{
template<class T>
class unique_ptr
{
public:
// RAII
// 像指针一样
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
// ap3(ap1)
// 管理权转移
// 防拷贝
//这两个函数被被明确删除（使用= delete;）是为了强制实施unique_ptr的“唯一所有权”语义。如果你尝试复制或赋值一个unique_ptr，编译器会产生一个错误。
unique_ptr(unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
private:
T* _ptr;
};
};
}
int main()
{
// C++11 简单粗暴，不让拷贝
gty::unique_ptr<A> up1(new A(1));
gty::unique_ptr<A> up2(new A(2));
//gty::unique_ptr<A> up3(up1);
//up1 = up2;
return 0;
}
使用拷贝和赋值，发现运行报错
总结：std::unique_ptr相比auto_ptr靠谱了一些，不会出现导致被拷贝对象悬空的问题。
主要原理：将拷贝构造函数和赋值函数用delete禁止使用。
//这两个函数被被明确删除（使用= delete;）是为了强制实施unique_ptr的“唯一所有权”语义。如果你尝试复制或赋值一个unique_ptr，编译器会产生一个错误。
unique_ptr(unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
但我们始终还是有一些场景是需要拷贝和赋值的。
所以接下来引出了shared_ptr。
3.5 std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
3.5.1 shared_ptr的原理
shared_ptr的原理是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
下面来看一下shared_ptr模拟实现和使用
namespace gty
{
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
template<class T>
class shared_ptr
{
public:
// RAII
// 像指针一样
shared_ptr(T* ptr = nullptr)//
:_ptr(ptr)
,_pcount(new int(1))
{}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
delete _pcount;
delete _ptr;
}
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
// sp3(sp1)
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
++(*_pcount);
}
// sp1 = sp5
// sp6 = sp6
// sp4 = sp5
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//自己给自己赋值，不要修改，直接返回this指针
if (sp._ptr == _ptr)
return *this;
//不是自己给自己赋值，先把pcount减1，判断是否需要释放
if (--(*_pcount) == 0)
{
delete _pcount;
delete _ptr;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
return *this;
}
int use_count() const
{
return *_pcount;
}
T* getptr() const
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;//引用计数
};
}
int main()
{
// C++11
gty::shared_ptr<A> sp1(new A(1));
gty::shared_ptr<A> sp2(new A(2));
gty::shared_ptr<A> sp3(sp1);
sp1->_a++;
sp3->_a++;
cout << sp1->_a << endl;
gty::shared_ptr<A> sp4(sp2);
gty::shared_ptr<A> sp5(sp4);
sp1 = sp5;
sp3 = sp5;
gty::shared_ptr<A> sp6(new A(6));
sp6 = sp6;
sp4 = sp5;
cout << sp6->_a << endl;
return 0;
}
运行结果：
我们可以看到share_ptr可以实现拷贝构造，赋值重载，通过拷贝或者赋值得到的指针，和原来的指针可以共享资源，共同对数据进行修改。
3.5.2share_ptr的死穴----循环引用
循环引用问题：
struct Node
{
A _val;
gty::shared_ptr<Node> _next;
gty::shared_ptr<Node> _prev;
};
int main()
{
// 循环引用
gty::shared_ptr<Node> sp1(new Node);
gty::shared_ptr<Node> sp2(new Node);
cout << sp1.use_count() << endl;
cout << sp2.use_count() << endl;
sp1->_next = sp2;
//sp2->_prev = sp1;
cout << sp1.use_count() << endl;
cout << sp2.use_count() << endl;
return 0;
}
屏蔽sp2->_prev = sp1;运行结果：
可以看到这种情况俩个指针都析构了
但是，当我们加上sp2->_prev = sp1;，再来看运行结果：
我们发现，这次俩个指针都没有释放，造成了内存泄漏，这是什么原因导致的呢？
我们来看下面这张图
我们看到，在初始化俩个shared_ptr之后，他们的引用计数都变为1，但当我执行这俩个语句，prev管着左边的节点next管着右边的节点
sp1->_next = sp2;
sp2->_prev = sp1;
我们，sp1就变成俩个指针管理，一个是sp1，另一个是sp2->_prev，
sp2也变成俩个指针管理，一个是sp2，另一个是sp1->_next 。
我们再来看：
所以就造成这个死循环，导致俩个shared_ptr没办法析构，进而造成内存泄漏。
那我们怎么解决这个问题呢？
使用weak_ptr可以解决这个问题，下面我们来看weak_ptr。
3.6 std::weak_ptr
weak_ptr不是RAII，它的存在只有一个意义，就是解决shared_ptr的循环引用问题
实现原理：支持用shared_ptr构造和赋值出weak_ptr。
weak_ptr不增加引用计数，可以访问资源，不参与资源释放的管理。
namespace gty
{
template<class T>
class weak_ptr
{
public:
weak_ptr(T* ptr)
:_ptr(nullptr)
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr<T>& (const shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
weak_ptr
private:
T* _ptr;
};
}
struct Node
{
A _val;
//bit::shared_ptr<Node> _next;
//bit::shared_ptr<Node> _prev;
gty::weak_ptr<Node> _next;
gty::weak_ptr<Node> _prev;
// weak_ptr不是RAII智能指针，专门用来解决shared_ptr循环引用问题
// weak_ptr不增加引用计数，可以访问资源，不参与资源释放的管理
};
int main()
{
// 循环引用
gty::shared_ptr<Node> sp1(new Node);
gty::shared_ptr<Node> sp2(new Node);
cout << sp1.use_count() << endl;
cout << sp2.use_count() << endl;
sp1->_next = sp2;
sp2->_prev = sp1;
cout << sp1.use_count() << endl;
cout << sp2.use_count() << endl;
return 0;
}
运行结果：
可以看到这次引用计数没有增加，俩个shared_ptr指针也成功释放了
总结：
auto ptr 管理权转移，会导致被拷贝对象悬空，建议不要使用它
unique_ptr 禁止拷贝，简单粗暴。日常使用，不需要拷贝的场景，建议使用它
shared ptr 引用计数支持拷贝，需要拷贝的场景，就使用它。但是要小心构成循环引用，循环引用会导致内存泄漏
weak ptr 专门解决shared ptr的循环引用问题
四、定制删除器
我们前面自定义的智能指针析构函数都是delete，然而，当我们new[],或者malloc的时候，析构函数就没有对应的语句进行释放。
运行示例：
报错
因此，我们要引入定制删除器来解决不同情况下的释放。
下面我们先来看一下库里面是如何实现定制删除器的：
可以看到库中是用了一个仿函数，默认情况下是delete，我们可以将其他需要的释放情况用仿函数的方式传入。
下面简单的看俩个使用例子：
template<class T>
struct DeleteArray
{
void operator()(T* ptr)
{
delete[] ptr;
}
};
int main()
{
shared_ptr<A> sp1(new A[10], DeleteArray<A>());
shared_ptr<A> sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
shared_ptr<FILE> sp3(fopen("Test.cpp", "r"), [](FILE* ptr) {
cout << "fclose:" << ptr << endl;
fclose(ptr);
});
return 0;
}
可以看到，这次我们成功的将所有内存释放。
在sp1中，我们传入了一个delete[]的仿函数；sp2中，我们用了一个lambda表达式；
sp3中，我们还可以进行文件的打开和关闭，同样也是传入了一个lambda表达式。
下面我们来模拟实现一下定制删除器：
我们发现我们的仿函数都有一个共同的特点，就是返回值是void，函数参数是T*
，所以我们利用function包装器来模拟定制删除器
首先我们用function定义一个_del,这里我们要注意，要将默认的释放方式delete传给_del，否则当我们没有传仿函数或者lambda表达式时，会报错。
如何再对构造函数和析构函数进行修改
用模板的方式在创建一个函数参数del，传入仿函数或者lambda表达式给到_del
然后再析构函数利用_del对_ptr进行释放。
最后我们来进行测试：
可以看到这次我们成功的将所有内存释放。
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
