std::shared_ptr 与 std::weak_ptr

构建3,4,5的二叉树

#include <iostream>
#include <memory>
class Person
{
private:
    /* data */
public:
    Person(int v);
    ~Person();
    int value;
};

Person::Person(int v)
{
    value=v;
}

Person::~Person()
{
}

void DeleteIntPtr(int* p){
    delete p;
}

void DeleteIntArrPtr(int* p){
    delete[] p;
}

class Node
{
public:
    int value;
    std::shared_ptr<Node> leftNode;
    std::shared_ptr<Node> rightNode;
    // std::shared_ptr<Node> parentNode;
    std::weak_ptr<Node> parentNode;
    Node(int v):value(v){
        std::cout<<"constructor"<<std::endl;
    }
    ~Node()
    {
        std::cout<<value<<"destructor"<<std::endl;
    }

};

int main()
{
    // std::cout<<"hello world !"<<std::endl;
    // std::shared_ptr<Person> p1(new Person(1));// Person(1)的引用计数为1
    // std::shared_ptr<Person> p2=std::make_shared<Person>(2);
    // p1.reset(new Person(3));//首先生成新对象，然后p1指向的对象Penson(1)引用计数减1，此时引用计数为0，故析构Person(1) 最后将新对象的指针交给智能指针p1
    // std::shared_ptr<Person> p3=p1;//现在p1和p3同时指向Person(3)，Person(3)的引用计数为2
    // reset()包含两个操作。当智能指针中有值的时候，调用reset()会使引用计数减1.当调用reset（new xxx())重新赋值时，
    // 智能指针首先是生成新对象，然后将之前指向的对象引用计数减1（当然，如果发现引用计数为0时，则析构旧对象），然后将新对象的指针交给智能指针保管
    // p1.reset();//Person(3)的引用计数为1
    // p3.reset();//Person(3)的引用计数为0，析构Person(3)
    
    // 注意，不能将一个原始指针直接赋值给一个智能指针，如下所示，原因是一个是类，一个是指针。
    // std::shared_ptr<int> p4 = new int(1);// error

    // 获取原始指针
    // std::shared_ptr<int> p4(new int(5)); 
    // int* pInt=p4.get();

    // //指定删除器 shard_ptr自动调用指定的删除器来释放内存。不支持删除数组对象
    // int* p=new int;
    // *p=5;
    // std::cout<<*p<<std::endl;

    std::shared_ptr<int> sp(new int(3));
    std::weak_ptr<int> wp=sp;
    std::weak_ptr<int> wp1=sp;
    if (wp.expired())//不会运行
    {
        std::cout<<"wp"<<wp.use_count()<<sp.use_count()<<std::endl;// 1 1 wq的使用不会使sp指向对象的引用次数+1
    }
    // auto lwp=wp.lock();//当调用lock时 sp与wp的引用都会+1    //reference:2 2 2
    // std::cout<<*lwp<<std::endl;//3
    std::cout<<"reference:"<<wp.use_count()<<" "<<wp1.use_count()<<" "<<sp.use_count()<<std::endl;//当不调用lock时 reference:1 1 1
    

    std::shared_ptr<Node> ptr(new Node(3));
    
    ptr->leftNode=std::make_shared<Node>(4);
    ptr->leftNode->parentNode=ptr;
    ptr->rightNode=std::make_shared<Node>(5);
    ptr->rightNode->parentNode=ptr;
    std::cout<<"ptr:"<<ptr->value<<std::endl;//3
    std::cout<<"ptr->leftNode:"<<ptr->leftNode->value<<std::endl;//4
    std::cout<<"ptr->rightNode:"<<ptr->rightNode->value<<std::endl;//5
    std::shared_ptr<Node> rightParentNode=ptr->rightNode->parentNode.lock();//如何使用weak指针指向的资源
    // if(ptr->rightNode->parentNode.expired())
    // {
    //      std::cout << "ptr reference count = " << ptr.use_count() << std::endl;
    //      std::cout<<"expired!!"<<std::endl;
    // }
        
    std::cout<<"ptr->rightNode->parentNode:"<<rightParentNode->value<<std::endl;//3
    std::cout << "ptr reference count = " << ptr.use_count() << std::endl;//lock() 2
    std::cout << "ptr->leftPtr reference count = " << ptr->leftNode.use_count() << std::endl;//1
    std::cout << "ptr->rightPtr reference count = " << ptr->rightNode.use_count() << std::endl;//1


    
    return 0;

}