c++ 智能指针基本概念

这里只展示智能指针的基本概念和操作，往后会详细介绍具体用法

智能指针基本操作

• 栈对象：仅在定义的程序块运行时存在
• static 对象：在使用之前分配，在程序结束时销毁
• 堆对象：动态分配的对象，在程序运过程中可以随时建立或删除
  • 需要注意内存泄漏的问题，例如：释放空指针，或者程序结束并没有释放内存等等。或者是使用一个已经释放的对象。
• 动态分配的对象在释放之前会一直存在
• 有三种常用的智能指针: shared_ptr, unique_ptr, weak_ptr。均在头文件<memory>中

new : 在动态内存中为对象分配空间并返回指向该对象的指针
delete ：接受一个动态对象的指针，销毁该对象并释放与之关联的内存
在delete之后，指针就变成了空悬指针

shared_ptr

shared_ptr:允许多个指针指向同一个对象

• 默认情况下：用来初始化智能指针的普通指针，必须指向动态内存。否则必须提供操作来替代delete

shared_ptr<T> p(q); // p 管理内置指针 q 所指向的对象，q 必须指向 new 分配的内存且能够转换为 T* 类型

shared_ptr<T> p(u); // p 从 unique_ptr u 那里接管了对象的所有权，将u置为空

shared_ptr<T> p(q, d); // p 接管了内置指针 q 所指向的对象的所有权，q 必须能转换为 T*类型。p 将使用可调用对象 d 来代替 delete

shared_ptr<T> p(p2, d); // p 是shared_ptr p2 的拷贝，唯一的区别是 p 将用可调用对象 d 来代替delete

/* 若 p 是唯一指向其对象的 shared_ptr，reset 会释放此对象，若传递了可选的参数内置指针 q ，会令 p 指向 q，否则会将 p 置为空。若还传递了参数 d ，将会调用 d 而不是delete来释放q
*/
p.reset();
p.reset(q);
p.reset(q, d);

• 智能指针的构造函数是explicit的

shared_ptr<int> p1 = new int(1024); // 错误！必须使用直接初始化形式

shared_ptr<int> p2(new int(1024)); // 直接初始化形式

shared_ptr<int> clone(int p)
{
	return new int(p); // 错误：隐式转换
}
shared_ptr<int> clone(int p)
{
	return shared_ptr<int>(new int(p));
}

shared_ptr 和 unique_ptr 都支持的操作

shared_ptr<T> sp; // 空智能指针，可以指向类型为 T 的对象
unique_ptr<T> up; 
p    // 将 p用作一个判断条件，若 p 指向一个对象，则为 true
*p   // 解引用 p ，获得它指向的对象
p->mem; // 等价于 (\*p).mem;_
p.get(); // 返回 p 中保存的指针。注意：若智能指针释放了其对象，返回指针所指向的对象也会消失
swap(p, q);  // 交换 p 和 q 中的指针
p.swap(q);

• 不能使用 get 初始化另一个智能指针或为另一个智能指针赋值

shared_ptr 独有的操作

make_shared<T> (args) // 返回一个shared_ptr, 指向一个动态类型为 T 的对象。使用 args 初始化此对象

shared_ptr<T> p(q); // p 是 shared_ptr q的拷贝，此操作会递增 q 中的计数器。q 中的指针必须能转换为 T*

p = q; // p 和 q都是shared_ptr 所保存的指针必须能互相转换，此操作会递减 p 的引用计数，递增 q 的引用计数，若 p 的引用计数变为 0 ，则将其管理的原内存释放

p.unique(); // 若 p.use_count() 为 1，返回 true，否则返回 false
p.use_count(); // 返回 p 共享对象的指针指针数量，主要用于调试

• 最安全的分配和使用动态内存的方法是调用 make_shared 函数
• 使用动态对象的一个常见原因是允许多个对象共享相同的状态

unique_ptr

• 独占所有对象

unique_ptr<int> p1; // 可以指向一个 int 的unique_ptr
unique_ptr<int> p2(new int(42)); // 指向一个值为 42 的int

unique_ptr<string> p1(new string("hello"));
unique_ptr<string>p2(p1); // 错误：unique 不支持拷贝
unique_ptr<string> p3;
p3 = p2; // 错误 unique_ptr 不支持赋值

unique_ptr的操作

unique_ptr<T> u1; // 空unique_ptr,可以指向 为T的对象，u1会使用delete来释放它的指针，u2 会使用一个类型为 D 的可调用对象来释放它的指针
unique_ptr<T, D> u2;

unique_ptr<T, D> u(d); // 空unique_ptr,指向类型为 T 的对象，用类型 D的对象 d 代替delete

u = nullptr; // 释放 u 所指向的对象，将 u 置为空
u。release(); // u 放弃对指针的控制权，返回指针，并将 u 置为空
u.reset(); // 释放 u 指向的对象
u.reset(q); // 如果提供了内置指针 q ，令u指向这个对象，否则将 u 置为空
u.reset(nullptr); 

• 虽然不能拷贝或赋值unique_ptr, 但可以通过release或reset将指针的所有权(非const)转移给另一个

weak_ptr

绑定到shared_ptr, 不会改变引用计数

weak_ptr<T> w; // 可以指向类型为 T 的对象
weak_ptr<T> w(sp); // 与shared_ptr sp 指向相同对象的weak_ptr.T必须能转换为 sp 指向的类型

w = p; // p可以是一个 shared_ptr 或一个 weak_ptr. 赋值后 w 与 p 共享对象
w.reset(); // 将 w 置为空
w.use_count(); // 与 w 共享对象的shared_ptr 数量
w.expried(); // 若w.use_count() 为 0 返回true，否则返回false
w.lock(); // 如果expired为true，返回一个空的shared_ptr,否则返回一个指向w的对象的shared_ptr

• 不能使用weak_ptr 直接访问对象，必须调用lock