1、问题引入：Java和C#等语言有自己的垃圾回收机制，.net运行时和java虚拟机可以管理分配的堆内存，在失去对象时自动回收，因此我们不需要去考虑垃圾回收问题，但是C++没有垃圾回收机制，我们必须要自己去释放分配的堆内存。
2、知识点：智能指针是指向动态分配（堆）对象指针，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数。每次使用它，内部的引用计数加1，每次析构一次，内部引用计数减1，减为0时，删除所指向的堆内存。C++中的智能指针包括：
std::shared_ptr
std::unique_ptr
std::weak_ptr
3、怎么用：智能指针std::shared_ptr的用法：通过构造函数、赋值函数、std::make_shared函数进行初始化，还可以指定删除器。智能指针的原始指针通过get()函数获取。shared_ptr允许多个该智能指针共享“拥有”同一堆分配对象的内存，这通过引用计数（reference counting）实现，会记录有多少个shared_ptr共同指向一个对象，一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。支持复制和赋值操作。
class Server;
std::shared_ptrp(new int[10]());
std::shared_ptrp2 = p;
std::shared_ptr pServer = std::make_shared();
//获取原始指针
std::shared_ptrpBuffer(new char[8]);
char* pChar = pBuffer.get();
std::shared_ptr sp1(new int(22));
std::shared_ptr sp2 = sp1;
std::cout << "cout: " << sp2.use_count() << std::endl; // 打印引用计数, 2
std::cout << *sp1 << std::endl; // 22
std::cout << *sp2 << std::endl; // 22
sp1.reset(); // 显示让引用计数减一
std::cout << "count: " << sp2.use_count() << std::endl; // 打印引用计数, 1
std::cout << *sp2 << std::endl; // 22
std::unique_ptr：如名字所示，unique_ptr是个独占指针，再C++11之前就存在了，unique_ptr所指的内存为自己所有，某一时刻只能有一个unique_ptr指向一个给定的对象。不拷贝和赋值。
std::unique_ptrup1(new int(22));
std::cout << *up1 << endl;//22
//std::unique_ptrup2 = up1;编译不过
std::unique_ptrup3 = std::move(up1);
std::cout << *up3 << endl;
//std::cout << *up1 << endl;//运行时错误，空指针
up3.reset();//显示释放内存
up1.reset();//不会错误
std::unique_ptrup5(new int(55));
up5.reset(new int(66));//动态绑定
std::cout << *up5 << endl;//66
int* ptr = up5.release();//只是释放控制权，不会释放内存
std::cout << *ptr << endl;//66
delete ptr;//释放堆资源
ptr = nullptr;
std::weak_ptr:weak_ptr是为配合shared_ptr而引入的一种智能指针来协助shared_ptr工作，它可以从一个shared_ptr或另一个weak_ptr对象构造，它的构造和析构不会引起引用计数的增加或减少。没有重载 *和 -> 但可以使用lock获得一个可用的shared_ptr对象
weak_ptr的使用更为复杂一点，它可以指向shared_ptr指针指向的对象内存，却并不拥有该内存，而使用weak_ptr成员lock，则可返回其指向内存的一个share_ptr对象，且在所指对象内存已经无效时，返回指针空值nullptr。
注意：weak_ptr并不拥有资源的所有权， 所以不能直接使用资源，可以从一个weak_ptr构造一个shared_ptr以取得共享资源的所有权。
#include
#include
using namespace std;
void check(std::weak_ptrwp)
{
shared_ptrsp = wp.lock();//可以获取wp指向的shared_ptr
if (sp != nullptr)
{
std::cout << *sp << endl;
}
else
{
std::cout << "point is invalid" << endl;
}
}
int main()
{
std::shared_ptrsp(new int(10));
std::shared_ptrsp2 = sp;
std::weak_ptrwp = sp;
check(wp);
std::cout << sp.use_count() << endl;
sp.reset();
check(wp);
std::cout << sp2.use_count() << endl;
sp2.reset();
check(wp);
system("pause");
return 0;
}
为什么要使用weak_ptr
weak_ptr解决shared_ptr循环引用的问题，定义两个类，每个类中又包含一个指向对方类型的智能指针作为成员变量，然后创建对象，设置完成后查看引用计数后退出，看一下测试结果：
class CB;
class CA
{
public:
CA() { cout << "CA() called! " << endl; }
~CA() { cout << "~CA() called! " << endl; }
void set_ptr(shared_ptr& ptr) { m_ptr_b = ptr; }
void b_use_count() { cout << "b use count : " << m_ptr_b.use_count() << endl; }
void show() { cout << "this is class CA!" << endl; }
private:
shared_ptr m_ptr_b;
};
class CB
{
public:
CB() { cout << "CB() called! " << endl; }
~CB() { cout << "~CB() called! " << endl; }
void set_ptr(shared_ptr& ptr) { m_ptr_a = ptr; }
void a_use_count() { cout << "a use count : " << m_ptr_a.use_count() << endl; }
void show() { cout << "this is class CB!" << endl; }
private:
shared_ptr m_ptr_a;
};
void test_refer_to_each_other()
{
shared_ptr ptr_a(new CA());
shared_ptr ptr_b(new CB());
cout << "a use count : " << ptr_a.use_count() << endl;
cout << "b use count : " << ptr_b.use_count() << endl;
ptr_a->set_ptr(ptr_b);
ptr_b->set_ptr(ptr_a);
cout << "a use count : " << ptr_a.use_count() << endl;
cout << "b use count : " << ptr_b.use_count() << endl;
}
int main()
{
test_refer_to_each_other();
system("pause");
return 0;
}
通过结果可以看到，最后CA和CB的对象并没有被析构，其中的引用效果如下图所示，起初定义完ptr_a和ptr_b时，只有①③两条引用，然后调用函数set_ptr后又增加了②④两条引用，当test_refer_to_each_other这个函数返回时，对象ptr_a和ptr_b被销毁，也就是①③两条引用会被断开，但是②④两条引用依然存在，每一个的引用计数都不为0，结果就导致其指向的内部对象无法析构，造成内存泄漏。参考博客（码农小非：https://blog.csdn.net/king_way/java/article/details/95536938）
解决这种状况的办法就是将两个类中的一个成员变量改为weak_ptr对象，因为weak_ptr不会增加引用计数，使得引用形不成环，最后就可以正常的释放内部的对象，不会造成内存泄漏，比如将CB中的成员变量改为weak_ptr对象，代码如下：
class CB
{
public:
CB() { cout << "CB() called! " << endl; }
~CB() { cout << "~CB() called! " << endl; }
void set_ptr(shared_ptr& ptr) { m_ptr_a = ptr; }
void a_use_count() { cout << "a use count : " << m_ptr_a.use_count() << endl; }
void show() { cout << "this is class CB!" << endl; }
private:
weak_ptr m_ptr_a;
};
// 测试结果
CA() called!
CB() called!
a use count : 1
b use count : 1
a use count : 1
b use count : 2
~CA() called!
~CB() called!
通过这次结果可以看到，CA和CB的对象都被正常的析构了，引用关系如下图所示，流程与上一例子相似，但是不同的是④这条引用是通过weak_ptr建立的，并不会增加引用计数，也就是说CA的对象只有一个引用计数，而CB的对象只有2个引用计数，当test_refer_to_each_other这个函数返回时，对象ptr_a和ptr_b被销毁，也就是①③两条引用会被断开，此时CA对象的引用计数会减为0，对象被销毁，其内部的m_ptr_b成员变量也会被析构，导致CB对象的引用计数会减为0，对象被销毁，进而解决了引用成环的问题。
weak_ptr 注意事项
// 编译错误 // error C2665: “std::weak_ptr::weak_ptr”: 3 个重载中没有一个可以转换所有参数类型
// weak_ptr ptr_1(new CA());
// 编译错误
// error C2440 : “初始化”: 无法从“std::weak_ptr”转换为“std::shared_ptr”
// shared_ptr ptr_3 = wk_ptr;
// 编译错误
// 编译必须作用于相同的指针类型之间
// wk_ptr_a.swap(wk_ptr_b); // 调用交换函数
// 编译错误
// 编译必须作用于相同的指针类型之间
// wk_ptr_b = wk_ptr_a;
weak_ptr中只有函数lock和expired两个函数比较重要，因为它本身不会增加引用计数，所以它指向的对象可能在它用的时候已经被释放了，所以在用之前需要使用expired函数来检测是否过期，然后使用lock函数来获取其对应的shared_ptr对象，然后进行后续操作：
void test2()
{
shared_ptr ptr_a(new CA()); // 输出：CA() called!
shared_ptr ptr_b(new CB()); // 输出：CB() called!
cout << "ptr_a use count : " << ptr_a.use_count() << endl; // 输出：ptr_a use count : 1
cout << "ptr_b use count : " << ptr_b.use_count() << endl; // 输出：ptr_b use count : 1
weak_ptr wk_ptr_a = ptr_a;
weak_ptr wk_ptr_b = ptr_b;
if (!wk_ptr_a.expired())
{
wk_ptr_a.lock()->show(); // 输出：this is class CA!
}
if (!wk_ptr_b.expired())
{
wk_ptr_b.lock()->show(); // 输出：this is class CB!
}
wk_ptr_b.reset(); // 将wk_ptr_b的指向清空
if (wk_ptr_b.expired())
{
cout << "wk_ptr_b is invalid" << endl; // 输出：wk_ptr_b is invalid 说明改指针已经无效
}
wk_ptr_b = ptr_b;
if (!wk_ptr_b.expired())
{
wk_ptr_b.lock()->show(); // 输出：this is class CB! 调用赋值操作后，wk_ptr_b恢复有效
}
// 最后输出的引用计数还是1，说明之前使用weak_ptr类型赋值，不会影响引用计数
cout << "ptr_a use count : " << ptr_a.use_count() << endl; // 输出：ptr_a use count : 1
cout << "ptr_b use count : " << ptr_b.use_count() << endl; // 输出：ptr_b use count : 1
}