现代 C++：一文读懂智能指针

时间  2020-07-06
标签 现代 c++ 一文 读懂 智能 指针 栏目 C&C++ 繁體版
原文   原文链接

智能指针

C++11 引入了 3 个智能指针类型：git

  1. std::unique_ptr<T> ：独占资源全部权的指针。
  2. std::shared_ptr<T> ：共享资源全部权的指针。
  3. std::weak_ptr<T> ：共享资源的观察者，须要和 std::shared_ptr 一块儿使用，不影响资源的生命周期。

std::auto_ptr 已被废弃。github

std::unique_ptr

简单说，当咱们独占资源的全部权的时候，可使用 std::unique_ptr 对资源进行管理——离开 unique_ptr 对象的做用域时，会自动释放资源。这是很基本的 RAII 思想。数组

std::unique_ptr 的使用比较简单，也是用得比较多的智能指针。这里直接看例子。bash

  1. 使用裸指针时，要记得释放内存。
{
    int* p = new int(100);
    // ...
    delete p;  // 要记得释放内存
}
复制代码
  1. 使用 std::unique_ptr 自动管理内存。
{
    std::unique_ptr<int> uptr = std::make_unique<int>(200);
    //...
    // 离开 uptr 的做用域的时候自动释放内存
}
复制代码
  1. std::unique_ptr 是 move-only 的。
{
    std::unique_ptr<int> uptr = std::make_unique<int>(200);
    std::unique_ptr<int> uptr1 = uptr;  // 编译错误，std::unique_ptr<T> 是 move-only 的

    std::unique_ptr<int> uptr2 = std::move(uptr);
    assert(uptr == nullptr);
}
复制代码
  1. std::unique_ptr 能够指向一个数组。
{
    std::unique_ptr<int[]> uptr = std::make_unique<int[]>(10);
    for (int i = 0; i < 10; i++) {
        uptr[i] = i * i;
    }   
    for (int i = 0; i < 10; i++) {
        std::cout << uptr[i] << std::endl;
    }   
}
复制代码
  1. 自定义 deleter。
{
    struct FileCloser {
        void operator()(FILE* fp) const {
            if (fp != nullptr) {
                fclose(fp);
            }
        }   
    };  
    std::unique_ptr<FILE, FileCloser> uptr(fopen("test_file.txt", "w"));
}
复制代码
  1. 使用 Lambda 的 deleter。
{
    std::unique_ptr<FILE, std::function<void(FILE*)>> uptr(
        fopen("test_file.txt", "w"), [](FILE* fp) {
            fclose(fp);
        });
}
复制代码

std::shared_ptr

std::shared_ptr 其实就是对资源作引用计数——当引用计数为 0 的时候，自动释放资源。函数

{
    std::shared_ptr<int> sptr = std::make_shared<int>(200);
    assert(sptr.use_count() == 1);  // 此时引用计数为 1
    {   
        std::shared_ptr<int> sptr1 = sptr;
        assert(sptr.get() == sptr1.get());
        assert(sptr.use_count() == 2);   // sptr 和 sptr1 共享资源，引用计数为 2
    }   
    assert(sptr.use_count() == 1);   // sptr1 已经释放
}
// use_count 为 0 时自动释放内存
复制代码

和 unique_ptr 同样，shared_ptr 也能够指向数组和自定义 deleter。ui

{
    // C++20 才支持 std::make_shared<int[]>
    // std::shared_ptr<int[]> sptr = std::make_shared<int[]>(100);
    std::shared_ptr<int[]> sptr(new int[10]);
    for (int i = 0; i < 10; i++) {
        sptr[i] = i * i;
    }   
    for (int i = 0; i < 10; i++) {
        std::cout << sptr[i] << std::endl;
    }   
}

{
    std::shared_ptr<FILE> sptr(
        fopen("test_file.txt", "w"), [](FILE* fp) {
            std::cout << "close " << fp << std::endl;
            fclose(fp);
        });
}
复制代码

std::shared_ptr 的实现原理

一个 shared_ptr 对象的内存开销要比裸指针和无自定义 deleter 的 unique_ptr 对象略大。this

std::cout << sizeof(int*) << std::endl;  // 输出 8
  std::cout << sizeof(std::unique_ptr<int>) << std::endl;  // 输出 8
  std::cout << sizeof(std::unique_ptr<FILE, std::function<void(FILE*)>>)
            << std::endl;  // 输出 40

  std::cout << sizeof(std::shared_ptr<int>) << std::endl;  // 输出 16
  std::shared_ptr<FILE> sptr(fopen("test_file.txt", "w"), [](FILE* fp) {
    std::cout << "close " << fp << std::endl;
    fclose(fp);
  }); 
  std::cout << sizeof(sptr) << std::endl;  // 输出 16
复制代码

无自定义 deleter 的 unique_ptr 只须要将裸指针用 RAII 的手法封装好就行，无需保存其它信息，因此它的开销和裸指针是同样的。若是有自定义 deleter，还须要保存 deleter 的信息。spa

shared_ptr 须要维护的信息有两部分：3d

  1. 指向共享资源的指针。
  2. 引用计数等共享资源的控制信息——实现上是维护一个指向控制信息的指针。

因此，shared_ptr 对象须要保存两个指针。shared_ptr 的 的 deleter 是保存在控制信息中，因此，是否有自定义 deleter 不影响 shared_ptr 对象的大小。指针

当咱们建立一个 shared_ptr 时，其实现通常以下：

std::shared_ptr<T> sptr1(new T);
复制代码

image

复制一个 shared_ptr ：

std::shared_ptr<T> sptr2 = sptr1;
复制代码

image
为何控制信息和每一个 shared_ptr 对象都须要保存指向共享资源的指针？可不能够去掉 shared_ptr 对象中指向共享资源的指针，以节省内存开销？

答案是：不能。 由于 shared_ptr 对象中的指针指向的对象不必定和控制块中的指针指向的对象同样。

来看一个例子。

struct Fruit {
    int juice;
};

struct Vegetable {
    int fiber;
};

struct Tomato : public Fruit, Vegetable {
    int sauce;
};

 // 因为继承的存在，shared_ptr 可能指向基类对象
std::shared_ptr<Tomato> tomato = std::make_shared<Tomato>();
std::shared_ptr<Fruit> fruit = tomato;
std::shared_ptr<Vegetable> vegetable = tomato;
复制代码

image

另外，std::shared_ptr 支持 aliasing constructor。

template< class Y > shared_ptr( const shared_ptr<Y>& r, element_type* ptr ) noexcept;
复制代码

Aliasing constructor，简单说就是构造出来的 shared_ptr 对象和参数 r 指向同一个控制块（会影响 r 指向的资源的生命周期），可是指向共享资源的指针是参数 ptr。看下面这个例子。

using Vec = std::vector<int>;
std::shared_ptr<int> GetSPtr() {
    auto elts = {0, 1, 2, 3, 4};
    std::shared_ptr<Vec> pvec = std::make_shared<Vec>(elts);
    return std::shared_ptr<int>(pvec, &(*pvec)[2]);
}

std::shared_ptr<int> sptr = GetSPtr();
for (int i = -2; i < 3; ++i) {
    printf("%d\n", sptr.get()[i]);
}
复制代码

image

看上面的例子，使用 std::shared_ptr 时，会涉及两次内存分配：一次分配共享资源对象；一次分配控制块。C++ 标准库提供了 std::make_shared 函数来建立一个 shared_ptr 对象，只须要一次内存分配。

image

这种状况下，不用经过控制块中的指针，咱们也能知道共享资源的位置——这个指针也能够省略掉。

image

std::weak_ptr

std::weak_ptr 要与 std::shared_ptr 一块儿使用。 一个 std::weak_ptr 对象看作是 std::shared_ptr 对象管理的资源的观察者，它不影响共享资源的生命周期：

  1. 若是须要使用 weak_ptr 正在观察的资源，能够将 weak_ptr 提高为 shared_ptr。
  2. 当 shared_ptr 管理的资源被释放时，weak_ptr 会自动变成 nullptr。\
void Observe(std::weak_ptr<int> wptr) {
    if (auto sptr = wptr.lock()) {
        std::cout << "value: " << *sptr << std::endl;
    } else {
        std::cout << "wptr lock fail" << std::endl;
    }
}

std::weak_ptr<int> wptr;
{
    auto sptr = std::make_shared<int>(111);
    wptr = sptr;
    Observe(wptr);  // sptr 指向的资源没被释放，wptr 能够成功提高为 shared_ptr
}
Observe(wptr);  // sptr 指向的资源已被释放，wptr 没法提高为 shared_ptr
复制代码

image

当 shared_ptr 析构并释放共享资源的时候，只要 weak_ptr 对象还存在，控制块就会保留，weak_ptr 能够经过控制块观察到对象是否存活。

image

enable_shared_from_this

一个类的成员函数如何得到指向自身（this）的 shared_ptr？ 看看下面这个例子有没有问题？

class Foo {
 public:
  std::shared_ptr<Foo> GetSPtr() {
    return std::shared_ptr<Foo>(this);
  }
};

auto sptr1 = std::make_shared<Foo>();
assert(sptr1.use_count() == 1);
auto sptr2 = sptr1->GetSPtr();
assert(sptr1.use_count() == 1);
assert(sptr2.use_count() == 1);
复制代码

上面的代码其实会生成两个独立的 shared_ptr，他们的控制块是独立的，最终致使一个 Foo 对象会被 delete 两次。

image

成员函数获取 this 的 shared_ptr 的正确的作法是继承 std::enable_shared_from_this。

class Bar : public std::enable_shared_from_this<Bar> {
 public:
  std::shared_ptr<Bar> GetSPtr() {
    return shared_from_this();
  }
};

auto sptr1 = std::make_shared<Bar>();
assert(sptr1.use_count() == 1);
auto sptr2 = sptr1->GetSPtr();
assert(sptr1.use_count() == 2);
assert(sptr2.use_count() == 2);
复制代码

通常状况下，继承了 std::enable_shared_from_this 的子类，成员变量中增长了一个指向 this 的 weak_ptr。这个 weak_ptr 在第一次建立 shared_ptr 的时候会被初始化，指向 this。

image

彷佛继承了 std::enable_shared_from_this 的类都被强制必须经过 shared_ptr 进行管理。

auto b = new Bar;
auto sptr = b->shared_from_this();
复制代码

在个人环境下（gcc 7.5.0）上面的代码执行的时候会直接 coredump，而不是返回指向 nullptr 的 shared_ptr：

terminate called after throwing an instance of 'std::bad_weak_ptr'
 what():  bad_weak_ptr
复制代码

小结

智能指针，本质上是对资源全部权和生命周期管理的抽象：

  1. 当资源是被独占时，使用 std::unique_ptr 对资源进行管理。
  2. 当资源会被共享时，使用 std::shared_ptr 对资源进行管理。
  3. 使用 std::weak_ptr 做为 std::shared_ptr 管理对象的观察者。
  4. 经过继承 std::enable_shared_from_this 来获取 this 的 std::shared_ptr 对象。

参考资料

  1. Back to Basics: Smart Pointers
  2. unique_ptr
  3. shared_ptr
  4. weak_ptr
  5. enable_shared_from_this
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程