智能指针

一、智能指针类型&智能指针

1. 标准库提供了两种智能指针类型（来管理动态分配的对象）

2. 智能指针

　　智能指针就是一个变量、一个对象，即智能指针类型的实例化（比如在整型 int 和变量 i 中，智能指针就类似 i）

3. 智能指针与指针

　　智能指针的行为类似常规指针

　　区别：智能指针负责自动释放所指向的对象

4. 两种智能指针的区别

智能指针类型	特点
shared_ptr	允许多个指针指向同一个对象
unique_ptr	该类型指针“独占”所指向的对象

 

二、shared_ptr

1. 形式

• shared_ptr<T> p;

　　解释：创建一个智能指针时，必须提供额外的信息——指针可以指向的类型

2. 默认初始化

　　智能指针中保存着一个空指针

3. 初始化

• shared_ptr<T> p = make_shared<T>(args)
• shared_ptr<int> p1(new int (100))
• shared_ptr<int> p2(p)

4. 每个 shared_ptr 都有一个关联的计数器（该计数器由指向同一对象的shared_ptr共享），也称引用计数（记录有多少个 shared_ptr 指向相同的对象）

　　引用计数是shared_ptr所指向的对象的，即是相对智能指针所指向的对象而言的

　　初始化一个shared_ptr对象后，其关联的计数器为1（也即该shred_ptr对象所指向的对象的引用计数为1）

　　当一个shared_ptr对象的计数器变为0时，它就会自动释放自己所管理的对象（即释放内存）

5. 支持的操作（蓝色部分为shared_ptr和unique_ptr都支持的操作）

操作	说明
shared_ptr<T> sp unique_ptr<T> up	空智能指针，可以指向类型为T的对象
p	将p作为一个条件判断，若p指向一个对象，则为true
*p	解引用p，获得它指向的对象
p->mem	等价于(*p).mem
p.get()	返回一个常规指针，该指针指向p所指的对象
swap(p, q) p.swap(q)	交换p和q中的指针
make_shared<T>(args)	返回一个shared_ptr，指向一个动态分配的类型为T的对象，使用args初始化该对象
shared_ptr<T>p(q)	p是shared_ptr q的拷贝，q中的指针必须能转化为T*
p = q	p和q都是shared_ptr，所保存的指针必须能相互转换
p.use_count()	返回与p共享对象的智能指针数量
p.unique()	若p.use_count()为1，返回 true；否则返回 false

6. 备注

　　在最后一个shared_ptr销毁前内存都不会释放

　　计数器递增：用一个shared_ptr初始化另一个shred_ptr、将它当做参数传递给一个函数、作为函数的返回值

　　计数器递减：给shared_ptr赋予一个新值、shared_ptr被销毁（例如一个局部的 shared_ptr离开其作用域）

7. 其他操作

操作	说明
T *q = new T shared_ptr<T> p(q)	p管理内置指针q所指向的对象（该对象是new分配的内存）
shared_ptr<T> p(q, d)	q指向的对象不是new分配的内存，p将使用可调用对象d来代替delete
shared_ptr<T> p(p2, d)	p是shared_ptr p2的拷贝，p将使用可调用对象d来代替delete
shared_ptr<T> p(u)	p从unique_ptr u那里接管了对象的所有权，将u置为空
p.reset() p.reset(q) p.reset(q, d)	若p是唯一指向其对象的shared_ptr，reset会释放此对象 q为内置指针，会令p指向q 将会调用d而不是delete来释放q

注：当将一个shared_ptr绑定到一个普通指针时，我们就将内存的管理责任交给了这个shared_ptr；当使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器

8. 使用示例

	int *p = new int(2);
    shared_ptr<int> sp = make_shared<int>(1);
    shared_ptr<int> sp2(p);
    shared_ptr<int> sp3(sp);
    cout << sp3.use_count() << endl;
    int *p2 = sp2.get();
    sp2.reset();
    sp3.reset(new int(5));

 

 

三、unique_str

1. 某个时刻，只能有一个 unique_ptr 指向一个给定对象

　　当unique_str被销毁时，它所指向的对象也被销毁

2. 没有类似make_shared这样返回一个unique_str的函数

　　定义一个unique_str时，需要将其绑定到一个new返回的指针上（和shared_ptr一样，初始化unique_str必须采用直接初始化形式）

3. 不支持普通的拷贝或赋值操作

　　一个unique_str拥有它指向的对象（所以不能让其他的unique_str再指向它的对象啊）

4. 特有操作（与shared_ptr共享的操作参考上面）

操作	说明
unique_str<T> u1 unique_str<T, d> u2	空unique_str，可以指向类型为T的对象 u1使用delete来释放它的指针，u2使用一个类型为d的可调用对象来释放它的指针
unique_str<T, D> u(d)	同上，用类型为D的对象d代替delete
u = nullptr	释放u指向的对象，将u置为空
u.release()	返回指向u指向的对象的指针，将u置为空 release返回的指针用来：初始化另一个智能指针，或给另一个智能指针赋值
u.reset() u.reset(q)	释放u指向的对象，将u置为空 q是内置指针，令u指向q指向的对象，并释放u原先指向的对象

注：释放对象即释放内存，将u置为空即“u = nullptr”

5. 向unique_ptr传递删除器

• 类似shared_ptr，unique_ptr默认情况下用delete释放它指向的对象
• 与shred_ptr一样，我们可以重载一个unique_ptr中默认的删除器（但unique_ptr管理删除器的方式与shared_ptr不同）

6. 使用示例

	int *p = new int(2);
    unique_ptr<int> up;
    unique_ptr<int> up2(p);
    up.reset(up2.release());
    unique_ptr<int> up3(up.release()); 

　　

四、weak_ptr

1. 一种不控制所指向对象生存期的智能指针

　　它指向由一个shared_ptr管理的对象

　　将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数

　　最后一个指向对象的shared_ptr被销毁，对象就会被释放，故weak_ptr指向的对象可能不存在

2. 创建一个weak_ptr时，要用一个shared_ptr来初始化它

    auto p = make_shared<int>(42);
    weak_ptr<int> wp(p);

3. 支持的操作

操作	说明
weak_ptr<T> w	空weak_ptr，可以指向类型为T的对象
weak_ptr<T> w(sp)	与shared_ptr sp指向相同对象的weak_ptr，T必须能转换为sp指向的类型
w = p	p可以是一个shared_ptr或一个weak_ptr
w.reset()	将w置为空
w.use_count()	与w共享对象的shared_ptr的数量
w.expired()	若w.use_count()为0，返回true
w.lock()	如果w.expired()为true，返回一个空shared_ptr；否则返回一个指向w的对象的shared_ptr

4. 不能直接访问对象

　　因为对象可能不存在，故必须调用lock，此函数检查weak_ptr指向的对象是否仍存在（如果存在，lock返回一个指向共享对象的shared_ptr）

5. 使用示例

	int *p = new int(2);
    shared_ptr<int> sp(new int(3));
    weak_ptr<int> wp(sp);
	weak_ptr<int> wp2, wp3;
	wp2 = wp; 
	wp3 = sp;
	wp.reset();		//将wp置为空 
	cout << wp.use_count() << endl;
	bool bl = wp.expired();
	shared_ptr<int> sp2 = wp.lock();