C++：智能指针【unique_ptr、shared_ptr、weak_ptr】【自动释放所指向的对象】【定义在memory.h标准头文件中】_unique_ptr 不使用release会崩溃

一、概述 

我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。

程序用堆来存储动态分配的对象（即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式地销毁它们）。

在C++中，动态内存的管理是用一对运算符完成的：new和delete。

• new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针;
• delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。

动态内存管理经常会出现两种问题：
（1）一种是忘记释放内存，会造成内存泄漏；
（2）一种是尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针。

为了更加容易（更加安全）的使用动态内存，引入了智能指针的概念。

智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。

标准库提供的两种智能指针（shared_ptr、unique_ptr）的区别在于管理底层指针的方法不同：

1. shared_ptr：允许多个指针指向同一个对象；
2. unique_ptr：“独占”所指向的对象。

标准库还定义了一种名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象，这三种智能指针都定义在memory头文件中。

二、auto_ptr （过时的指针）

1、内部大概实现

做成一个auto_ptr类，包含原始指针成员。当auto_ptr类型的对象被释放时，利用析构函数，将拥有的原始指针delete掉。

//大概长这个样子（简化版）
template<class T>
class auto_ptr
{　　
    T* ptr;
};

2、示例用法

//runGame函数执行完时，monster1被释放，然后它的析构函数也把指向的一个怪物释放了
void runGame(){
  std::auto_ptr<Monster> monster1(new Monster());//monster1 指向 一个怪物
  monster1->doSomething();//怪物做某种事
}

复制auto_ptr对象时，把指针指传给复制出来的对象，原有对象的指针成员随后重置为nullptr。这说明auto_ptr是独占性的，不允许多个auto_ptr指向同一个资源。

void runGame(){
     std::auto_ptr<Monster> monster1(new Monster());//monster1 指向 一个怪物
     monster1->doSomething();						//怪物做某种事
     std::auto_ptr<Monster> monster2 = monster1;	//转移指针
     monster2->doSomething();						//怪物做某种事
     monster1->doSomething();						//Oops!monster1智能指针指向了nullptr，运行期崩溃。
}

注意：虽然本文简单介绍了auto_ptr。但是不要用auto_ptr! 不要用auto_ptr!

虽然它是c++11以前的最原始的智能指针，但是在c++11中已经被弃用（使用的话会被警告）了。
它的替代品，也就是c++11新智能指针unique_ptr、shared_ptr、weak_ptr。

三、shared_ptr（一种强引用指针）

多个shared_ptr指向同一处资源，当所有shared_ptr都全部释放时，该处资源才释放。

有某个对象的所有权（访问权，生命控制权） 即是“强引用”，所以shared_ptr是一种强引用型指针。

1、内部大概实现

每次复制，多一个共享同处资源的shared_ptr时，计数+1。每次释放shared_ptr时，计数-1。
当shared计数为0时，则证明所有指向同一处资源的shared_ptr们全都释放了，则随即释放该资源（哦，还会释放new出来的SharedPtrControlBlock）。
 

//shared计数放在这个结构体里面，实际上结构体里还应该有另一个weak计数。下文介绍weak_ptr时会解释。
struct SharedPtrControlBlock{　　
  int shared_count;
};
 
//大概长这个样子（简化版）
template<class T>
class shared_ptr{　　
  T* ptr;　　
  SharedPtrControlBlock* count;
};

2、示例用法

void runGame() {
    std::shared_ptr <Monster> monster1(new Monster());//计数加到1
    do {
        std::shared_ptr <Monster> monster2 = monster1;    //计数加到2　　
    } while (0);
    //该栈退出后，计数减为1，monster1指向的堆对象仍存在
    std::shared_ptr <Monster> monster3 = monster1;    //计数加到2
}//该栈退出后，shared_ptr都释放了，计数减为0，它们指向的堆对象也能跟着释放.

缺陷：模型循环依赖(互相引用或环引用)时，计数会不正常。

假如有这么一个怪物模型，它有2个亲人关系：

class Monster {
    std::shared_ptr <Monster> m_father;
    std::shared_ptr <Monster> m_son;
public:
    void setFather(std::shared_ptr <Monster> &father);
    void setSon(std::shared_ptr <Monster> &son);
    ~Monster() { std::cout << "A monster die!"; }
};
 
void runGame() {
    std::shared_ptr <Monster> father = new Monster();
    std::shared_ptr <Monster> son = new Monster();
    father->setSon(son);
    son->setFather(father);
}

函数退出时栈的shared_ptr对象陆续释放后的情形：

• 一开始：father,son指向的堆对象 shared计数都是为2；
• son智能指针退出栈：son指向的堆对象 计数减为1，father指向的堆对象 计数仍为2。
• father智能指针退出栈：father指向的堆对象 计数减为1 , son指向的堆对象 计数仍为1。
• 函数结束：所有计数都没有变0，也就是说中途没有释放任何堆对象。

为了解决这一缺陷的存在，弱引用指针weak_ptr的出现很有必要。

......

待写

......

四、weak_ptr（一种弱引用指针）

weak_ptr是为了辅助shared_ptr的存在，它只提供了对管理对象的一个访问手段，同时也可以实时动态地知道指向的对象是否存活。

只有某个对象的访问权，而没有它的生命控制权 即是“弱引用”，所以weak_ptr是一种弱引用型指针

五、unique_ptr（一种强引用）

正如它的名字，独占 是它最大的特点。

1、内部大概实现

它其实算是auto_ptr的翻版(都是独占资源的指针,内部实现也基本差不多).

但是unique_ptr的名字能更好的体现它的语义，而且在语法上比auto_ptr更安全（尝试复制unique_ptr时会编译期出错，而auto_ptr能通过编译期从而在运行期埋下出错的隐患）

假如你真的需要转移所有权（独占权），那么你就需要用std::move(std::unique_ptr对象)语法，尽管转移所有权后 还是有可能出现原有指针调用（调用就崩溃）的情况。

但是这个语法能强调你是在转移所有权，让你清晰的知道自己在做什么，从而不乱调用原有指针。
 

1、示例用法

void runGame() {
    std::unique_ptr <Monster> monster1(new Monster());//monster1 指向 一个怪物　　
    std::unique_ptr <Monster> monster2 = monster1;//Error!编译期出错，不允许复制指针指向同一个资源。　　   	std::unique_ptr<Monster> monster3 = std::move(monster1);//转移所有权给monster3.　　
    monster1->doSomething();//Oops!monster1指向nullptr，运行期崩溃
}

额外：boost库的boost::scoped_ptr也是一个独占性智能指针，但是它不允许转移所有权，从始而终都只对一个资源负责，它更安全谨慎，但是应用的范围也更狭窄。

 虽然我们不能拷贝或者赋值unique_ptr，但是可以通过调用release或reset将指针所有权从一个（非const）unique_ptr转移给另一个unique。

//将所有权从p1（指向string Stegosaurus）转移给p2
unique_ptr<string> p2(p1.release());//release将p1置为空
unique_ptr<string>p3(new string("Trex"));
//将所有权从p3转移到p2
p2.reset(p3.release());//reset释放了p2原来指向的内存

release成员返回unique_ptr当前保存的指针并将其置为空。因此，p2被初始化为p1原来保存的指针，而p1被置为空。

reset成员接受一个可选的指针参数，令unique_ptr重新指向给定的指针。

调用release会切断unique_ptr和它原来管理的的对象间的联系。release返回的指针通常被用来初始化另一个智能指针或给另一个智能指针赋值。

不能拷贝unique_ptr有一个例外：我们可以拷贝或赋值一个将要被销毁的unique_ptr。

最常见的例子是从函数返回一个unique_ptr：
 

unique_ptr<int> clone(int p) {
    //正确：从int*创建一个
    unique_ptr < int >
    return unique_ptr<int>(new int(p));
}

还可以返回一个局部对象的拷贝：

unique_ptr<int> clone(int p) {
    unique_ptr<int> ret(new int(p));
    return ret;
}

向后兼容：auto_ptr
标准库的较早版本包含了一个名为auto_ptr的类，它具有uniqued_ptr的部分特性，但不是全部。

用unique_ptr传递删除器
unique_ptr默认使用delete释放它指向的对象，我们可以重载一个unique_ptr中默认的删除器

我们必须在尖括号中unique_ptr指向类型之后提供删除器类型。在创建或reset一个这种unique_ptr类型的对象时，必须提供一个指定类型的可调用对象删除器。
 

六、小结

使用建议：

1. 不要使用std::auto_ptr
2. 当你需要一个独占资源所有权（访问权+生命控制权）的指针，且不允许任何外界访问，请使用std::unique_ptr
3. 当你需要一个共享资源所有权（访问权+生命控制权）的指针，请使用std::shared_ptr
4. 当你需要一个能访问资源，但不控制其生命周期的指针，请使用std::weak_ptr

推荐用法：一个shared_ptr和n个weak_ptr搭配使用 而不是n个shared_ptr。

逻辑上，大部分模型的生命在直观上总是受某一样东西直接控制而不是多样东西共同控制。

程序上，能够完全避免生命周期互相控制引发的 循环引用问题。
 

C++智能指针详解_夏之七的博客-CSDN博客_c++ 智能指针