C++智能指针介绍（shared

shared_ptr，使用引用计数实现对同一块内存可以有多个引用，在最后一个引用被释放时，指向的内存才释放，这也是和unique_ptr最大的区别。基本用法：

shared_ptrsp1(new int(10));
cout << "sp1: " << sp1.use_count() << 'n';
cout << "sp1 = " << sp1 << " *sp1 = " << *sp1 << endl;
shared_ptrsp2 = make_shared(10);
cout << "sp2: " << sp2.use_count() << 'n';
cout << "sp2 = " << sp2 << " *sp2 = " << *sp2 << endl;

输出：

 这个智能指针的特性“在最后一个引用被释放时，指向的内存才释放”。怎么理解这一点呢？使用自定义数据类型来看看：

	class A {
	public:
		~A() {
			cout << "dealloc A" << endl;
		}
	};
		A* a = new A();
		delete a; //调用~A
		shared_ptrspa = make_shared(); //使用shared_ptr
		cout << "spa: " << spa.use_count() << 'n';//可以看到引用计数为1
		spa = nullptr;//将智能指针赋值为空指针后，先前指向内存的引用计数为0，内存被析构，调用~A
		cout << "spa: " << spa.use_count() << 'n';//引用计数为0

输出：

 最后看看不同方法使用智能指针的引用计数：

	shared_ptr p1;//默认构造，没有获取任何指针的所有权
	shared_ptr p2(nullptr);//同p1
	shared_ptr p3(new int);//拥有指向int的指针所有权
	cout << "p1: " << p1.use_count() << 'n';
	cout << "p2: " << p2.use_count() << 'n';
	cout << "p3: " << p3.use_count() << 'n';

	shared_ptr p4(p3);//如果p3引用计数为0，则引用计数加1，否则同样为0
	cout << "p4: " << p4.use_count() << 'n';

	shared_ptr p5(std::move(p4));//获取p4的引用计数
	cout << "p5: " << p5.use_count() << 'n';
	return 0;

输出：

std::enable_shared_from_this 是一个模板类，能让一个对象t（被 std::shared_ptr 对象 pt1 管理）生成另一个 std::shared_ptr 实例pt2 ，与 pt1 共享对象 t 的所有权。

一个类 T 继承 std::enable_shared_from_this ，则会为该类 T 提供成员函数：shared_from_this 。 当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr 类对象管理时，调用 T::shared_from_this 成员函数，将会返回一个新的 std::shared_ptr 对象，它与 pt 共享 t 的所有权。

当类A被share_ptr管理，且在类A的成员函数里需要把当前类对象作为参数传给其他函数时，就需要传递一个指向自身的share_ptr。

	struct A : std::enable_shared_from_this 
	{
	public:
		std::shared_ptr getptr() {
			return shared_from_this();//调用shared_from_this()，返回一个新的shared_ptr对象
		}
		~A() { std::cout << "A destroy" << std::endl; }
	};

		std::shared_ptr gp1(new A());
		std::shared_ptr gp2 = gp1->getptr();
		// 打印gp1和gp2的引用计数
		std::cout << "gp1.use_count() = " << gp1.use_count() << std::endl;
		std::cout << "gp2.use_count() = " << gp2.use_count() << std::endl;
	
	return 0;

输出：

该类型指针通常不单独使用（没有实际用处），只能和 shared_ptr 类型指针搭配使用。可以视为 shared_ptr 指针的一种辅助工具。借助 weak_ptr 类型指针可以获取 shared_ptr 指针的一些状态信息，比如有多少指向相同的 shared_ptr 指针、通过expired()判断shared_ptr 指针指向的堆内存是否已经被释放等等。

weak_ptr 类型指针并不会影响所指堆内存空间的引用计数。当 weak_ptr 指针的指向和某一 shared_ptr 指针相同时，weak_ptr 指针并不会使所指堆内存的引用计数加 1；同样，当 weak_ptr 指针被释放时，之前所指堆内存的引用计数也不会因此而减 1。weak_ptr 模板类中没有重载 * 和 -> 运算符，这也就意味着，weak_ptr 类型指针只能访问所指的堆内存，而无法修改它。

    std::shared_ptr sp1(new int(10));
    std::shared_ptr sp2(sp1);
    cout << "sp1 : "< wp(sp2);
    cout << "wp : "< 
输出：
 
 
weak_ptr的一个作用是解决share_ptr的循环引用问题。如下面代码所示，A中引用B，B中引用A，spa和spb的强引用计数永远大于等于1，所以直到程序退出前都不会被退出，这种情况有时候在正常的业务逻辑中是不可避免的，而解决循环引用的方法是改用weak_ptr
 
class A {
public:
    shared_ptr b;
};
class B {
public:
    shared_ptr a;
};
int main(int argc, const char * argv[]) {
    shared_ptr spa = make_shared();
    shared_ptr spb = make_shared();
    spa->b = spb;
    spb->a = spa;
    return 0;
} 
 
使用weak_ptr
 
class A {
public:
    shared_ptr b;
    ~A()
    {
        cout << "A destroy" << endl;
    }
};
class B {
public:
    weak_ptr a;
    ~B()
    {
        cout << "B destroy" << endl;
    }
};
int main(int argc, const char* argv[]) {
    shared_ptr spa = make_shared();
    shared_ptr spb = make_shared();
    cout << "spa = " << spa.use_count() << endl;
    cout << "spb = " << spb.use_count() << endl;
    spa->b = spb; //spb强引用计数为2，弱引用计数为1
    spb->a = spa; 
    //spb->a为weak_ptr类型，不会增加强引用计数，所以spa强引用计数为1，弱引用计数为2
    cout << "spa = " << spa.use_count() << endl;
    cout << "spb = " << spb.use_count() << endl;
    return 0;
} //main函数退出后，spa先释放，spb再释放，循环解开了
 
输出：
 
 
 更详细内容参考：智能指针（三）：weak_ptr浅析_AlbertS Home of Technology-CSDN博客_weakptr
 
四、unique_ptr 
unique_ptr也是一种智能指针，不过它独占被管理的内存地址，如果有其它指针指向它管理的内存地址，则会引发错误。可以用move函数给其他unique_ptr赋值，调用move后，原unique_ptr就会失效，再用其访问裸指针也会发生错误。
 
unique_ptr up(new int(5));
auto up2 = up; // 编译错误
auto up2 = move(up);
cout << *up << endl; //错误，up已经失效，无法访问其裸指针