C++ 11/14/17 智能指针

news2024/9/21 22:55:58

1. 简介

为了更加容易（更加安全）的使用动态内存，引入了智能指针的概念。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。

标准库提供的两种智能指针的区别在于管理底层指针的方法不同：shared_ptr和unique_ptr。
1）shared_ptr允许多个指针指向同一个对象；
2）unique_ptr则“独占”所指向的对象。

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

2. shared_ptr

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

1. 内部大概实现：

每次复制，多一个共享同处资源的shared_ptr时，计数+1。每次释放shared_ptr时，计数-1。
当shared计数为0时，则证明所有指向同一处资源的shared_ptr们全都释放了。

//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，它们指向的堆对象也能跟着释放.

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

创建智能指针时必须提供额外的信息，指针可以指向的类型：

shared_ptr<string>p1;
shared_ptr<list<int>> p2;

默认初始化的智能指针中保存着一个空指针。
智能指针的使用方式和普通指针类似，解引用一个智能指针返回它指向的对象，在一个条件判断中使用智能指针就是检测它是不是空。

if(p1 && p1->empty())
  *p1 = "hi";

3. 如下表所示是shared_ptr特有的操作：

函数说明

1）make_share函数

最安全的分配和使用动态内存的方法就是调用一个名为make_shared的标准库函数，此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。头文件和share_ptr相同，在memory中。

必须指定想要创建对象的类型，定义格式如下：

shared_ptr<int> p3 = make_shared<int>(42);
shared_ptr<string> p4 = make_shared<string>(10,'9');
shared_ptr<int> p5 = make_shared<int>();

make_shared用其参数来构造给定类型的对象，如果我们不传递任何参数，对象就会进行值初始化。

2）shared_ptr的拷贝和赋值
当进行拷贝和赋值时，每个shared_ptr都会记录1有多少个其他shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。

auto p = make_shared<int>(42);
auto q(p);

我们可以认为每个shared_ptr都有一个关联的计数器，通常称其为引用计数，无论何时我们拷贝一个shared_ptr，计数器都会递增。当我们给shared_ptr赋予一个新值或是shared_ptr被销毁时，计数器就会递减，一旦一个shared_ptr的计数器变为0,它就会自动释放自己所管理的对象。

auto r = make_shared<int>(42);     //r指向的int只有一个引用者

r=q;                //给r赋值，令它指向另一个地址
                //递增q指向的对象的引用计数
                //递减r原来指向的对象的引用计数
                //r原来指向的对象已没有引用者，会自动释放

3. weak_ptr

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

1. 内部大概实现

1）计数区域(SharedPtrControlBlock)结构体引进新的int变量weak_count，来作为弱引用计数。
2）每个weak_ptr都占指针的两倍空间，一个装着原始指针，一个装着计数区域的指针（和shared_ptr一样的成员）。
3）weak_ptr可以由一个shared_ptr或者另一个weak_ptr构造。
4）weak_ptr的构造和析构不会引起shared_count的增加或减少，只会引起weak_count的增加或减少。

被管理资源的释放只取决于shared计数，当shared计数为0，才会释放被管理资源，也就是说weak_ptr不控制资源的生命周期。

但是计数区域的释放却取决于shared计数和weak计数，当两者均为0时，才会释放计数区域。

//shared引用计数和weak引用计数
//之前的计数区域实际最终应该长这个样子
struct SharedPtrControlBlock
{
   int shared_count;
   int weak_count;
};
//大概长这个样子（简化版）
template<class T>
class weak_ptr
{
   T* ptr;
   SharedPtrControlBlock* count;
};

2. 针对空悬指针问题

空悬指针问题是指：无法知道指针指向的堆内存是否已经释放。

得益于引入的weak_count,weak_ptr指针可以使计数区域的生命周期受weak_ptr控制，

从而能使weak_ptr获取被管理资源的shared计数，从而判断被管理对象是否已被释放。（可以实时动态地知道指向的对象是否被释放,从而有效解决空悬指针问题）

它的成员函数**expired()**就是判断指向的对象是否存活。

3. 针对循环引用问题

class Monster{
//尽管父子可以互相访问，但是彼此都是独立的个体，无论是谁都不应该拥有另一个人的所有权。
std::weak_ptr<Monster> m_father; //所以都把shared_ptr换成了weak_ptr
std::weak_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指向的堆对象 shared计数为1,weak计数为1；son指向的堆对象 shared计数为1,weak计数为1；
    son智能指针退出栈：son指向的堆对象 shared计数减为0,weak计数为1,释放son的堆对象；father指向的堆对象 shared计数为1,weak计数减为0;
    father智能指针退出栈：father指向的堆对象 shared计数减为0,weak计数为0;释放father的堆对象和father的计数区域；son指向的堆对象 shared计数为0,weak计数减为0;释放son的计数区域。
    函数结束，释放行为正确。

（可以说，当生命控制权没有彼此互相掌握时，才能正确解决循环引用问题，而弱引用的使用可以使生命控制权互相掌握的情况消失）

此外：
weak_ptr没有重载 * 和 -> ，所以并不能直接使用资源。但可以使用lock()获得一个可用的shared_ptr对象，如果对象已经死了，lock()会失败，返回一个空的shared_ptr。

void runGame()
{
  std::shared_ptr<Monster> monster1(new Monster());
  std::weak_ptr<Monster> r_monster1 = monster1;
  r_monster1->doSomething();//Error! 编译器出错！weak_ptr没有重载* 和 -> ，无法直接当指针用                  std::shared_ptr<Monster> s_monster1 = r_monster1.lock();//OK!可以通过weak_ptr的lock方法获得shared_ptr。
}