C++智能指针
目录
1.为什么需要智能指针？
下面结合抛异常的情况来看一个程序，看看这个程序中有没有内存方面的问题：
#include<iostream>
#include<memory>
using namespace std;
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
//如果p1这里new 抛异常了：
//p1new抛异常，会直接跳到main函数中，
//异常会在main函数中被捕捉，
//紧接着就会在main函数往下执行。
//这会导致p1往下的代码无法执行，p1无法被释放
//造成内存泄漏
int* p1 = new int[10];
//如果p2这里new抛异常了：
//这里跟p1一样，造成p1和p2的内存泄漏
int* p2 = new int[20];
//如果div调用这里抛异常了会造成p1和p2的内存泄漏
cout << div() << endl;
delete[] p1;
delete[] p2;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}通过代码我们发现，在抛异常的时候，有很大可能会导致内存泄漏。
目前在讲智能指针方法前，上面代码问题的解决方法如下：
void Func()
{
int* p1 = new int[10];
int* p2 = nullptr;
try
{
p2 = new int[20];
try
{
cout << div() << endl;
}
catch (...)
{
//在这里捕获异常，然后释放内存
delete[] p1;
delete[] p2;
//释放内存后再将捕获到的异常重新抛出
throw;
}
}
catch (...)
{
//...
}
}用catch(...) 捕捉异常后，释放内存，然后再重新抛出！
2.内存泄漏
2.1 什么是内存泄漏，内存泄漏的危害
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现 内存泄漏会导致响应越来越慢，最终卡死。
void Func()
{
//如果p1这里new 抛异常了：
//p1new抛异常，会直接跳到main函数中，
//异常会在main函数中被捕捉，
//紧接着就会在main函数往下执行。
//这会导致p1往下的代码无法执行，p1无法被释放
//造成内存泄漏
int* p1 = new int[10];
//如果p2这里new抛异常了：
//这里跟p1一样，造成p1和p2的内存泄漏
int* p2 = new int[20];
//如果div调用这里抛异常了会造成p1和p2的内存泄漏
cout << div() << endl;
delete[] p1;
delete[] p2;
}
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）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
利用对象生命周期来控制程序资源即这段资源随对象的销毁而销毁。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
①不需要显式地释放资源。
②采用这种方式，对象所需的资源在其生命期内始终保持有效。
3.2智能指针的使用以及原理
使用RAII思想设计SmartPtr类：
template<class T>
class SmartPtr
{
public:
//RAII
//保存资源
SmartPtr(T* ptr = nullptr)
:_ptr(ptr)
{}
//释放资源
~SmartPtr()
{
delete _ptr;
cout << _ptr << endl;//用于测试是否成功释放
}
//像指针一样
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
private:
T* _ptr;
};
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
//使用智能指针
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(new int);
cout << div() << endl;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
智能指针的原理，便是重载了operator->()和operator*()的功能。
总结一下智能指针的原理：
1. RAII特性 2. 重载operator*和opertaor->，具有像指针一样的行为。
智能指针除了operator->()和operator*()等功能，会有拷贝和赋值这样的操作吗？
对于拷贝和赋值，以下的不同版本的智能指针有它们的见解。
3.3 std::auto_ptr
auto_ptr是C++98版本的库中提供的智能指针。auto_ptr智能指针的拷贝和赋值操作是权限转移。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理。
template<class T>
class auto_ptr
{
public:
//RAII
//保存资源
auto_ptr(T* ptr)
:_ptr(ptr)
{}
//释放资源
~auto_ptr()
{
delete _ptr;
//用于测试资源是否释放成功
cout << _ptr << endl;
}
//拷贝
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
//权限转移
sp._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& sp)
{
//检测是否为自己给自己赋值
if (this != &sp)
{
if (_ptr)
delete _ptr;
//转移sp中资源到当前对象中
_ptr = sp._ptr;
sp._ptr = nullptr;
}
return *this;
}
//像指针一样
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
private:
T* _ptr;
};为了避免内存泄漏，需要权限转移。但是这会导致一个问题，会导致原本的智能指针对象悬空！即我拷贝或赋值之后，还要用怎么办？因此，auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。
3.4 std::unique_ptr
C++11中开始提供更靠谱的unique_ptr。unique_ptr看到auto_ptr的拷贝和赋值操作原本的智能指针对象悬空，那么我就不让拷贝和赋值吧！因此，unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理。
template<class T>
class unique_ptr
{
public:
//RAII
//保存资源
unqiue_ptr(T* ptr)
:_ptr(ptr)
{}
//释放资源
~unique_ptr()
{
delete _ptr;
//用于测试资源是否释放成功
cout << _ptr << endl;
}
//不给拷贝
unique_ptr(const unique_ptr<T>& up) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
//像指针一样
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
private:
T* _ptr;
};3.5 std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
template<class T>
class shared_ptr
{
public:
//RAII
//保存资源
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new int(1))
{}
//释放资源
~shared_ptr()
{
Release();
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
++(*_pcount);
}
void Release()
{
//如果计数减到0了，就释放资源
if (--(*_pcount) == 0)
{
delete _pcount;
delete _ptr;
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//判断是否自己给自己赋值
if (_ptr != sp._ptr)
{
//释放资源
Release();
_pcount = sp._pcount;
_ptr = sp._ptr;
++(*_pcount);
}
return *this;
}
// 像指针一样
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
private:
T* _ptr;
int* _pcount;//计数引用
};std::shared_ptr的线程安全问题
在shared_ptr中的构造和赋值的计数引用操作，我们需要给上锁，来保证线程安全。
template<class T>
class shared_ptr
{
public:
//RAII
//保存资源
shared_ptr(T* ptr=nullptr)
:_ptr(ptr)
, _pcount(new int(1))
,_pmtx(new mutex)
{}
//释放资源
~shared_ptr()
{
Release();
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
,_pmtx(sp._pmtx)
{
//加锁
_pmtx->lock();
++(*_pcount);
//解锁
_pmtx->unlock();
}
void Release()
{
bool flag = false;
_pmtx->lock();
//如果计数减到0了，就释放资源
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
flag = true;
}
_pmtx->unlock();
if (flag == true)
{
delete _pmtx;
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//判断是否自己给自己赋值
if (_ptr != sp._ptr)
{
//释放资源
Release();
_pcount = sp._pcount;
_ptr = sp._ptr;
_pmtx = sp._pmtx;
_pmtx->lock();
++(*_pcount);
_pmtx->unlock();
}
return *this;
}
int use_count() const
{
return *_pcount;
}
T* get() const
{
return _ptr;
}
// 像指针一样
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
private:
T* _ptr;
int* _pcount;//计数引用
mutex* _pmtx;//锁
};
};shared_ptr本身是线程安全的，就是在拷贝和析构的时候，引用计数++--是线程安全的，但是shared_ptr管理资源的访问并不是线程安全的，需要用的地方自行保护。
看下面代码，对于简单日期类的资源，我们可以直接在执行代码的地方添加锁来保证线程安全。
struct Date
{
int _year = 0;
int _month = 0;
int _day = 0;
};
void test_shared_ptr1()
{
int n = 10000;
mutex mtx;
shared_ptr<Date> sp1(new Date);
thread t1([&]()
{
for (int i = 0; i < n; ++i)
{
shared_ptr<Date> sp2(sp1);
mtx.lock();
sp2->_year++;
sp2->_month++;
sp2->_day++;
mtx.unlock();
}
});
std::thread t2([&]()
{
for (int i = 0; i < n; ++i)
{
shared_ptr<Date> sp3(sp1);
mtx.lock();
sp3->_year++;
sp3->_month++;
sp3->_day++;
mtx.unlock();
}
});
t1.join();
t2.join();
cout << sp1.use_count() << endl;
cout << sp1.get() << endl;
cout << sp1->_year << endl;
cout << sp1->_month << endl;
cout << sp1->_day << endl;
}
结果正如我们期望的，计数引用到最后变回1个，年月日的次数增加到2万。
定制删除器
在智能指针中，我们可以看到，释放资源的代码为：
delete _ptr;那如果我们的类型是一个数组，是一个文件类型，那么这种释放资源的方式很明显是不对的。为了解决这个问题，就可以使用定制删除器。
在使用shared_ptr智能指针的时候，除了传入类型，我们还可以传入定制删除器。
//定制删除器
template<class T>
struct DeleteArray
{
void operator()(const T* ptr)
{
delete[] ptr;
}
};
int main()
{
//delete[] ptr
std::shared_ptr<int> sp1(new int[10], DeleteArray<int>());
std::shared_ptr<string> sp2(new string[10], DeleteArray<string>());
std::shared_ptr<string> sp3(new string[10], [](string* str) {delete[] str; });
std::shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), [](FILE* f) {fclose(f); });
}循环引用
对于shared_ptr的引用计数，有一个问题，那就是它会在某些场景下导致循环引用。先看下面一段代码：
struct ListNode
{
int val;
//一样的
//std::shared_ptr<ListNode> _next;
//std::shared_ptr<ListNode> _prev;
my_smartptr::shared_ptr<ListNode> _next;
my_smartptr::shared_ptr<ListNode> _prev;
~ListNode()
{
//用于测试
cout << "~ListNode()" << endl;
}
};
void test_shared_ptr2()
{
my_smartptr::shared_ptr<ListNode> node1(new ListNode);
my_smartptr::shared_ptr<ListNode> node2(new ListNode);
node1->_next = node2;
node2->_prev = node1;
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
}代码分析：
上面说到，智能指针管理的资源的生命周期是跟随对象的生命周期的。在上面的代码中，node1指向了一组资源，node2也指向了一组资源，这没问题。如果把node1->_next = node2;和node2->_prev = node1;这段代码注释并运行后，得到的结果是这样的：
结果说明了，引用计数一开始都是1，然后释放资源。但是加上那段代码后，结果就变成这样了：
这就是循环引用的问题所在了！
循环引用之后，对于node1指向的那一组资源，也被node2->_prev指向了，并且node2->_prev是作为对象去指向这一组资源的。同样的，对于对于node2指向的那一组资源，也被node1->_next指向了，并且node2->_prev是作为对象去指向这一组资源的。
于是就会造成以下问题：
计数引用：
①node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
② node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
释放资源：
③node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
④_next和_prev属于node节点的成员，节点释放了，_next和_prev才会析构。
④要让右边这个节点销毁，就得让node1->_next先释放，而要让node1->_next释放，就必须让左边这个节点先销毁，要让左边这个节点销毁，就需要让node2->_prev先释放，要让node2->_prev释放，就需要右边这个节点销毁，要让右边这个节点销毁，就得让node1->_next先释放......陷入死循环了。
解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。
struct ListNode
{
int val;
//一样的
//std::shared_ptr<ListNode> _next;
//std::shared_ptr<ListNode> _prev;
//my_smartptr::shared_ptr<ListNode> _next;
//my_smartptr::shared_ptr<ListNode> _prev;
std::weak_ptr<ListNode> _prev;
std::weak_ptr<ListNode> _next;
~ListNode()
{
//用于测试
cout << "~ListNode()" << endl;
}
};
void test_shared_ptr2()
{
std::shared_ptr<ListNode> n1(new ListNode);
std::shared_ptr<ListNode> n2(new ListNode);
n1->_next = n2;
n2->_prev = n1;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
}
最后提一下C++11和boost中智能指针的关系
boost库我们可以看作是C++官方库的先锋队，它为C++官方库开辟道路，让官方库从中吸取经验。
在智能指针方面：
1. C++ 98 中产生了第一个智能指针auto_ptr. 2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr. 3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。 4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。
腾讯云开发者
