当前位置：首页 > news >正文

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

news 2025/11/9 13:27:42

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。
}

4. 小结

推荐用法：一个shared_ptr和n个weak_ptr搭配使用而不是n个shared_ptr。
逻辑上，大部分模型的生命在直观上总是受某一样东西直接控制而不是多样东西共同控制。
程序上，能够完全避免生命周期互相控制引发的循环引用问题。