目录
1.智能指针存在的意义
2.内存泄漏
①什么是内存泄漏，内存泄漏的危害
②内存泄漏分类
③如何检测内存泄漏
④如何避免内存泄漏
3.智能指针的使用及其模拟实现
①RAII
②智能指针的原理
③std::auto_ptr
模拟实现
④std::unique_ptr
模拟实现
模拟实现
⑥std::weak_ptr
模拟实现
⑦定制删除器
4.C++11和boost中智能指针的关系
1.智能指针存在的意义
在之前我们使用new之后只要记住使用delete将其释放，基本上不会出什么大问题，但是在异常出现之后，由于遇到异常时会直接将其抛出，这样可能就会导致这段程序无法运行到delete指令，从而导致内存泄漏，举个例子
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>;
div();
delete p1;
cout << "delete:" << p1 << endl;
}
int main()
{
try
{
f();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}在上面的代码中如果运行到div()函数时输入的b为0时，会直接抛异常这样就会直接跳到主函数中的catch处，从而导致p1没有得到释放，直接导致内存泄漏，有人可能会想在f函数中再套一层try即可，但是当在堆上申请的变量过多时，这样的写法会略显冗余，此时就需要智能指针了。
2.内存泄漏
①什么是内存泄漏，内存泄漏的危害
内存泄漏是什么？
内存泄漏：指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
那么内存泄漏会有什么样的危害？
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。这里一般有两种情况，如
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
div(); // 这里div函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}②内存泄漏分类
在C/C++程序中我们一般关心两种方面的内存泄漏
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
③如何检测内存泄漏
在 linux下内存泄漏检测： Linux下几款内存泄露检查工具（推荐）在 windows下使用第三方工具： VLD工具说明其他工具： 内存泄露检测工具比较
④如何避免内存泄漏
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。
3.智能指针的使用及其模拟实现
①RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
1. 不需要显式地释放资源。
2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。
因此我们可以基于这种思想设计一个smart_ptr类
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
private:
T* _ptr;
};
void Func()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(new int);
cout << div() << endl;
}
int main()
{
try {
Func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}这样就做到了就算div函数抛异常，在作用域周期结束时，智能指针会自动调用析构函数，从而自动释放内存。
②智能指针的原理
但是上面写的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。我们对其稍作修改，有
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};
struct Date
{
Date()
{}
int _year = 0;
int _month = 0;
int _day = 0;
};
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;
}总结一下智能指针的原理：
1. RAII特性
2. 重载operator*和opertaor->，具有像指针一样的行为。
但是智能指针到这就结束了吗？ 其实并不是，如果想将一个智能指针赋值给另一个又该怎么办呢？在这里C/C++提供了四种智能指针来解决这个问题分别是auto_ptr, unique_ptr, shared_ptr, weak_ptr
③std::auto_ptr
它的使用举例如下
int main()
{
auto_ptr<int> sp1(new int);
auto_ptr<int> sp2(sp1); // 管理权转移
// sp1悬空
*sp2 = 10;
cout << *sp2 << endl;
cout << *sp1 << endl;
return 0;
}在运行时我们可以发现
在进行构造操作后，我们可以看到sp1就被置空了，因此我们可以知道auto_ptr的实现实际是将原有的资源管理权转移给新的对象，这无疑是一个失败的设计，在许多的公司中都有明确要求禁止使用auto_ptr，
模拟实现
我们模拟实现该指针的代码如下
namespace my_ptr
{
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
// sp2(sp1)
// 将sp1的资源转移给sp2，然后将自己置空
auto_ptr(auto_ptr<T>& ptr)
:_ptr(ptr._ptr)
{
ptr._ptr = nullptr;
}
~auto_ptr()
{
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr = nullptr;
};
}④std::unique_ptr
C++11中开始提供更靠谱的unique_ptr，它不允许被拷贝
其使用举例如下
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
~A()
{
cout << this;
cout << " ~A()" << endl;
}
//private:
int _a;
};
int main()
{
// C++11 简单粗暴，不让拷贝
unique_ptr<A> up1(new A(1));
unique_ptr<A> up2(new A(2));
unique_ptr<A> up3(up1);
up1 = up2;
return 0;
}编译有
模拟实现
其模拟实现如下
namespace my_ptr
{
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
// C++11中可以直接使用delete
unique_ptr(unique_ptr<T>& ptr) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ptr) = delete;
~unique_ptr()
{
delete _ptr;
}
T* operator*()
{
return _ptr;
}
T& operator->()
{
return *_ptr;
}
private:
T* _ptr;
};
}⑤std::shared_ptr
此外，C++11中也提供更靠谱的并且支持拷贝的shared_ptr，那么它的支持拷贝的原理是怎样的呢？
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。如：在读书的时候，每天晚上在放学之后，最后走的学生会把灯关上。
1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
我们可以使用如下的代码来验证
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
~A()
{
cout << this;
cout << " ~A()" << endl;
}
//private:
int _a;
};
int main()
{
// C++11
shared_ptr<A> sp1(new A(1));
shared_ptr<A> sp2(new A(2));
shared_ptr<A> sp3(sp1);
sp1->_a++;
sp3->_a++;
cout << sp1->_a << endl;
shared_ptr<A> sp4(sp2);
shared_ptr<A> sp5(sp4);
sp1 = sp5;
sp3 = sp5;
shared_ptr<A> sp6(new A(6));
sp6 = sp6;
sp4 = sp5;
cout << sp6->_a << endl;
return 0;
}运行如下
模拟实现
其模拟实现的代码如下
namespace my_ptr
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new int(1))
{}
// 拷贝构造
// s3(s2)
// s5 = s2
shared_ptr(shared_ptr<T>& ptr)
:_ptr(ptr._ptr)
, _pcount(ptr._pcount)
{
++(*_pcount);
}
// 赋值运算符重载
// s6 = s2
// s7 = s6
// s6 = s7(让自己赋值给自己不增加计数)
shared_ptr<T>& operator=(shared_ptr<T>& ptr)
{
if (ptr._ptr == _ptr)
{
return *this;
}
// 如果当前指向的计数为最后一个需要释放当前指针
if (--(*_pcount) == 0)
{
delete _pcount;
delete _ptr;
}
_ptr = ptr._ptr;
_pcount = ptr._pcount;
++(*_pcount);
return *this;
}
~shared_ptr()
{
--(*_pcount);
if (*_pcount == 0)
{
delete _ptr;
delete _pcount;
}
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
// 提供两个接口获取指针与计数
int GetCount() const
{
return *_pcount;
}
T* get() const
{
return _ptr;
}
private:
T* _ptr;
// 在这里使用指针，而非静态变量是多方面原因的考量，
// 有多线程的问题，也有静态区变量的释放问题
int* _pcount;
};
}有了shared_ptr之后，我们可以解决绝大多数的指针问题，但是它在某些方面还是有一些缺陷，在下面这个场景中
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
~A()
{
cout << this;
cout << " ~A()" << endl;
}
//private:
int _a;
};
struct Node
{
Node()
{}
~Node() { cout << "~Node()" << endl; }
A _val;
my_ptr::shared_ptr<Node> _next = nullptr;
my_ptr::shared_ptr<Node> _prev = nullptr;
};
int main()
{
// 循环引用
my_ptr::shared_ptr<Node> sp1(new Node);
my_ptr::shared_ptr<Node> sp2(new Node);
cout << sp1.GetCount() << endl;
cout << sp2.GetCount() << endl;
sp1->_next = sp2;
sp2->_prev = sp1;
cout << sp1.GetCount() << endl;
cout << sp2.GetCount() << endl;
return 0;
}在运行后，我们可以发现
在程序结束后，sp1与sp2均还存在且它们的计数均为1，对于这种情况我们称之为循环引用，接下来让我们来具体分析一下它
1. sp1和sp2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
2. sp1的_next指向sp2，sp2的_prev指向sp1，引用计数变成2。
3. sp1和sp2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
4. 也就是说_next析构了，sp2就释放了。
5. 也就是说_prev析构了，sp1就释放了。
6. 但是_next属于sp的成员，sp1释放了，_next才会析构，而sp1由_prev管理，_prev属于sp2成员，所以这就叫循环引用，谁也不会释放。
图示如下
那要如何解决这个问题呢？此时就需要weak_ptr了
⑥std::weak_ptr
要解决上面的问题我们只需要将Node中_prev和_next替换为weak_ptr即可，可以认为weak_ptr不是RAII智能指针，专门用来解决shared_ptr循环引用问题。因此weak_ptr是无法进行资源管理的
模拟实现
其模拟实现如下
namespace my_ptr
{
template<class T>
class weak_ptr
{
public:
weak_ptr(T* ptr)
:_ptr(ptr._ptr)
{}
weak_ptr(shared_ptr<T>& ptr)
:_ptr(ptr.get())
{}
weak_ptr<T>& operator=(shared_ptr<T>& ptr)
{
_ptr = ptr.get();
return *this;
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
};
}在使用weak_ptr代替shared_ptr之后再次运行我们可以发现
这样就解决了循环引用的问题
⑦定制删除器
如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题
我们对shared_ptr改造有
namespace my_ptr
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new int(1))
{}
template<class D>
shared_ptr(T* ptr, D del)
: _ptr(ptr)
, _pcount(new int(1))
, _del(del)
{}
// 拷贝构造
// s3(s2)
// s5 = s2
shared_ptr(shared_ptr<T>& ptr)
:_ptr(ptr._ptr)
, _pcount(ptr._pcount)
{
++(*_pcount);
}
// 赋值运算符重载
// s6 = s2
// s7 = s6
// s6 = s7(让自己赋值给自己不增加计数)
shared_ptr<T>& operator=(shared_ptr<T>& ptr)
{
if (ptr._ptr == _ptr)
{
return *this;
}
// 如果当前指向的计数为最后一个需要释放当前指针
if (--(*_pcount) == 0)
{
delete _pcount;
delete _ptr;
}
_ptr = ptr._ptr;
_pcount = ptr._pcount;
++(*_pcount);
return *this;
}
~shared_ptr()
{
--(*_pcount);
if (*_pcount == 0)
{
_del(_ptr);
delete _pcount;
}
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
// 提供两个接口获取指针与数量
int GetCount() const
{
return *_pcount;
}
T* get() const
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
function<void(T*)> _del = [](T* ptr) {delete ptr; };
};
}此后，需要删除时，我们只需要自己给出对应的删除方式即可，如
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
~A()
{
cout << this;
cout << " ~A()" << endl;
}
//private:
int _a;
};
template<class T>
struct DeleteArray
{
void operator()(T* ptr)
{
delete[] ptr;
}
};
// 定制删除器
int main()
{
my_ptr::shared_ptr<A> sp1(new A[10], DeleteArray<A>());
my_ptr::shared_ptr<A> sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
my_ptr::shared_ptr<FILE> sp3(fopen("Test.cpp", "r"), [](FILE* ptr) {
cout << "fclose:" << ptr << endl;
fclose(ptr);
});
my_ptr::shared_ptr<A> sp1(new A);
return 0;
}4.C++11和boost中智能指针的关系
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中的实现的。
