shared_ptr

shared_ptr是一种共享型的智能指针，它使用一种“引用计数”的机制来让它变得“智能”。考虑这样一个过程：

  • 假设有一个叫pA的shared_ptr，创建它的时候引用计数为1；
  • 当有另一个pA2=pA时，查看pA和pA2的引用计数都变成了2；
  • 而当pA2离开函数作用域时，pA的计数又回到了1；
  • 当pA也离开自己的作用域时，计数则变为0，此时指针所指向的内存就会被销毁。

下面的例子中则体现了这个过程

  1. #include <iostream>
  2. #include <memory>
  3. using namespace std;
  5. struct A
  6. {
  7.     string m_strA;
  9.     A(string strA)
  10.     {
  11.         m_strA = strA;
  12.         cout << "A(" << m_strA << ")" << endl;
  13.     }
  15.     ~A()
  16.     {
  17.         cout << "~A(" << m_strA << ")" << endl;
  18.     }
  19. };
  21. void PrintSharedA(string strObj, shared_ptr<A>& pA)
  22. {
  23.     cout << strObj << " 引用计数:" << pA.use_count() << endl;
  24. }
  26. void TestShared()
  27. {
  28.     cout << "创建一个共享指针 pA" << endl;
  29.     shared_ptr<A> pA = make_shared<A>("1");
  30.     PrintSharedA("pA", pA);
  32.     cout << "令pA2 = pA;" << endl;
  33.     shared_ptr<A> pA2 = pA;
  34.     PrintSharedA("pA", pA);
  35.     PrintSharedA("pA2",pA2);
  36. }
  38. int main(int argc, char *argv[]) {
  39.     TestShared();
  40. }

测试结果为：
image.png

unique_ptr

unique_ptr是一种独占型指针，相比于shared_ptr要轻量级许多，它即便没有引用计数的机制，但也可以在离开作用域后自动的销毁内存，因为它每次只允许一个指针实例拥有它（你可以把它想象成）。
假设我们定义了下面的一个结构：

  1. struct A
  2. {
  3.     int m_iA;
  4.     string m_strA;
  6.     A(int iA, int strA)
  7.     {
  8.         m_iA = iA;
  9.         m_strA = strA;
  10.     }
  11. };

然后我们使用以下代码创建一个独占指针：

  1. unique_ptr<A> pA = make<A>(1, "1");//使用工厂方法创建指向A的独占指针

当我们想要向下面的代码这样将pA赋值给pB的时候，则会编译错误，因为独占指针不允许两个指针指向同一个实例

  1. unique_ptr<A> pA2 = pA;//错误，不能复制

想要实现类似的操作，你可以通过以下的方式“折衷”的完成

  1. unique_ptr<A> pA2 = std::move(pA); //将pA的所有权转移给pB，这时候你会发现pA变成了nullptr

shared_ptr的循环引用异常现象

考虑到下面这种异常情景：

  • 有一对成为了情侣的结构指针，它们叫pBoy和pGirl
  • 另外它们有着相互指向对方的指针，pBoy下有个pGirl的共享指针，pGirl下面也有个pBoy的共享指针
  • 这时当它们互相指向时，离开作用域后它们互相的引用计数并不会减少，导致无法析构

具体看下面这个例子：

  1. #include <iostream>
  2. #include <memory>
  3. using namespace std;
  5. struct Boy;
  6. struct Girl;
  8. struct Boy
  9. {
  10.     shared_ptr<Girl> pGirl;
  11.     string m_str;
  13.     Boy(string str)
  14.     {
  15.         m_str = str;
  16.         cout << "Boy(" << m_str << ")" << endl;
  17.     }
  19.     ~Boy()
  20.     {
  21.         cout << "~Boy(" << m_str << ")" << endl;
  22.     }
  24.     friend ostream &operator<<(ostream &output, const Boy& stuBoy)
  25.     {
  26.         output << "Boy(" << stuBoy.m_str << ")";
  27.         return output;
  28.     }
  29. };
  31. struct Girl
  32. {
  33.     shared_ptr<Boy> pBoy;
  34.     string m_str;
  36.     Girl(string str)
  37.     {
  38.         m_str = str;
  39.         cout << "Girl(" << m_str << ")" << endl;
  40.     }
  42.     ~Girl()
  43.     {
  44.         cout << "~Girl(" << m_str << ")" << endl;
  45.     }
  47.     friend ostream &operator<<(ostream &output, const Girl& stuGirl)
  48.     {
  49.         output << "stuGirl(" << stuGirl.m_str << ")";
  50.         return output;
  51.     }
  52. };
  54. template<class T>
  55. void PrintShared(string strObj, shared_ptr<T>& pT)
  56. {
  57.     cout << strObj << " 引用计数:" << pT.use_count() << endl;
  58. }
  60. void TestShared2()
  61. {
  62.     auto pBoy = make_shared<Boy>("boy");
  63.     auto pGirl = make_shared<Girl>("girl");
  64.     PrintShared("pBoy", pBoy);
  65.     PrintShared("pGirl", pGirl);
  67.     pBoy->pGirl = pGirl;
  68.     PrintShared("pBoy", pBoy);
  69.     PrintShared("pGirl", pGirl);
  71.     pGirl->pBoy = pBoy;
  72.     PrintShared("pBoy", pBoy);
  73.     PrintShared("pGirl", pGirl);
  74. }
  76. int main(int argc, char *argv[]) {
  77.     TestShared2();
  78. }

测试结果为：
image.png

weak_ptr

为了克服以上shared_ptr循环引用情况下的异常，weak_ptr则是被设计出来监视shared_ptr的，言下之意它并不是一个单独使用的指针，而是配合shared_ptr一起使用的。

参考：

  • 《深入应用C++11 代码优化与工程级应用》