C++基础语法——智能指针

指针"/>

C++基础语法——智能指针

目录

1.智能指针存在的意义

2.内存泄漏

①什么是内存泄漏，内存泄漏的危害

②内存泄漏分类

③如何检测内存泄漏

④如何避免内存泄漏

3.智能指针的使用及其模拟实现

①RAII

②智能指针的原理

③std::auto_ptr

模拟实现

④std::unique_ptr

模拟实现

⑤std::shared_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中可以直接使用deleteunique_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++11shared_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 = s2shared_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 = s2shared_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中的实现的。