cpp - weak_ptr详解

编程 评论

转自dsw846

为什么需要weak_ptr？

  • 在正式介绍weak_ptr之前，我们先来回忆一下shared_ptr的一些知识。我们知道shared_ptr是采用引用计数的智能指针，多个shared_ptr实例可以指向同一个动态对象，并维护了一个共享的引用计数器。

  • 对于引用计数法实现的计数，总是避免不了循环引用（或环形引用）的问题，shared_ptr也不例外。

  • 我们先来看看下面这个例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #include <iostream>
    #include <memory>
    #include <vector>
    using namespace std;

    class ClassB;

    class ClassA {
    public:
      ClassA() { cout << "ClassA Constructor..." << endl; }
      ~ClassA() { cout << "ClassA Destructor..." << endl; }
      shared_ptr<ClassB> pb; // 在A中引用B
    };

    class ClassB {
    public:
      ClassB() { cout << "ClassB Constructor..." << endl; }
      ~ClassB() { cout << "ClassB Destructor..." << endl; }
      shared_ptr<ClassA> pa; // 在B中引用A
    };

    int main() {
      shared_ptr<ClassA> ptr_a = make_shared<ClassA>();
      shared_ptr<ClassB> ptr_b = make_shared<ClassB>();
      ptr_a->pb = ptr_b;
      ptr_b->pa = ptr_a;

      std::cout << "spa use_count:" << ptr_a.use_count() << std::endl;
      std::cout << "spb use_count:" << ptr_b.use_count() << std::endl;
    }

  • 上面代码的输出如下：

1
2
3
4
ClassA Constructor...
ClassB Constructor...
spa use_count:2
spb use_count:2
  • 从上面代码中，ClassA和ClassB间存在着循环引用，从运行结果中我们可以看到：当main函数运行结束后，spa和spb管理的动态资源并没有得到释放，产生了内存泄露。为了解决类似这样的问题，C++11引入了weak_ptr，来打破这种循环引用。

weak_ptr是什么？

  • weak_ptr是为了配合shared_ptr而引入的一种智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期
  • 也就是将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。
  • 不论是否有weak_ptr指向，一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。从这个角度看，weak_ptr更像是shared_ptr的一个助手而不是智能指针。

weak_ptr如何使用？

  • 接下来，我们来看看weak_ptr的简单用法。

如何创建weak_ptr实例

  • 当我们创建一个weak_ptr时，需要用一个shared_ptr实例来初始化weak_ptr，由于是弱共享，weak_ptr的创建并不会影响shared_ptr的引用计数值。示例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    {
        std::shared_ptr<int> fsPtr(new int(5));
        std::weak_ptr<int> fwPtr = fsPtr;

        //weak_ptr不会改变shared_ptr，但是会和shared_ptr的引用保持一致
        std::cout << "fsPtr use_count:" << fsPtr.use_count() << " fwPtr use_count:" << fwPtr.use_count() << std::endl;

        //fwPtr.lock()后会该变shared_ptr的引用计数(+1)
        //std::shared_ptr<int> fsPtr2 = fwPtr.lock();
        //std::cout << "fsPtr use_count:" << fsPtr.use_count() << " fwPtr use_count:" << fwPtr.use_count() << std::endl;

        //编译报错，weak_ptr没有重载*，->操作符，因此不可直接通过weak_ptr使用对象,只能通过lock()使用shared_ptr来操作
        //std::cout << " number is " << *fwPtr << std::endl;

        fsPtr.reset();
        if (fwPtr.expired())
        {
            std::cout << "shared_ptr object has been destory" << std::endl;
        }

        std::shared_ptr<int> fsPtr3 = fwPtr.lock();                //fsPtr3为NULL
        std::cout << " number is " << *fsPtr3 << std::endl;　　　　 //运行时中断
    }

如何判断weak_ptr指向对象是否存在

  • 既然weak_ptr并不改变其所共享的shared_ptr实例的引用计数，那就可能存在weak_ptr指向的对象被释放掉这种情况。这时，我们就不能使用weak_ptr直接访问对象。那么我们如何判断weak_ptr指向对象是否存在呢？C++中提供了lock函数来实现该功能。如果对象存在，lock()函数返回一个指向共享对象的shared_ptr，否则返回一个空shared_ptr。示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class A
{
public:
    A() : a(3) { cout << "A Constructor..." << endl; }
    ~A() { cout << "A Destructor..." << endl; }

    int a;
};

int main() {
    shared_ptr<A> sp(new A());
    weak_ptr<A> wp(sp);
    //sp.reset();

    if (shared_ptr<A> pa = wp.lock())
    {
        cout << pa->a << endl;
    }
    else
    {
        cout << "wp指向对象为空" << endl;
    }
}
  • 试试把sp.reset()这行的注释去掉看看结果有什么不同。
  • 除此之外，weak_ptr还提供了expired()函数来判断所指对象是否已经被销毁。
  • 示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A
{
public:
    A() : a(3) { cout << "A Constructor..." << endl; }
    ~A() { cout << "A Destructor..." << endl; }

    int a;
};

int main() {
    shared_ptr<A> sp(new A());
    weak_ptr<A> wp(sp);
    sp.reset(); // 此时sp被销毁
    cout << wp.expired() << endl;  // true表示已被销毁，否则为false
}
  • 代码输入如下：
    1
    2
    A Constructor...
    A Destructor...

如何使用weak_ptr

  • weak_ptr并没有重载operator->和operator *操作符，因此不可直接通过weak_ptr使用对象，典型的用法是调用其lock函数来获得shared_ptr示例，进而访问原始对象。

  • 最后，我们来看看如何使用weak_ptr来改造最前面的代码，打破循环引用问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class ClassB;

class ClassA
{
public:
    ClassA() { cout << "ClassA Constructor..." << endl; }
    ~ClassA() { cout << "ClassA Destructor..." << endl; }
    weak_ptr<ClassB> pb;  // 在A中引用B
};

class ClassB
{
public:
    ClassB() { cout << "ClassB Constructor..." << endl; }
    ~ClassB() { cout << "ClassB Destructor..." << endl; }
    weak_ptr<ClassA> pa;  // 在B中引用A
};

int main() {
    shared_ptr<ClassA> spa = make_shared<ClassA>();
    shared_ptr<ClassB> spb = make_shared<ClassB>();
    spa->pb = spb;
    spb->pa = spa;
    // 函数结束，思考一下：spa和spb会释放资源么？因为没改变shared_ptr的引用计数，此时引用计数为1，超过作用域后自动释放
}
  • 输出结果如下
1
2
3
4
5
ClassA Constructor...
ClassB Constructor...
ClassA Destructor...
ClassB Destructor...
Program ended with exit code: 0
  • 从运行结果可以看到spa和spb指向的对象都得到释放！

QinHanGame Developer & Designer

当你发现自己的才华撑不起野心时，就请安静下来学习吧！