C++ weak_ptr的2个使用场景

C++11之后提供了weak_ptr，weak_ptr不会增加引用计数。本文讲述weak_ptr的2个使用场景

---

一 解决循环引用无法释放的问题

假设有2个类，其内部各有一个指向对方的shared_ptr指针，如下，

#include <iostream>
#include <memory>


// 前置声明
class A;

class B
{
public:
    ~B()
    {
        std::cout << "B destructor\n";
    }
    std::shared_ptr<A> ptr;
};


class A
{
public:
    ~A()
    {
        std::cout << "A destructor\n";
    }
    std::shared_ptr<B> ptr;
};

当在main函数按照如下方式使用时，

int main()
{
    { // 作用域开始
        std::shared_ptr<A> aPtr = std::make_shared<A>();
        std::shared_ptr<B> bPtr = std::make_shared<B>();

        aPtr->ptr = bPtr;
        bPtr->ptr = aPtr;
    } // 作用域结束

    std::cout << "end\n";

    return 0;
}

会造成无法释放，运行后打印如下，

当离开作用域时，并未执行类A和B的析构函数。

原因是：创建aPtr和bPtr时，各自的引用计数会变成1，接着2个赋值语句，又把各自的引用计数加了1，就都变成了2，然后离开作用域，会减1，这样各自的引用计数还保持1，这样就无法释放内存空间，就不会去执行A和B的析构函数。

可以把A里的ptr类型换成weak_ptr，如下，

class A
{
public:
    ~A()
    {
        std::cout << "A destructor\n";
    }
    std::weak_ptr<B> ptr;
};

这样再重新编译运行程序，就可以看到正常释放了，

因为weak_ptr不增加引用计数，创建aPtr和bPtr时，各自的引用计数会变成1，接着2个赋值语句中，只有指向A的引用计数会加1变成2，而指向B的引用计数还是1，当离开作用域时，都会减1，这样B的引用计数先变成0，就会先释放，释放后B中指向A的智能指针也释放，会再次减1，这样指向A的引用计数就变成了0，然后释放A。比较绕…

---

二 探查内存空间是否有效

这个例子来自stackoverflow，地址是这里，本人简单修改了下。本例子说明weak_ptr可以用来解决dangling pointer的问题，

#include <iostream>
#include <memory>

int main()
{
    // OLD, problem with dangling pointer
    // PROBLEM: ref will point to undefined data!
    
    int* ptr = new int(10);
    int* ref = ptr;
    delete ptr;

    // NEW
    // SOLUTION: check expired() or lock() to determine if pointer is valid

    // empty definition
    std::shared_ptr<int> sptr;

    // takes ownership of pointer
    sptr.reset(new int);
    *sptr = 10;

    // get pointer to data without taking ownership
    std::weak_ptr<int> weak1 = sptr;

    // deletes managed object, acquires new pointer
    sptr.reset(new int);
    *sptr = 5;

    // get pointer to new data without taking ownership
    std::weak_ptr<int> weak2 = sptr;

    // weak1 is expired!
    if (weak1.expired())
    {
        std::cout << "weak1 is expired\n";
    }
    else
    {
        auto temp = weak1.lock();
        std::cout << "value (weak1 point to): "<< *temp << '\n';
    }
        
    // weak2 points to new data (5)
    if (weak2.expired())
    {
        std::cout << "weak2 is expired\n";
    }
    else
    {
        auto temp = weak2.lock();
        std::cout << "value (weak2 point to): "<< *temp << '\n';
    }
}

代码中weak1先是和sptr指向相同的内存空间，后面sptr释放了那段内存空间然后指向新的内存空间，此时通过weak1的expired()方法就可以知道本来指向的那段内存空间已经被释放。因为不增加引用计数，所以不会影响内存的释放。非常方便。

以往使用老的方法，判断一个指针是否是NULL，但是如果这段内存已经被释放却没有赋一个NULL，那么就会引发未知错误，这需要程序员手动赋值，而且出问题还很难排查。有了weak_ptr，就方便多了，直接使用其expired()方法看下就行了。