C++ 智能指针中的循环引用

1、C++11 里面出现了三种智能指针，分别是std::unique_ptr，std::shared_ptr，和std::weak_ptr

2、std::unique_ptr：与所指对象的内存紧密绑定，不能与其它std::unique_ptr的指针共享其对象，每一个std::unique_ptr都是唯一拥有所指向对象的内存，但是这种所有权可以通过std::move函数进行转移，转移之后原来的std::unique_ptr就失去了对象内存的所有权，从实现上将std::unique_ptr是删除了拷贝构造，保留了移动构造的指针封装类型

#include <iostream>
#include <memory>
class Test {
public:
    void Show() { 
        std::cout << "value:" << value_ << std::endl; 
    }
private:
    int value_ = 10;
};
int main(void) {
    std::unique_ptr<Test> test(new Test());
    test->Show();
    // std::unique_ptr<Test> unique_test = test; // 编译出错
    std::unique_ptr<Test> move_test = std::move(test);
    // test->Show(); // 运行崩溃
    // 因为此时test已经是一个空指针了
    if(test == nullptr){
        std::cout << "nullptr" << std::endl;
    }
    move_test->Show();
    return 0;
}

3、std::shared_ptr：允许多个该智能指针共享的拥有同一堆分配对象的内存，在实现上采用了引用计数，所以一旦一个std::shared_ptr放弃了所有权，其它的并不会受到影响

#include <iostream>
#include <memory>
class Test {
public:
    void Show() { std::cout << "value:" << value_ << std::endl; }
private:
    int value_ = 10;
};
int main(void) {
    std::shared_ptr<Test> shared_test1(new Test());
    shared_test1->Show();
    std::shared_ptr<Test> shared_test2 = shared_test1;
    shared_test2->Show();
    shared_test1.reset(); // 手动销毁，delete
    shared_test2->Show(); // 不会有任何影响
    return 0;
}

4、std::weak_ptr：指向std::shared_ptr指针指向的对象内存，但是却不拥有该内存，对象的内存的生命周期由原来的std::shared+ptr去控制，使用成员函数lock()，可以返回一个指向该内存的std::shared_ptr指针，如果内存对象已经无效，那么返回空值nullptr，std::weak_ptr还提供了expired()函数来判断所指对象是否已经被销毁

#include <iostream>
#include <memory>
class Test {
public:
    void Show() { 
        std::cout << "value:" << value_ << std::endl; 
    }
private:
    int value_ = 10;
};
void Check(std::weak_ptr<Test> test) {
    std::shared_ptr<Test> shared_test = test.lock();
    if (shared_test == nullptr) {
        std::cout << "nullptr" << std::endl;
    } else {
        shared_test->Show();
    }
}
int main(void) {
    std::shared_ptr<Test> shared_test1 = std::make_shared<Test>();
    std::shared_ptr<Test> shared_test2 = shared_test1;
    // std::weak_ptr<Test> weak_test = shared_test1;
    std::weak_ptr<Test> weak_test = shared_test2;
    Check(weak_test);
    std::cout << weak_test.expired() << std::endl; // 0
    shared_test1->Show();
    shared_test1.reset();
    Check(weak_test);
    std::cout << weak_test.expired() << std::endl; // 0
    shared_test2->Show();
    shared_test2.reset();
    Check(weak_test);
    std::cout << weak_test.expired() << std::endl; // 1
    return 0;
}

5、循环引用：什么是循环引用？比如有两个类A和B，在A里面使用std::shared_ptr引用了B，在B里面使用std::shared_ptr引用了A，这样就成了循环引用

#include <iostream>
#include <memory>

class B;
class A {
public:
    A() { 
        std::cout << "A()" << std::endl; 
    }
    ~A() { 
        std::cout << "~A()" << std::endl; 
    }
    void Make(std::shared_ptr<B> pb) { 
        pb_ = pb; 
    }

private:
    std::shared_ptr<B> pb_;
};

class B {
public:
    B() { 
        std::cout << "B()" << std::endl; 
    }
    ~B() { 
        std::cout << "~B()" << std::endl; 
    }
    void Make(std::shared_ptr<A> pa) { 
        pa_ = pa; 
    }

private:
    std::shared_ptr<A> pa_;
};

int main(void) {
    std::shared_ptr<A> pa(new A());
    std::shared_ptr<B> pb(new B());

    pa->Make(pb);
    pb->Make(pa);
    return 0;
}

上面程序最后的输出是

A()
B()

可以发现A和B的析构函数都没有执行，这是因为std::shared_ptr的析构是引用计数为0的时候才会析构，那么在析构B的时候，会先将自己的成员析构掉，这个时候去析构A，但是在析构A的时候，又要将B析构掉，这样就成了一个循环了

std::weak_ptr可以解决循环引用，将上面A和B的成员变量中的std::shared_ptr都改成std::weak_ptr，运行结果如下

A()
B()
~B()
~A()