C++11智能指针shared_ptr、weak_ptr、unique_ptr

一、shared_ptr

shared_ptr智能指针的创建

1. 构造空智能指针

std::shared_ptr<int> p1;             //不传入任何实参
std::shared_ptr<int> p2(nullptr);    //传入空指针 nullptr

注意，空的 shared_ptr 指针，其初始引用计数为 0，而不是 1。

2. 明确指针指向

std::shared_ptr<int> p3(new int(10));
std::shared_ptr<int> p3 = std::make_shared<int>(10);

由此，我们就成功构建了一个 shared_ptr 智能指针，其指向一块存有 10 这个 int 类型数据的堆内存空间。

3. 拷贝构造函数和移动构造函数

//调用拷贝构造函数
std::shared_ptr<int> p4(p3);//或者 std::shared_ptr<int> p4 = p3;

//调用移动构造函数
std::shared_ptr<int> p5(std::move(p4)); //或者 std::shared_ptr<int> p5 = std::move(p4);

如上所示，p3 和 p4 都是 shared_ptr 类型的智能指针，因此可以用 p3 来初始化 p4，由于 p3 是左值，因此会调用拷贝构造函数。需要注意的是，如果 p3 为空智能指针，则 p4 也为空智能指针，其引用计数初始值为 0；反之，则表明 p4 和 p3 指向同一块堆内存，同时该堆空间的引用计数会加 1。

而对于 std::move(p4) 来说，该函数会强制将 p4 转换成对应的右值，因此初始化 p5 调用的是移动构造函数。另外和调用拷贝构造函数不同，用 std::move(p4) 初始化 p5，会使得 p5 拥有了 p4 的堆内存，而 p4 则变成了空智能指针。

注意，同一普通指针不能同时为多个 shared_ptr 对象赋值，否则会导致程序发生异常。例如：

> int* ptr = new int;
> std::shared_ptr<int> p1(ptr);
> std::shared_ptr<int> p2(ptr);//错误
>

4. 内存释放规则

在初始化 shared_ptr 智能指针时，还可以自定义所指堆内存的释放规则，这样当堆内存的引用计数为 0 时，会优先调用我们自定义的释放规则。

在某些场景中，自定义释放规则是很有必要的。比如，对于申请的动态数组来说，shared_ptr 指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存。

对于申请的动态数组，释放规则可以使用 C++11 标准中提供的 default_delete<T> 模板类，我们也可以自定义释放规则：

//指定 default_delete 作为释放规则
std::shared_ptr<int> p6(new int[10], std::default_delete<int[]>());

//自定义释放规则
void deleteInt(int*p) {
    delete []p;
}
//初始化智能指针，并自定义释放规则
std::shared_ptr<int> p7(new int[10], deleteInt);

// Lambda 表达式，与上面完全相同
std::shared_ptr<int> p7(new int[10], [](int* p) {delete[]p; });

shared_ptr模板类成员方法

成员方法名	功 能
operator=()	重载赋值号，使得同一类型的 shared_ptr 智能指针可以相互赋值。
operator*()	重载 * 号，获取当前 shared_ptr 智能指针对象指向的数据。
operator->()	重载 -> 号，当智能指针指向的数据类型为自定义的结构体时，通过 -> 运算符可以获取其内部的指定成员。
swap()	交换 2 个相同类型 shared_ptr 智能指针的内容。
reset()	当函数没有实参时，该函数会使当前 shared_ptr 所指堆内存的引用计数减 1，同时将当前对象重置为一个空指针；当为函数传递一个新申请的堆内存时，则调用该函数的 shared_ptr 对象会获得该存储空间的所有权，并且引用计数的初始值为 1。
get()	获得 shared_ptr 对象内部包含的普通指针。
use_count()	返回同当前 shared_ptr 对象（包括它）指向相同的所有 shared_ptr 对象的数量。
unique()	判断当前 shared_ptr 对象指向的堆内存，是否不再有其它 shared_ptr 对象再指向它。
operator bool()	判断当前 shared_ptr 对象是否为空智能指针，如果是空指针，返回 false；反之，返回 true。

除此之外，C++11 标准还支持同一类型的 shared_ptr 对象，或者 shared_ptr 和 nullptr 之间，进行 ==，!=，<，<=，>，>= 运算。

#include <iostream>
#include <memory>
using namespace std;
int main()
{
    // 构建 2 个智能指针
    std::shared_ptr<int> p1(new int(10));
    std::shared_ptr<int> p2(p1); // 拷贝构造函数，计数=2

    // 输出 p2 指向的数据
    cout << *p2 << endl;
    p1.reset(); // 引用计数-1，p1为空指针
    
    if (p1)
        cout << "p1 不为空" << endl;
    else
        cout << "p1 为空" << endl; // p1已经空了
    
    // 以上操作，并不会影响 p2
    cout << *p2 << endl; // 10
    cout << p2.use_count() << endl; // 1
    return 0;
}

程序执行结果为：

10
p1 为空
10
1

转自：http://c.biancheng.net/view/7898.html

二、unique_ptr

unique_ptr智能指针的创建

和 shared_ptr 指针最大的不同之处在于，unique_ptr 指针指向的堆内存无法同其它 unique_ptr 共享，也就是说，每个 unique_ptr 指针都独自拥有对其所指堆内存空间的所有权。

1. 构造空智能指针

std::unique_ptr<int> p1();
std::unique_ptr<int> p2(nullptr);

2. 明确指针指向

std::unique_ptr<int> p3(new int);

3. 移动构造函数

基于 unique_ptr 类型指针不共享各自拥有的堆内存，因此 C++11 标准中的 unique_ptr 模板类没有提供拷贝构造函数，只提供了移动构造函数：

std::unique_ptr<int> p4(new int);
std::unique_ptr<int> p5(p4); // 错误，堆内存不共享
std::unique_ptr<int> p5(std::move(p4)); // 正确，调用移动构造函数

对于调用移动构造函数的 p4 和 p5 来说，p5 将获取 p4 所指堆空间的所有权，而 p4 将变成空指针（nullptr）。

4. 自定义释放规则

默认情况下，unique_ptr 指针采用 std::default_delete<T> 方法释放堆内存。和 shared_ptr 指针不同，为 unique_ptr 自定义释放规则，只能采用函数对象的方式：

// 自定义的释放规则
struct myDel
{
    void operator()(int *p) {
        delete p;
    }
};
std::unique_ptr<int, myDel> p6(new int);

unique_ptr模板类成员方法

成员函数名	功 能
operator*()	获取当前 unique_ptr 指针指向的数据。
operator->()	重载 -> 号，当智能指针指向的数据类型为自定义的结构体时，通过 -> 运算符可以获取其内部的指定成员。
operator =()	重载了 = 赋值号，从而可以将 nullptr 或者一个右值 unique_ptr 指针直接赋值给当前同类型的 unique_ptr 指针。
operator []()	重载了 [] 运算符，当 unique_ptr 指针指向一个数组时，可以直接通过 [] 获取指定下标位置处的数据。
get()	获取当前 unique_ptr 指针内部包含的普通指针。
get_deleter()	获取当前 unique_ptr 指针释放堆内存空间所用的规则。
operator bool()	unique_ptr 指针可直接作为 if 语句的判断条件，以判断该指针是否为空，如果为空，则为 false；反之为 true。
release()	释放当前 unique_ptr 指针对所指堆内存的所有权，但该存储空间并不会被销毁。
reset(p)	其中 p 表示一个普通指针，如果 p 为 nullptr，则当前 unique_ptr 也变成空指针；反之，则该函数会释放当前 unique_ptr 指针指向的堆内存（如果有），然后获取 p 所指堆内存的所有权（p 为 nullptr）。
swap(x)	交换当前 unique_ptr 指针和同类型的 x 指针。

除此之外，C++11标准还支持同类型的 unique_ptr 指针之间，以及 unique_ptr 和 nullptr 之间，做 ==，!=，<，<=，>，>= 运算。

#include <iostream>
#include <memory>
using namespace std;
int main()
{
    std::unique_ptr<int> p5(new int);
    *p5 = 10;
    
    // p 接收 p5 释放的堆内存（堆内存还在，只是被接管了）
    int *p = p5.release();
    cout << *p << endl;
    
    //判断 p5 是否为空指针
    if (p5)
        cout << "p5 is not nullptr" << endl;
    else
        cout << "p5 is nullptr" << endl; // p5已经空了
    
    std::unique_ptr<int> p6;
    //p6 获取 p 的所有权
    p6.reset(p);
    cout << *p6 << endl;
    
    return 0;
}

程序执行结果为：

10
p5 is nullptr
10

转自：http://c.biancheng.net/view/7909.html

三、weak_ptr

weak_ptr智能指针的创建

weak_ptr 虽然是智能指针的一种，但通常不单独使用，只能和 shared_ptr 类型指针搭配使用。借助 weak_ptr 类型指针， 我们可以获取 shared_ptr 指针的一些状态信息，比如有多少指向相同的 shared_ptr 指针、shared_ptr 指针指向的堆内存是否已经被释放等等。

weak_ptr 类型指针并不会影响 shared_ptr 所指堆内存空间的引用计数。

1. 构造空 weak_ptr 指针

std::weak_ptr<int> wp1;

2. 根据已有 weak_ptr 创建新的 weak_ptr 指针

凭借已有的 weak_ptr 指针，可以创建一个新的 weak_ptr 指针：

std::weak_ptr<int> wp2 (wp1);

若 wp1 为空指针，则 wp2 也为空指针；反之，如果 wp1 指向某一 shared_ptr 指针拥有的堆内存，则 wp2 也指向该块存储空间（可以访问，但无所有权）。

3. 指向 shared_ptr

weak_ptr 指针更常用于指向某一 shared_ptr 指针拥有的堆内存，因为在构建 weak_ptr 指针对象时，可以利用已有的 shared_ptr 指针为其初始化：

std::shared_ptr<int> sp (new int);
std::weak_ptr<int> wp3 (sp);

wp3 指针和 sp 指针有相同的指针。

再次强调，weak_ptr 类型指针不会导致堆内存空间的引用计数增加或减少

unique_ptr模板类成员方法

成员方法	功 能
operator=()	重载 = 赋值运算符，是的 weak_ptr 指针可以直接被 weak_ptr 或者 shared_ptr 类型指针赋值。
swap(x)	其中 x 表示一个同类型的 weak_ptr 类型指针，该函数可以互换 2 个同类型 weak_ptr 指针的内容。
reset()	将当前 weak_ptr 指针置为空指针。
use_count()	查看指向和当前 weak_ptr 指针相同的 shared_ptr 指针的数量。
expired()	判断当前 weak_ptr 指针为否过期（指针为空，或者指向的堆内存已经被释放）。
lock()	如果当前 weak_ptr 已经过期，则该函数会返回一个空的 shared_ptr 指针；反之，该函数返回一个和当前 weak_ptr 指向相同的 shared_ptr 指针。

再次强调，weak_ptr<T> 模板类没有重载 * 和 -> 运算符，因此 weak_ptr 类型指针只能访问某一 shared_ptr 指针指向的堆内存空间，无法对其进行修改。

#include <iostream>
#include <memory>
using namespace std;
int main()
{
    std::shared_ptr<int> sp1(new int(10));
    std::shared_ptr<int> sp2(sp1);
    
    std::weak_ptr<int> wp(sp2);
    //输出和 wp 同指向的 shared_ptr 类型指针的数量
    cout << wp.use_count() << endl; // 2
    
    //释放 sp2
    sp2.reset(); // 剩下sp1，计数为1
    cout << wp.use_count() << endl; // 1
    //借助 lock() 函数，返回一个和 wp 同指向的 shared_ptr 类型指针，获取其存储的数据
    cout << *(wp.lock()) << endl; // 10
    
    return 0;
}

程序执行结果为：

2
1
10

转自：http://c.biancheng.net/view/7909.html