1.为什么需要智能指针？
下面我们先分析一下下面这段程序有没有什么内存方面的问题？提示一下：注意分析下面 Func
函数中的问题。
#include<exception>
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("报错：除 0 错误");
return a / b;
}
void Func()
{
// 1、如果p1这里new 抛异常会如何？
// 2、如果p2这里new 抛异常会如何？
// 3、如果div调用这里又会抛异常会如何？
int* p1 = new int;
int* p2 = new int;
cout << div() << endl;
delete p1;
delete p2;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
1、如果p1这里new 抛异常会如何？
2、如果p2这里new 抛异常会如何？
3、如果div调用这里又会抛异常会如何？
p1 、 p2、div调用抛异常都会直接 结束当前函数，跳出当前函数，下面的两个 delete 语句无法执行，导致两个new的空间无法释放，内存泄漏
2.内存泄漏
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 如何避免内存泄漏
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：
这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
能指针来管理才有保证。 - 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄
漏检测工具。
3.智能指针的使用及原理
3.1 RAII
RAII（Resource Acquisition Is Initialization）是一种利用 对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。
这种做法有两大好处：
（1）不需要显式地释放资源。
（2）采用这种方式，对象所需的资源在其生命期内始终保持有效
简单来说，RAII 就是将资源（如new了一块内存）管理权交给了一个对象，该对象自己析构时，同时就会自动将管理的那块资源给释放，无需自己管理那块资源析构了，则就是智能指针的原理
具体讲解智能指针为什么有这个功效？
因为智能指针对象 也是局部变量，函数结束销毁后，会自动销毁局部变量，对象则调用析构函数，这里存在 函数结束自动析构对象的 特性
而 new 的对象一定要 手动delete，函数结束，不会自动 delete 导致内存泄漏，因此需要借助 局部对象自动析构的特性帮助 delete
3.2 模拟实现比较简单的智能指针
// 智能指针类模板
template<class T>
struct smartPtr
{
public:
smartPtr(T* ptr)
:_ptr(ptr)
{}
~smartPtr() {
cout << "delete _ptr" << '\n';
delete _ptr;
}
private:
T* _ptr;
};
void Func() {
int* arr = new int();
smartPtr<int> sp(arr); // 将arr指向的空间资源交给智能指针对象 sp 管理
throw "测试异常跳出";
cout << "Func delete arr" << '\n';
delete arr;
}
int main() {
try {
Func();
}
catch (const char* str) {
cout << str << '\n';
}
return 0;
}
运行这段代码：可以发现，在 Func 函数销毁时，智能指针对象 sp 也被销毁，该对象管理的资源 arr 也被 delete 了，arr 指向的空间被正确的释放，避免了内存泄漏
3.2 智能指针的原理
上述的 smartPtr 还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将 * 、-> 重载下，才可让其
像指针一样去使用。
// 智能指针类模板
template<class T>
struct smartPtr
{
public:
smartPtr(T* ptr)
:_ptr(ptr)
{}
~smartPtr() {
cout << "delete _ptr" << '\n';
delete _ptr;
}
T& operator*() {
return *_ptr;
}
T* operator->() {
return _ptr;
}
private:
T* _ptr;
};
struct Date
{
int _year;
int _month;
int _day;
};
int main() {
smartPtr<int> sp1(new int);
*sp1 = 10;
cout << *sp1 << endl;
smartPtr<Date> spArray(new Date);
// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
spArray->_year = 2018;
spArray->_month = 1;
spArray->_day = 1;
return 0;
}
总结一下智能指针的原理：
- RAII特性
- 重载 operator* 和 opertaor-> 等功能，具有像指针一样的行为。
4.智能指针拷贝问题
智能指针也是 一种指针，当使用一个智能指针 拷贝给 新一个智能指针时，默认的拷贝为 浅拷贝，使得两指针同时指向一块空间，但是这样会导致多次析构的问题（多个对象析构同一资源会出问题！）
我们需要浅拷贝，又不想多次析构？？
我们来看看库中的几种智能指针的处理方法：
4.1 std::auto_ptr
C++98 版本的库中就提供了auto_ptr 的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr 的拷贝函数实现原理：管理权转移的思想，下面简化模拟实现了一份 my::auto_ptr 来了解它的原理
通过代码的调试，可以发现，管理权转移是将原本旧智能指针的指针置为空，同时将新智能指针指向管理的那块空间资源：相当于将管理这块空间的权力转交给新指针
随便将一个指针置为空，会造成很多严重的问题！因此该设计是一个失败的设计
// C++98 管理权转移 auto_ptr
namespace my
{
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<T>& operator=(auto_ptr<T>& ap)
{
// 检测是否为自己给自己赋值
if (this != &ap)
{
// 释放当前对象中资源：将自己管理的资源先释放，然后再接收新资源
if (_ptr)
delete _ptr;
// 转移ap中资源到当前对象中
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get() {
return _ptr;
}
private:
T* _ptr;
};
}
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
int main()
{
std::auto_ptr<int> sp1(new int);
std::auto_ptr<int> sp2(sp1); // 管理权转移
// sp1悬空
*sp2 = 10;
cout << sp2.get() << endl;
cout << sp1.get() << endl;
return 0;
}
旧的智能指针置为空了
4.2 std::unique_ptr
C++11中开始提供更靠谱的 unique_ptr
unique_ptr 的实现原理：简单粗暴的防拷贝，（既然拷贝有风险，就干脆不允许拷贝了，如果使用智能指针时，且无需拷贝操作，则 unique_ptr 将是一个极佳的选择）
unique_ptr 使用 delete 将拷贝构造及其他相关函数禁用掉了
下面简化模拟实现了一份 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 my
{
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;
}
// 禁用掉拷贝
unique_ptr(const unique_ptr<T>& sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
private:
T* _ptr;
};
}
int main()
{
my::unique_ptr<int> sp1(new int);
my::unique_ptr<int> sp2(sp1); // 报错
std::unique_ptr<int> sp1(new int);
std::unique_ptr<int> sp2(sp1); // 报错
return 0;
}
如果你非要拷贝，可以使用 shared_ptr
4.3 std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr 的原理：是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源。即多个指针指向同一块空间资源，对象内部使用引用计数记录当前该空间被多少个对象共享，方便实现空间析构
-
shared_ptr 在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
-
在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
（一个对象销毁时，计数-1） -
如果引用计数是 0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
（计数=0，则表示自己是最后一个人，可以释放空间了） -
如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
（计数不等于0，则表示自己不是是最后一个人，没有释放资源的权力）
4.4 模拟实现 shared_ptr
由于篇幅限制，可以跳转该博客：
【C++ 第二十章】模拟实现 shared_ptr（可以拷贝的智能指针）
4.5 使用 shared_ptr 会出现严重的循环引用问题？？
由于篇幅限制，可以跳转该博客：
【C++ 第二十章】使用 shared_ptr 会出现严重 循环引用 问题？
扫一扫
4017
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
