C++｜深入理解智能指针

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++｜深入理解智能指针相关的知识，希望对你有一定的参考价值。

参考技术A It’s often the case that you’ll need something that behaves like a pointer, but a built-in pointer type just doesn’t do the job. In those cases, a C++ programmer will use a “smart pointer. ”

我们经常遇到这样的情形：需要某种类似指针的东西，但内建的指针又做不了我们想要做的事情。在这些情形下，C++程序员可以使用一个“智能指针” 。

A smart pointer is a class type that is tricked up to look and act like a pointer but that provides additional capability beyond that provided by a built-in pointer. Generally, a smart pointer uses the capabilities provided by a class’s constructors, destructor, and copy operations to control access to or keep track of what it points to in a way that a built-in pointer cannot.

智能指针是一个类类型，它乔装打扮成一个指针，但额外提供了内建指针所无法提供的能力。通常而言，一个智能指针通过使用类的构造函数、析构函数和复制操作符所提供的能力，来控制（或跟踪）对它所指向的东西的访问，而内建指针在这方面则无能为力。所有智能指针都重载 -> 和＊ 操作符，从而可以采用标准指针语法来使用它们（一些罕见的智能指针甚至还重载了->＊ 操作符)。

All smart pointers overload the -> and * operators so that they can be used with standard pointer syntax. (Some rare specimens even go so far as to overload the ->* operator; ) Other smart pointers (in particular, smart pointers used as STL iterators) overload other pointer operators, like ++, --, +, -, +=, -=, and []. Smart pointers are often implemented as class templates so that they may refer to different types of objects. Here’s a very simple smart pointer template that performs a check that it’s not null before use:

另有一些智能指针（尤其是用作STL迭代器的指针）还重载了其他一些指针操作符，包括++、--、 、－、+=、-=以及[ ]等。智能指针通常采用类模板来实现，从而使它们可以指向不同类型的对象。下面是一个非常简单的智能指针模板，它执行一个检查， 确保在被使用之前不为空：

Use of a smart pointer should be straightforward, mimicking the use of a built-in pointer:

智能指针的用法非常简单，酷似内建指针的用法：

The key to this facede is the overloaded operator ->. The -> operator must be overloaded as a member and has a rather unusual property in that it is not “consumed” when it is called. In other words, when we write s->draw(), the compiler recognizes that s is not a pointer but a class object with an overloaded operator -> (that is, that s is a smart pointer). This results in a call to the member overloaded operator, which returns (in this case) a Shape * built-in pointer. This pointer is then used to call Shape’s draw function. If you write this out longhand, you’ll get the following challenging expression: (s. operator ->())->draw(), which contains two uses of the -> operator, one overloaded, one built in.

在这个用法外表之下的关键点在于重载的operator->, 此操作符必须被重载为一个成员函数，并且具有一个非同寻常的性质，即当它被调用时，它并不被消耗掉(consumed)，换句话说， 当我们写s->draw()时， 编译器识别出s不是一个指针， 而是一个重载了operator->的类对象（即s是一个智能指针）。这将导致对成员重载的操作符的调用，本例中返回一个Shape*内建指针。然后该指针被用于调用Shape的draw函数。如果采用普通写法来编写代码，将会得到如下具有挑战性的表达式(s.operator->())->draw(), 其中包含了两个->操作符，一个是重载的版本，另一个是内建的版本。

Smart pointers also typically overload operator * as well as operator -> so that they may be used to refer to nonclass types.

除了重载operator->外，智能指针通常还重载operator *, 从而可以用它们指向不是类的类型，如下所示：

Smart pointers are used pervasively in C++ programming, from resource handles to STL iterators, to reference counting pointers, to wrappers around pointers to member functions, and on and on.

智能指针在C++编程中广泛使用，从资源句柄到STL迭代器，再到引用计数指针，再到围绕成员函数的指针的包装器，等等。

ref

《C++ COMMON KNOWLEDGE: ESSENTIAL INTERMEDIATE PROGRAMMING》

深入理解C++中的move和forward！

导语 |  在C++11标准之前，C++中默认的传值类型均为Copy语义，即：不论是指针类型还是值类型，都将会在进行函数调用时被完整的复制一份！对于非指针而言，开销及其巨大！因此在C++11以后，引入了右值和Move语义，极大地提高了效率。本文介绍了在此场景下两个常用的标准库函数：move和forward。

一、特性背景

（一）Copy语义简述

C++中默认为Copy语义，因此存在大量开销。

以下面的代码为例：

0_copy_semantics.cc

#include <iostream>
#include <vector>


class Object 
public:
    Object() 
        std::cout << "build this object!" << std::endl;
    


    virtual ~Object() 
        std::cout << "destruct this object!" << std::endl;
    
;


void f(const Object obj) 


int main() 
    Object obj;


    // function calling
    f(obj);


    // vector
    std::vector<Object> v;
    v.push_back(obj);

最终的输出结果为：

build this object!
destruct this object!
destruct this object!
destruct this object!

第一个为显式调用构造函数创建obj时的输出。

后面的输出说明存在三个对象，因此调用了三次析构函数。

即：除了我们显式构造的函数之外，我们在调用函数、将对象加入vector的时候，也创建了新的对象！

并且这个对象不是通过构造函数创建的，事实上是通过复制构造函数创建的！

当尝试将复制构造函数禁用后，上面的代码将无法编译：

Object (const Object& object) = delete;

（二）临时值（右值）简述

Copy语义虽然用起来很方便，但是很多时候我们并不想将值（尤其是一些临时变量）Copy一遍再使用！

例如：

func("some temporary string"); // 尽管直接将一个常量传入函数中, C++还是大概率会创建一个string的复制
v.push_back(X()); // 初始化了一个临时X, 然后被复制进了vector
a = b + c; // b+c是一个临时值, 然后被赋值给了a
x++; // x++操作也有临时变量的产生（++x则不会产生）
a = b + c + d; //c+d是一个临时变量, b+(c+d)是另一个临时变量

另外还有函数在返回时：

vector<string> str_split(const string& s) 
  vector<string> v;
  // ...
  return v; // v是左值，但优先移动，不支持移动时仍可复制

注意：上面的函数在返回时，实际上编译器会对返回值进行优化，并不会先析构v，再在str_split 函数的调用栈中对整个v进行Copy。

但是之前的C++的确是这么做的，因此会出现类似于下面的代码：

void str_split(const string& s, vector<string>* vec);

即：将返回值也作为一个输入参数。

上面编译器的优化有一个非常学术的名字：RVO (Return Value Optimization)，返回值优化。

感兴趣的可以看看下面的文章：

C++ 编译器优化之RVO与NRVO

https://www.yhspy.com/2019/09/01/C-%E7%BC%96%E8%AF%91%E5%99%A8%E4%BC%98%E5%8C%96%E4%B9%8B-RVO-%E4%B8%8E-NRVO/

上面的这些临时值，在C++中被统一定义为：右值(rvalue)，因为在编译器的角度，实际上并没有对应的变量名存储这些变量值。

对面上面提到的一些临时值的场景都有一些共性：

  • 临时变量的内容先被复制一遍。

  • 被复制的内容覆盖到成员变量指向的内存。

  • 临时变量用完了再被回收。

其实这里是可以优化的：

临时变量其实最终都是要被回收的，如果能把临时变量的内容直接“移入”成员变量中，此时就不需要调用复制构造函数了！

即：

  • 成员变量内部的指针指向”temporary str1”所在的内存。

  • 临时变量内部的指针指向成员变量以前所指向的内存。

  • 最后临时变量指向的那块内存再被回收。

上面的操作即可避免一次对象Copy的发生，实际上它就是所谓的Move语义。

对于使用过Rust的开发者来说，这里他们是非常熟悉的。因为Rust丧心病狂的将所有赋值操作都默认定义为了Move语义！

二、使用move函数

（一）move函数的基本使用

对比之前的例子，这里我们使用move语义对其进行优化：

1_move_semantics.cc

#include <iostream>
#include <utility>
#include <vector>
#include <string>


class Object 
public:
    explicit Object(std::string str) : _str(std::move(str)) 
        std::cout << "build this object, address: " << this << std::endl;
    


    virtual ~Object() 
        std::cout << "destruct this object, address: " << this << std::endl;
    


    Object(const Object &object) : _str(object._str) 
        std::cout << "copy this object, address: " << this << std::endl;
    


    Object(Object &&object) noexcept: _str(std::move(object._str)) 
        std::cout << "move this object!" << std::endl;
    


    std::string _str;
;


void f_copy(Object obj) 
    std::cout << "copy function, address: " << &obj << std::endl;



void f_move(Object &&obj) 
    Object a_obj(std::move(obj));
    std::cout << "move function, address: " << &a_obj << std::endl;



int main() 
    Object obj"abc";


    // function calling
    f_copy(obj);
    f_move(std::move(obj));


//    std::cout << obj._str << std::endl; // danger!


    std::cout << "============== end ================" << std::endl;


    return 0;

这里的用法其实是没有意义的，只是为了演示强行使用了move

为了方便演示，这里给Object类增加了一个string类型的成员，并且输出了Object的内存地址。

代码输出：

build this object, address: 000000FD546FF5A8 // Object obj"abc"
copy this object, address: 000000FD546FF620 // f_copy(obj)
copy function, address: 000000FD546FF620 // Object(const Object &object)
destruct this object, address: 000000FD546FF620 // f_copy(obj) End
move this object! // Object a_obj(std::move(obj));
move function, address: 000000FD546FF508 // f_move(Object &&obj)
destruct this object, address: 000000FD546FF508 // f_move(Object &&obj) End
============== end ================
destruct this object, address: 000000FD546FF5A8 // main End

可以看到，相比于Copy，我们直接使用了move函数将变量移入了函数中，此时是没有调用复制构造函数的！

实际上，C++中的move函数只是做了类型转换，并不会真正的实现值的移动！

因此，对于自定义的类来说，如果要实现真正意义上的 “移动”，还是要手动重载移动构造函数和移动复制函数。

即：我们需要在自己的类中实现移动语义，避免深拷贝，充分利用右值引用和std::move的语言特性。

实际上，通常情况下C++编译器会默认在用户自定义的class和struct中生成移动语义函数。

但前提是：用户没有主动定义该类的拷贝构造等函数！

同时也要注意到：使用一个已经被move过的函数是非常危险的事情！

（二）move语义下的析构函数

在上面的测试在，可能你也注意到了一点就是：

destruct this object, address: 000000FD546FF508 // f_move(Object &&obj) End
============== end ================
destruct this object, address: 000000FD546FF5A8 // main End

对象被move了之后，仍然会在其离开作用域之后调用他的析构函数？

这是因为：

  • 虽然将obj的资源给了a_obj ，但是obj并没有立刻析构，只有在obj离开了自己的作用域的时候才会析构；因此，如果继续使用str2的m_data变量，可能会发生意想不到的错误。

  • 也正因为如此，在自己实现移动构造函数的时候，需要将原对象中的值手动置为空，以防止同一片内存区域被多次释放！

此外还需要注意：

  • 如果我们没有提供移动构造函数，只提供了拷贝构造函数，std::move()会失效但是不会发生错误，因为编译器找不到移动构造函数就去寻找拷贝构造函数，这也是拷贝构造函数的参数是const T&常量左值引用的原因！

  • c++11中的所有容器都实现了move语义，move只是转移了资源的控制权，本质上是将左值强制转化为右值使用，以用于移动拷贝或赋值，避免对含有资源的对象发生无谓的拷贝。

  • move对于拥有如内存、文件句柄等资源的成员的对象有效，如果是一些基本类型，如int和char[10]数组等，如果使用move，仍会发生拷贝（因为没有对应的移动构造函数），所以说move对含有资源的对象说更有意义。

上面的例子只是对move语义的简单介绍，下面给出了一个真正需要自己手动管理资源（内存地址）的例子：

1_move_and_destructor.cc

#include <iostream>
#include <utility>
#include <vector>


class MyString 
public:
    // Constructor
    explicit MyString(const char *data) 
        if (data != nullptr) 
            _data = new char[strlen(data) + 1];
            strcpy(_data, data);
         else 
            _data = new char[1];
            *_data = '\\0';
        


        std::cout << "built this object, address: " << this << std::endl;
    


    // Destructor
    virtual ~MyString() 
        std::cout << "destruct this object, address: " << this << std::endl;
        delete[] _data;
    


    // Copy constructor
    MyString(const MyString &str) 
        std::cout << "copy this object, address: " << this << std::endl;
        _data = new char[strlen(str._data) + 1];
        strcpy(_data, str._data);
    


    // Move constructor
    MyString(MyString &&str) noexcept
            : _data(str._data) 
        std::cout << "move this object" << std::endl;
        str._data = nullptr; // Very important!
    


    // Copy assignment
    MyString& operator=(const MyString& str)
        if (this == &str) // 避免自我赋值!!
            return *this;


        delete[] _data;
        _data = new char[ strlen(str._data) + 1 ];
        strcpy(_data, str._data);
        return *this;
    


    // Move assignment
    MyString& operator=(MyString&& str) noexcept
        if (this == &str) // 避免自我赋值!!
            return *this;


        delete[] _data;
        _data = str._data;
        str._data = nullptr; // 不再指向之前的资源了
        return *this;
    


public:
    char *_data;
;


void f_move(MyString &&obj) 
    MyString a_obj(std::move(obj));
    std::cout << "move function, address: " << &a_obj << std::endl;



int main() 
    MyString obj"abc";


    f_move(std::move(obj));


//    std::cout << obj._data << std::endl; // danger!


    std::cout << "============== end ================" << std::endl;


    return 0;

最终输出：

built this object, address: 000000843D0FFD78
move this object
move function, address: 000000843D0FFD08
destruct this object, address: 000000843D0FFD08
============== end ================
destruct this object, address: 000000843D0FFD78

这里需要注意，在移动构造函数和移动赋值函数中，我们将当前待移动对象的资源赋值为了空（str._data=nullptr），这里就是我们手动实现了 资源的移动！

下面我们尝试修改两个地方，来导致报错：

  • 使用资源被move后的对象。

  • 在实现移动构造函数时不赋值为nullptr。

  • 使用资源被move后的对象

将注释打开：

//    std::cout << obj._data << std::endl; // danger!

此时执行代码会疯狂报错：

Exception: Exception 0xc0000005 encountered at address 0x7ff62a4f245a: Access violation reading location 0x00000000

因为此时obj中的内容已经为空了！

  • 在实现移动构造函数时不赋值为nullptr

将这里注释掉：

MyString(MyString &&str) noexcept
    : _data(str._data) 
        std::cout << "move this object" << std::endl;
        // str._data = nullptr; // Very important!

此时再执行代码，整个程序会直接崩溃，因为：我们未将已经move掉的资源设置为空值，最终会导致这里的资源被释放两次！

三、什么又是foward函数

有了move函数之后，我们又遇到了一个新的问题：

按照上面的写法，处理临时变量用右值引用T&&，处理普通变量用const引用const T&，我们需要分别建立两个函数，然后入参使用不同的类型，每个函数都要写两遍。

那么能不能避免重复，将T &&类型和const T &类型合二为一呢？

答案就是：forward函数，std::forward也被称为完美转发，即：保持原来的值属性不变：

  • 如果原来的值是左值，经std::forward处理后该值还是左值。

  • 如果原来的值是右值，经std::forward处理后它还是右值。

这样一来，我们就可以使用forward函数对入参进行封装，从而保证了入参的统一性，从而可以实现一个方法处理两种类型！

正因为如此，forward函数被大量用在了入参值类型情况不确定的C++模板中！

2_forward.cc

template<typename T>
void f_forward(T &&t) 


    Object a = std::forward<T>(t);


    std::cout << "forward this object, address: " << &a << std::endl;



int main() 
    Object obj"abc";
    f_forward(obj);


    f_forward(Object("def"));


    return 0;

紧接着上面的例子，我们构建了一个模板函数f_forward。

在里面我们调用了std::forward<T>(t)来创建一个新的对象。

在main函数中，我们分别使用一个左值和一个右值调用了该模板函数。

结果如下：

build this object, address: 000000CFAE8FFC78
copy this object, address: 000000CFAE8FFBD8
forward this object, address: 000000CFAE8FFBD8
destruct this object, address: 000000CFAE8FFBD8
build this object, address: 000000CFAE8FFCB8
move this object!
forward this object, address: 000000CFAE8FFBD8
destruct this object, address: 000000CFAE8FFBD8
destruct this object, address: 000000CFAE8FFCB8
destruct this object, address: 000000CFAE8FFC78

一个调用了复制构造函数，另一个调用了移动构造函数。

forward函数成功的识别到了我们的入参，并完成了转发，即：

  • 如果外面传来了右值临时变量，它就转发右值并且启用move语义。

  • 如果外面传来了左值，它就转发左值并且启用copy，同时它也还能保留const。

四、move和forward函数的区别

从上面的分析我们可以看出，基本上forward可以cover所有的需要move的场景，毕竟forward函数左右值通吃。

那为什么还要使用move呢？原因主要有两点：

  • 首先，forward函数常用于模板函数这种入参情况不确定的场景中，在使用的时候必须要多带一个模板参数forward<T>，代码略复杂。

  • 此外，明确只需要move临时值的情况下如果使用了forward，会导致代码意图不清晰，其他人看着理解起来比较费劲。

实际上从实现的角度上来说，他们都可以被static_cast替代。

注意：为什么不用static_cast呢？也是为了阅读和使用起来更方便。

五、move和forward函数的实现

（一）C++11后加入的一些新规则

  • 引用折叠规则

如果间接的创建一个引用的引用，则这些引用就会“折叠”，在所有情况下（除了一个例外），引用折叠成一个普通的左值引用类型。

一种特殊情况下，引用会折叠成右值引用，即右值引用的右值引用：T&& &&。

即：

  • X& &、X& &&、X&& &都折叠成X&。

  • X&& &&折叠为X&&。

  • 右值引用的特殊类型推断规则

当将一个左值传递给一个参数是右值引用的函数，且此右值引用指向模板类型参数(T&&)时，编译器推断模板参数类型为实参的左值引用，如：

template<typename T> 
void f(T&&);


int i = 42;
f(i)

上述的模板参数类型T&&最终将被推断为int&类型，而非int！

  • 若将这两个规则结合起来，则意味着可以传递一个左值int i给f，编译器将推断出T的类型为int&。

  • 再根据引用折叠规则 void f(int& &&)将推断为void f(int&)，因此，f将被实例化为: void f<int&>(int&)。

从上述两个规则可以得出结论：如果一个函数形参是一个指向模板类型的右值引用，则该参数可以被绑定到一个左值上。

即类似下面的定义：

template<typename T> 
void f(T&&);

  • 可以通过static_cast显式地将一个左值转换为一个右值

虽然不能隐式的将一个左值转换为右值引用，但是可以通过static_cast显式地将一个左值转换为一个右值。

C++11中为static_cast新增的转换功能。

（二）move函数解析

标准库中move的定义如下：

template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept  // forward _Arg as movable
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);

move函数的参数T&&是一个指向模板类型参数的右值引用（见上方新规则），通过引用折叠，此参数可以和任何类型的实参匹配！

因此move函数的入参既可以传递一个左值，也可以传递一个右值！

右值情况，std::move(string("hello"))调用解析：

  • 首先，根据模板推断规则，确地T的类型为string，typename remove_reference_t<_Ty>&&的结果为string &&，因此，move 函数的返回值参数类型为string&&。

  • 同时，对于static_cast<string &&>(_Arg)来说，_Arg已经是 string&&，于是类型转换什么都不做，直接返回string&&。

左值情况，string s1("hello"); std::move(s1); 调用解析：

  • 首先，根据模板推断规则，确定T的类型为string&，typename remove_reference_t<_Ty>&& 的结果为string&，因此move函数的参数类型为string& &&，引用折叠之后为string&。

  • 同时，对于static_cast<string &&>(_Arg)来说，_Arg是string&，经过static_cast之后转换为string&&，返回string&&。

因此，从move函数的实现可以看出，move自身除了做一些参数的推断之外，返回右值引用本质上还是靠static_cast<T&&>完成的。

因此下面两个调用是等价的，std::move就是个语法糖

void func(int&& a) 
    cout << a << endl;



int a = 6;
func(std::move(a));


int b = 10;
func(static_cast<int&&>(b));

需要注意的是：std::move函数仅仅执行到右值类型的无条件转换；就其本身而言，它没有“move”任何东西。

（三）forward函数解析

标准库中forward函数的定义如下：

template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept  // forward _Arg as movable
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);

当传递一个lvalue或者const lvaue时：

  • 传递一个lvalue，模板推导之后_Ty=_Ty&。

  • 传递一个const lvaue, 模板推导之后_Ty=const_Ty&。

  • 随后，_Ty& && 将折叠为_Ty&，即_Ty& && 折叠为 _Ty&，即最终返回 _Ty&类型。

  • std::forward<_Ty&>(_Arg)将返回一个左值，最终调用拷贝构造函数。

类似的，当传递一个rvalue时：

remove_reference_t<_Ty>&& move(_Ty&& _Arg) 将返回一个右值，最终调用移动构造函数。

六、总结

首先，std::move和std::forward本质都是转换：

  • std::move执行强制到右值的无条件转换。

  • std::forward只有在它的参数绑定到一个右值上的时候，才转换它的参数到一个右值。

  • std::move没有move任何东西，std::forward没有转发任何东西。

整个类型转变的实现是在编译期完成的，在运行期，它们没有做任何事情。

它们没有为移动或者复制产生需要执行的代码，一byte都没有；（换言之，我们需要通过重载移动相关操作函数来自己处理move语义）

在使用场景方面：

  • 一般在模板元编程里面，由于入参的值类型不确定，因此对于forward使用比较多。

  • 在一般的函数中，如果可以确定传入的一定是右值（临时值），可以直接使用move函数，强调使用场景。

源代码：

https://github.com/JasonkayZK/cpp-learn/tree/value

参考资料：

1.C++11特性之move和forward应用与区别

2.C++11std::move和std::forward

3.C++右值引用与move

 作者简介

张凯

腾讯后台开发工程师

腾讯后台开发工程师，毕业于华南理工大学。目前负责腾讯电子签的后端开发工作。

 推荐阅读

甜skr人！程序员专属七夕表白神器，成功率100%

如何从0到1构建一个稳定、高性能的Redis集群？（附16张图解）

31个！Golang常用工具来啦（建议收藏）

深入浅出详解Knative云函数框架！

以上是关于C++｜深入理解智能指针的主要内容，如果未能解决你的问题，请参考以下文章

智能指针--转

智能指针

C++智能指针

C++智能指针详解:智能指针的引入

C++ 和智能指针——智能指针在这种情况下有啥帮助？

C++ 智能指针性能