【C++】智能指针

四种智能指针：auto_ptr（C++11已经摒弃）、unique_ptr、shared_ptr 和 weak_ptr

1、unique_ptr（独占指针）

• 3种创建方式

using namespace std;

// 1.使用原始指针创建
A *p1 = new A("OK");  // A是一个类
unique_ptr<A> u_p1 ( p1 );
u_p1->print();

// 2.使用new的方式创建（推荐使用）
unique_ptr<A> u_p2 ( new A("OK") );
u_p2->print();

// 3.make_unique 创建（推荐使用）
unique_ptr<A> u_p3 = make_unique<A>("OK");
u_p3->print();

• 任何时刻，只能有一个指针管理内存，因此不支持拷贝和赋值操作，只能移动（move），这样所有权将会被转移

unique_ptr<A> u_p4 = move(u_p2);
u_p4->print();
u_p2->print();  // 程序崩溃，因为所有权转移了

• reset 方法 ：可以解除原始内存的管理，也可以用来初始化一个独占的智能指针

u_p4.reset();
u_p4->print();  // 程序崩溃

unique_ptr<A> u_p5;
u_p5.reset(new A(“520”));  // 初始化一个独占指针

2、shared_ptr（计数指针/共享指针）

• 允许多个 shared_ptr 共同管理同一个对象
• 每当shared_ptr的最后一个所有者被销毁时，关联对象或关联资源就会被删除
• shared_ptr 对象除了包括一个所拥有对象的指针外，还必须包括一个引用计数代理对象的指针
• 2种创建方式

// 1.
shared_ptr<A> s_p1(new A("OK"));
s_p1->print();

// 2.
shared_ptr<A> s_p2 = make_shared<A>("OK");
s_p2->print();

•  reset 用法

shared_ptr<A> s_p3;
s_p3.reset(new A("point"));  // 初始化一个共享指针

• 其他操作 

shared_ptr<A> s_p4 = make_shared<A>("OK");
cout << s_p4.use_count() << endl;       // 1
shared_ptr<A> s_p5 = s_p4;              // copy
cout << s_p4.use_count() << endl;       // 2  // 计数+1
cout << s_p5.use_count() << endl;       // 2

s_p4->set_str("ok!");                   // change
s_p4->print();                          // ok!
s_p5->print();                          // ok!

s_p4 = nullptr;                         // nullptr
cout << s_p4.use_count() << endl;       // 0   // 清空后计数为0
cout << s_p5.use_count() << endl;       // 1   // 只有一个指针共享

• 强制类型转换

share_ptr<void> point(new int(1)); //共享指针内部保存void型指针
share_ptr<int> point(static_cast<int *>(point.get())); //compile error，undefined pointer
static_pointer_cast<int *>(point);

// 1、static_pointer_cast
// 2、dynamic_pointer_cast
// 3、const_pointer_cast

• 线程安全问题

（1）同一个shared_ptr被多个线程 “读” 是安全的；
（2）同一个shared_ptr被多个线程 “写” 是不安全的；
        证明：在多个线程中同时对一个shared_ptr循环执行两遍swap。shared_ptr的swap函数的作用就是和另外一个 shared_ptr交换引用对象和引用计数，是写操作。执行两遍swap之后，shared _ptr引用的对象的值应该不变
（3）共享引用计数的不同的shared_ptr被多个线程 ”写” 是安全的。

• 共享指针有内存泄漏风险

当两个类对象中各自有一个 shared_ptr 指向对方时，会造成循环引用（有一个shared_ptr，计数加一，那么指向的内存就不会释放，对方不释放，里面指向自己的shared_ptr就不被销毁，计数也不能为0，互相纠缠，谁也不释放内存），使引用计数失效，从而导致内存泄露。解决此问题，引入weak_ptr，其允许共享但不拥有对象所有权，因此不会增加关联对象的引用次数。

3、weak_ptr（弱指针）

• 弱指针是共享指针辅助类，其允许共享但不拥有对象所有权，因此不会增加关联对象的引用次数
• 不能使用运算符 * 和 -> 直接访问弱指针的引用对象，而是使用 lock() 函数生成关联对象的共享指针（可能为空）
• 当拥有该对象的最后一个共享指针失去其所有权时，任何弱指针都会自动变为空

shared_ptr<A> s_p6 = make_shared<A>("OK");
weak_ptr<A> w_p1(s_p6);             // 构造weak_ptr
cout << s_p6.use_count() << endl;   // 1
cout << w_p1.use_count() << endl;   // 1
	
shared_ptr<A> s_p7 = w_p1.lock();   // 使用lock()函数生成关联的共享指针
cout << s_p6.use_count() << endl;   // 2
cout << s_p7.use_count() << endl;   // 2
cout << w_p1.use_count() << endl;   // 2