C++11 智能指针详解

        C++ 程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己 管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11 中引入了智能指针的 概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常 时内存泄露等问题等，使用智能指针能更好的管理堆内存。

        C++ 里面的四个智能指针 : auto_ptr,unique_ptr,shared_ptr, weak_ptr  其中后三个是 C++11 支持，并且第一个已经被C++11 弃用。

目录

一. shared_ptr(共享智能指针)

1.shared_ptr的基本用法

1）初始化

2）获取原始指针

2.shared_ptr使用问题

1)不能用一个原始指针初始化多个shared_ptr，更不能初始化非堆的内存。

2)不能在函数实参中创建智能指针

3）不要将this指针作为shared_ptr返回回来。

4）循环引用

二 . unique_ptr(独占智能指针)

        1. 不允许赋值

        2.通过std::move 移动

        3.使用make_unique效率更高（C++14引入）

        4. unique_ptr 指定删除器

三 . weak_ptr(弱引用智能指针)     

 1.基本用法

  1).weak_ptr使用

  2). 通过expired()方法判断所观察资源是否已经释放

  3). 通过lock方法获取监视的shared_ptr

  2. weak_ptr返回this指针

  3. 解决循环引用

四：智能指针使用安全问题

---

一. shared_ptr(共享智能指针)

        

        shared_ptr共享被管理对象，同一时刻可以有多个 shared_ptr 拥有对象的所有权，当最后一个

shared_ptr 对象销毁时，被管理对象自动销毁。

        shared_ptr使用引用计数(use_count)，每一个shared_ptr 的拷贝都指向相同的内存。再最后一个 shared_ptr 析 构的时候，内存才会被释放。

        

   shared_ptr实现包含了两部分：

•   一个指向堆上创建的对象的裸指针，raw_ptr
• 一个指向内部隐藏的、共享的管理对象。 share_count_object

1.shared_ptr的基本用法

1）初始化

通过构造函数、 std::shared_ptr 辅助函数和 reset 方法来初始化 shared_ptr

std::shared_ptr p1(new int(1)); 
std::shared_ptr p2 = p1; 
std::shared_ptr p3; 
p3.reset(new int(1));  //构建对象
p3.reset();            //析构对象

注意：

• 如果使用考虑效率，可以使用make_shared

  这是因为：make_shared 通常具有更好的性能，因为它可以在一次堆分配中同时分配对象和控制块，而不是两次分配（一个用于对象，一个用于控制块），而普通的shared是进行两次分配，先分配一个内存块用于存储对象，然后再分配另一个内存块用于存储控制块，这就是两次分配。

 auto sp1 = make_shared(100)  等价于 shared_ptr sp1(new int(100));

• 不能将一个原始指针直接赋值给一个智能指针，需要通过构造函数和辅助方法（隐式转换或reset）来初始化，下述行为时错误的

  std::shared_ptr p = new int(1);

•  上述示例中，p1和p2不是同一个地址，p1.get()和p2.get() 才是同一个地址，共同指向raw_ptr

2）获取原始指针

当需要原始指针的时候。可以通过调用get返回luo'zhi

shared_ptr p3(p1);  //引用计数+1
p3.reset(new TEST); //reset有参数表示分配资源， 无参表示释放资源
TEST *p = p3.get();

注意：

• 不要delete p.get()的返回值 ，会导致对一块内存delete两次的错误
• 不要保存 p.get() 的返回值 ，无论是保存为裸指针还是 shared_ptr 都是错误的
• 保存为裸指针不知什么时候就会变成空悬指针，保存为 shared_ptr 则产生了独立指针
  3）指定删除器
  当shared_ptr管理非new的对象或者没有析构函数的对象的时候，应该传递合适的删除器
  3-1示例表示自动关系析构函数
  3-1) 函数做删除器

  void release_source(TEST *p)
  {
      cout<<"release_source"< p1(new TEST,release_source);
      return 0;
  }

      

      

        3-2) Lambda表达式做删除器    

shared_ptr p2(new TEST,[](TEST *p){
        cout<<"release_source"<

  注意：

•  当智能指针管理数组的时候需要指定删除器或使用模板类default_delete（因为shared_ptr默认删除器不支持数组对象） 

  原因：智能指针默认的删除器（deleter）是针对单个对象的，而不是数组对象。这是因为C++中数组的内存布局和单个对象是不同的。数组通常需要在内存中连续存储多个元素，而单个对象只占用一个内存块。C++11引入了std::shared_ptr的一个专门版本：std::shared_ptr，它支持管理数组对象。当你使用std::shared_ptr时，你需要提供一个删除器，该删除器知道如何使用delete[]来释放内存，从而正确处理数组。

std::shared_ptr p3(new int[10], [](int *p) { delete [] p;});
std::shared_ptrptr(new int[10],std::default_delete());

2.shared_ptr使用问题

1)不能用一个原始指针初始化多个shared_ptr，更不能初始化非堆的内存。

int *p =  new int;
shared_ptrptr1(p);
shared_ptrptr2(p); //逻辑错误

2)不能在函数实参中创建智能指针

function(shared_ptr(new int), g()); //有缺陷

C++函数参数对于不同的编译器执行过程可能时不同的，可能从左到右或从右到左。假设想new int，然后调用g().此时g发生了异常 ，shared_ptr还没创建完成（用make_shared会快一些），就会造成内存泄漏

正确做法：

shared_ptr p(new int);
function(p, g());

3）不要将this指针作为shared_ptr返回回来。

        this指针本质也是一个裸指针，可能会造成重复析构

class TEST
{
public:
    TEST()
    {
        cout<<"new TEST"<get_ptr()
    {
        return shared_ptr(this);
    }
};

int main()
{

    shared_ptrp1(new TEST);
    shared_ptrp2 = p1->get_ptr();
    return 0;

}

 在这个例子中，由于用同一个指针（this)构造了两个智能指针sp1和sp2，而他们之间是没有任何关系 的，在离开作用域之后this将会被构造的两个智能指针各自析构，导致重复析构的错误

正确做法： 让目标类通过 std::enable_shared_from_this 类，然后使用基类的

成员函数 shared_from_this() 来返回 this 的 shared_ptr

class TEST:public enable_shared_from_this
{
public:
    TEST()
    {
        cout<<"new TEST"<get_ptr()
    {
        return shared_from_this();
        // return shared_ptr(this);
    }
};

  4）循环引用

        智能指针shared_ptr的出现可以使得同一资源被多个指针共享，并且保证共享资源只被释放一次，其内部使用计数器原理。但是两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。

看案例：

#include 
#include 
#include
#include 

using namespace std;

class B;

class A 
{
public:
    shared_ptr pb_;  
    ~A()
    {
        cout<<"A delete"< pa_;
    ~B()
    {
        cout<<"B delete"< pb(new B());
    shared_ptr pa(new A());

    pb->pa_ = pa;
    pa->pb_ = pb;
    cout<

 解决办法：

        下面会讲

        weak_ptr对象指向shared_ptr对象时（反之亦然），不会增加shared_ptr中的引用计数。

        当然使用weak_ptr的时候需要注意访问对象的方法。

shared_ptr pb_ -> weak_ptr pb_;

二 . unique_ptr(独占智能指针)

        独占智能指针不允许其他智能指针共享，也不允许通过将一个 unique_ptr赋值到unique_ptr中。但是unique_ptr可以通过move操作移动unique_ptr（原指针失效） 当然也可以通过返回进行返回。以下举例：

        1. 不允许赋值

#include
#include
using namespace std;

class TEST
{
public:
    TEST()
    {
        cout<<"new TEST"< p1(new TEST);
    unique_ptr p2(p1); //错误

    return 0;
}

        2.通过std::move 移动

unique_ptr p1(new TEST);
unique_ptr p2(std::move(p1)); //正确

        3.使用make_unique效率更高（C++14引入）

auto p3(make_unique());

        4. unique_ptr 指定删除器

        对于shared_ptr,指定删除器        

shared_ptrp1(new int, [](int *p){delete p;});

       对于unique_ptr，指定删除器需要确定删除器的类型

unique_ptr p6(new int, [](int *p){delete p;});

        比如指针是指向一个数组，对于共享指针，默认删除器是不能删除数组的，需要注意。

  

三 . weak_ptr(弱引用智能指针)     

      weak_ptr是一种不控制对象生命周期的弱引用指针（因为没有引用计数）。用来解决shared_ptr相互引用导致引用计数不能减为0。它不会增加引用计数，可以和shared_ptr之间相互转化，shared_ptr可以赋值给他（反之亦然）,可以通过lock函数获取shared_ptr指针。

        weak_ptr没有*和->,因为它不共享指针，构造和析构不会造成引用计数的增减。作为一个纯粹的旁观者监测shared_ptr变化。weak_ptr还可以返回this指针和解决循环引用的问题

 1.基本用法

  1).weak_ptr使用

shared_ptr s1(new int);
weak_ptr   w1(s1);
cout<< w1.use_count()<

2). 通过expired()方法判断所观察资源是否已经释放

int main()
{
    shared_ptr s1(new int);
    weak_ptr   w1(s1);
    weak_ptr   w2(move(w1));
    cout<< w1.use_count()<

通过move将w1指针移动到w2.w1释放。    

 3). 通过lock方法获取监视的shared_ptr

std::weak_ptr ptr2; 
void f() 
{ 
    if(ptr2.expired())
    { 
        cout << "ptr2 invaild"<
 
     
  2. weak_ptr返回this指针
 
    

    在使用shared_ptr的时候是不能直接将this指针返回shared_ptr的，需要通过继承enable_shared_from_this，然后基类调用shared_from_this()返回指针。这是因为

enable_shared_from_this中有一个weak_ptr.这个weak_ptr通过lock观察this指针.将观察的shared_ptr返回。

3. 解决循环引用

    智能指针shared_ptr的出现可以使得同一资源被多个指针共享，并且保证共享资源只被释放一次，其内部使用计数器原理。但是两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。

看案例：

#include 
#include 
#include
#include 

using namespace std;

class B;

class A 
{
public:
    shared_ptr pb_;  
    ~A()
    {
        cout<<"A delete"< pa_;
    ~B()
    {
        cout<<"B delete"< pb(new B());
    shared_ptr pa(new A());

    pb->pa_ = pa;
    pa->pb_ = pb;
    cout<

 解决办法：

        weak_ptr对象指向shared_ptr对象时（反之亦然），不会增加shared_ptr中的引用计数。

        当然使用weak_ptr的时候需要注意访问对象的方法。

shared_ptr pb_ -> weak_ptr pb_;

weak_ptr使用注意事项：

    在使用wp前需要调用wp.expired()函数判断一下。避免对象已经释放问题

四：智能指针使用安全问题

1. 注意多线程共享智能指针问题，后续补充