C++ 智能指针

#include <iostream>
#include <memory>
using namespace std;
class Test
{
public:
    Test(string s){
        str = s;
        cout << "Test create() :" << str << endl;
    }
    ~Test(){
        cout << "Test delete() :" << str << endl;
    }
    string &getStr(){
        return str;
    }
    void setStr(string s){
        str = s;
    }
    void print(){
        cout << str << endl;
    }

private:
    string str;
};
unique_ptr<Test> fun()
{
    return unique_ptr<Test>(new Test("789")); //调用了构造函数，输出Test creat
}

int main()
{
    /* unique_ptr 
	unique_ptr 是一个独享所有权的智能指针，它提供了严格意义上的所有权，包括：
	1、拥有它指向的对象
	2、无法进行复制构造，无法进行复制赋值操作。即无法使两个unique_ptr指向同一个对象。但是可以进行移动构造和移动赋值操作
	3、保存指向某个对象的指针，当它本身被删除释放的时候，会使用给定的删除器释放它指向的对象
	*/
    
    {
//当我们对智能指针进行赋值时，如ptest2 = ptest，ptest2会接管ptest原来的内存管理权，
// ptest会变为空指针，如果ptest2原来不为空，则它会释放原来的资源，
// 基于这个原因，应该避免把auto_ptr放到容器中，因为算法对容器操作时，
//很难避免STL内部对容器实现了赋值传递操作，这样会使容器中很多元素被置为NULL。
//判断一个智能指针是否为空不能使用if(ptest == NULL)，应该使用if(ptest.get() == NULL)
		cout << "------------part 1------------" << endl;
        unique_ptr<Test> ptest(new Test("123"));
        unique_ptr<Test> ptest2(new Test("456"));
//        ptest2 = ptest; 							//不能直接ptest2 = ptest，
        ptest2 = std::move(ptest);               	//调用了move后ptest2原本的对象会被释放，ptest2对象指向原本ptest对象的内存
        ptest2->print();
        if (ptest.get() == NULL)
            cout << "ptest = NULL\n";
    }
    cout << endl << endl; 
	
    {
		cout << "------------part 2------------" << endl;
		unique_ptr<Test> ptest(new Test("123"));
//		ptest.release();
//		release()函数只是把智能指针赋值为空，但是它原来指向的内存并没有被释放，
//		相当于它只是释放了对资源的所有权，析构函数没有被调用。
	}
    cout << endl << endl; 
    
    {
		cout << "------------part 3------------" << endl;
        unique_ptr<Test> ptest(new Test("123"));  //调用构造函数，输出Test creat
        unique_ptr<Test> ptest2(new Test("456")); //调用构造函数，输出Test creat
        ptest->print();                           //输出123
        ptest2 = std::move(ptest);                //不能直接ptest2 = ptest，调用了move后ptest2原本的对象会被释放，ptest2对象指向原本ptest对象的内存，输出Test delete 456
        if (ptest == NULL)
            cout << "ptest = NULL\n"; //因为两个unique_ptr不能指向同一内存地址，所以经过前面move后ptest会被赋值NULL，输出ptest=NULL
        Test *p = ptest2.release();   //release成员函数把ptest2指针赋为空，但是并没有释放指针指向的内存，所以此时p指针指向原本ptest2指向的内存
        p->print();                   //输出123
        ptest.reset(p);               //重新绑定对象，原来的对象会被释放掉，但是ptest对象本来就释放过了，所以这里就不会再调用析构函数了
        ptest->print();               //输出123
        ptest2 = fun();               //这里可以用=，因为使用了移动构造函数，函数返回一个unique_ptr会自动调用移动构造函数
        ptest2->print();              //输出789
    }//此时程序中还有两个对象，调用两次析构函数释放对象
    cout << endl << endl; 

    
    //share_ptr
    {
		cout << "------------part 4------------" << endl;
        shared_ptr<Test> ptest(new Test("123"));  //调用构造函数输出Test create
        shared_ptr<Test> ptest2(new Test("456")); //调用构造函数输出 Test creat
        cout << ptest2->getStr() << endl;         //输出456
        cout << ptest2.use_count() << endl;       //显示此时资源被几个指针共享，输出1
        ptest = ptest2;                           //"456"引用次数加1，“123”销毁，输出Test delete：123
        ptest->print();                           //输出456
        cout << ptest2.use_count() << endl;       //该指针指向的资源被几个指针共享，输出2
        cout << ptest.use_count() << endl;        //2
        ptest.reset();                            //重新绑定对象，绑定一个空对象，当时此时指针指向的对象还有其他指针能指向就不会释放该对象的内存空间，
        ptest2.reset();                           //此时“456”销毁，此时指针指向的内存空间上的指针为0，就释放了该内存，输出Test delete
        cout << "done !\n";
    }
    cout << endl << endl; 
    
    /*weak_ptr
	weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,
	那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。
	它是对对象的一种弱引用，不会增加对象的引用计数，
	和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。
    */
    {
		cout << "------------part 5------------" << endl;
		class B;
		class A{
		public:
//		    shared_ptr<B> pb_;
		    weak_ptr<B> pb_;
		    ~A(){
		        cout << "A delete\n";
		    }
		};
		class B{
		public:
		    shared_ptr<A> pa_;
		    ~B(){
		        cout << "B delete\n";
		    }
		    void print(){
		    	cout << "B print()\n"; 
			} 
		};
        shared_ptr<B> pb(new B());
        shared_ptr<A> pa(new A());
        pb->pa_ = pa;
        pa->pb_ = pb;
        cout << pb.use_count() << endl; // 2
        cout << pa.use_count() << endl; // 2
        //可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，
        //智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，
        //导致跳出函数时资源没有被释放（A B的析构函数没有被调用），

        //如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr<B> pb_;
        //改为weak_ptr<B> pb_; 运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，
        //B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。

        //注意的是我们不能通过weak_ptr直接访问对象的方法，比如B对象中有一个方法print(),我们不能这样访问，pa->pb_->print();
        // 英文pb_是一个weak_ptr，应该先把它转化为shared_ptr,如：shared_ptr<B> p = pa->pb_.lock();    p->print();
//        pa->pb_->print(); // not ok
        shared_ptr<B>p = pa->pb_.lock();
        p->print();
    }

    return 0;
}
//https://www.cnblogs.com/wuyepeng/p/9741241.html

参考：
C++智能指针总结
【C++】智能指针详解
C++智能指针的分析与使用