C++11 智能指针 unique_ptr，让资源管理更简单，更安全

原创已于 2022-01-22 18:34:48 修改 · 3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #安全 #开发语言

于 2022-01-21 22:06:41 首次发布

Effectivve Modern Cpp 专栏收录该内容

25 篇文章

订阅专栏

本文深入探讨了unique_ptr的设计理念，包括其轻量级特性、内存占用情况、析构过程及自定义析构方式。此外，还介绍了该智能指针的使用场景、移动语义的应用及其与其他智能指针之间的转换。

                    
总览

轻量级

行为基本和原始指针相同.

大小

默认:delete析构,大小和原始指针一样.

实现

支持构造和移动,不支持拷贝.
数据采用tuple组合,组合类之间采用继承的方式.

析构

默认和自定义.

使用

工厂.
不完整的成员指针变量.

转换

unique_ptr独占.
移动转化为shared_ptr也是可以的.

轻量级

默认

使用delete析构.

大小和原始指针一样.

分析

template <typename _Tp, typename _Dp = default_delete<_Tp>>
class unique_ptr

可以看到default_delete是默认的析构.

template<typename _Tp>
struct default_delete
{
   constexpr default_delete() noexcept = default;
   void operator()(_Tp* __ptr) const
   {
       delete __ptr;
   }
};

默认析构是一个可调用对象.无数据.

template <typename _Tp, typename _Dp>
class __uniq_ptr_impl
{
private:
   tuple<pointer, _Dp> _M_t;
};

__uniq_ptr_impl<_Tp, _Dp> _M_t;

unique_ptr的唯一成员变量,_M_t.

实际是tuple的封装,tuple则是以继承的形式实现.

所以默认delete是空类,指针继承还是空的.大小不变,多出来了一些代码而已.

使用场景

既然大小和原始指针一样,那么原始指针可以用的地方,这个也可以.

总结

对指针的封装.

其他的功能都是成员函数实现.

成员函数则是普通函数,第一参数是对象本身而已.

大小

说明

前面介绍了数据采用继承的形式。

指针的大小是不变的,那么唯一变化的就是析构类.

析构类

可以是lambda,可调用对象,其他.

入参类型和数据指针类型一致即可.

tuple

template<std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, false>
{
   _Head _M_head_impl;
};

template<std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, true>
{

};

template<std::size_t _Idx, typename _Head, typename... _Tail>
struct _Tuple_impl<_Idx, _Head, _Tail...>
 : public _Tuple_impl<_Idx + 1, _Tail...>,
   private _Head_base<_Idx, _Head>
{

};

空类无成员变量,非空类有成员变量.

模板元变成.智能代码生成器.

实现

说明

实现了构造和移动。

拷贝被delete掉了.

分析

// Disable copy from lvalue.
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;

可以看到拷贝构造和拷贝赋值都被delete.

参与匹配,但是报错.

移动

void reset(pointer __p = pointer()) noexcept
{
   using std::swap;
   swap(_M_t._M_ptr(), __p);
   if (__p != pointer())
       get_deleter()(__p);
}

pointer release() noexcept
{
   pointer __p = get();
   _M_t._M_ptr() = pointer();
   return __p;
}

unique_ptr& operator=(unique_ptr&& __u) noexcept
{
   reset(__u.release());
   get_deleter() = std::forward<deleter_type>(__u.get_deleter());
   return *this;
}

先对__u执行release,即返回并修改为空,返回值.

在执行reset进行交换并释放原值(交换出来的 __p ).

赋值传递了数据和析构对象.

使用

工厂类

创建一个成员并返回.

须知

返回时,局部变量变成右值.

然后外部接收对象调用右值构造.

移动

移动代表着资源转移.

原始资源的释放.

交换

互换,不涉及释放.

转移失败

析构.

析构失败

signal崩溃.
abort无unwind stack.

析构

回顾

默认用delete.

可以自定义析构.

自定义析构

由于采用tuple,数据之间采用继承的方式组合.
所以可以减少空类占用数据.

注意

默认是指针,大小固定.
加了自定义函数可能会增大.

拓展

数组

需要以数组的形式创建.

#include<memory>
#include<iostream>
class D{
public:
   D(){std::cout << __FUNCTION__ << std::endl;}
   ~D(){std::cout << __FUNCTION__ << std::endl;}
};

int main() {
   std::unique_ptr<D[]> d(new D[5]);
}

这里的类型是D[],而不是D.即数组和单个元素的差别.

调用也有一些差别.

重载的函数也是数组的操作[],不支持*,->操作.

通常用在C风格的函数返回数组.C++一般是使用容器.

转换为shared_ptr

因为是独占的,所以可以理解为共享,只是计数只能为1.

同时支持独占和共享的转换也是作为工厂函数的原因之一.