C++的std::move与std::forward原理大白话总结

Posted 长江很多号

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++的std::move与std::forward原理大白话总结相关的知识,希望对你有一定的参考价值。

阅读大型的C++开源项目代码,基本逃不过std::move和std::forward,例如webRTC。
所以搞懂其原理,很有必要。

网络上已有不少文章介绍(见@参考),但是比较分散,所以我把自认为的关键点,加上一些自己的想法,提取总结一下。

1. std::move

别看它的名字叫move,其实std::move并不能移动任何东西,它唯一的功能是将一个左值/右值强制转化为右值引用,继而可以通过右值引用使用该值,所以称为移动语义

std::move的作用:将对象的状态或者所有权从一个对象转移到另一个对象,只是转移,没有内存的搬迁或者内存拷贝所以可以提高利用效率,改善性能。 它是怎么个转移法,将在文章的最后面解释。

1.1 函数原型

函数定义原型:

/**
 *  @brief  Convert a value to an rvalue.
 *  @param  __t  A thing of arbitrary type.
 *  @return The parameter cast to an rvalue-reference to allow moving it.
*/
template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
	return static_cast<typename remove_reference<T>::type&&>(t);
}

用到的remove_reference定义

/// remove_reference
  template<typename _Tp>
    struct remove_reference
    { typedef _Tp   type; };

  template<typename _Tp>
    struct remove_reference<_Tp&>
    { typedef _Tp   type; };

  template<typename _Tp>
    struct remove_reference<_Tp&&>
    { typedef _Tp   type; };

1.2 参数讨论

先看参数 T&& t,其参数看起来是个右值引用,其是不然!!!

因为T是个模板,当右值引用和模板结合的时候,就复杂了。T&&并不一定表示右值引用,它可能是个左值引用又可能是个右值引用。

再弄个清爽的代码解释一下:

template<typename T>
void func( T&& param){
    
}
func(5);  //15是右值, param是右值引用
int a = 10; //
func(a); //x是左值, param是左值引用

这里的&&是一个未定义的引用类型,称为
通用引用 Universal References
(https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers)

它必须被初始化,它是左值引用还是右值引用却决于它的初始化,如果它被一个左值初始化,它就是一个左值引用;如果被一个右值初始化,它就是一个右值引用。

注意,只有当发生自动类型推断时(如函数模板的类型自动推导,或auto关键字),&&才是一个Universal References

1.3 通用引用

这里还可以再深入一下通用引用,解释为什么它一会可以左值引用,一会可以右值引用。
既然T是个模板,那T就可以是string,也可以是string&,或者string&&。
那参数就变成
(string&& && param)了
这么多&怎么办?好吓人!!!
没事,稳住,C++ 11立了规矩,太多&就要折叠一下(也就是传说中的引用折叠)。具体而言

X& &、X&& &、X& &&都折叠成X&

X&& &&折叠成X&&

所以,想知道 param 最终是什么引用,就看T被推导成什么类型了。
可以用下面的一个测试程序,来验证。

#include <iostream>
#include <type_traits>
#include <string>
using namespace std;

template<typename T>
void func(T&& param) {
    if (std::is_same<string, T>::value)
        std::cout << "string" << std::endl;
    else if (std::is_same<string&, T>::value)
        std::cout << "string&" << std::endl;
    else if (std::is_same<string&&, T>::value)
        std::cout << "string&&" << std::endl;
    else if (std::is_same<int, T>::value)
        std::cout << "int" << std::endl;
    else if (std::is_same<int&, T>::value)
        std::cout << "int&" << std::endl;
    else if (std::is_same<int&&, T>::value)
        std::cout << "int&&" << std::endl;
    else
        std::cout << "unkown" << std::endl;
}

int getInt() {
    return 10;
}

int main() {
    int x = 1;
    func(1); // 传递参数是右值 T推导成了int, 所以是int&& param, 右值引用
    func(x); // 传递参数是左值 T推导成了int&, 所以是int&&& param, 折叠成 int&,左值引用
    func(getInt());// 参数getInt是右值 T推导成了int, 所以是int&& param, 右值引用

    return 0;
}

1.4 返回值

我们以T为string为例子,简化一下函数定义:

//T的类型为string
//remove_reference<T>::type为string 
//整个std::move被实例如下
string&& move(string&& t) //可以接受右值
{
    return static_cast<string&&>(t);  //返回一个右值引用
}

显而易见,用static_cast,返回的一定是个右值引用。

综上,std::move基本等同于一个类型转换:static_cast<T&&>(lvalue);

即,输入可以是左值,右值,输出,是一个右值引用。

1.5 std::move的常用例子

1.5.1 用于vector添加值

以下是一个经典的用例:


//摘自https://zh.cppreference.com/w/cpp/utility/move
#include <iostream>
#include <utility>
#include <vector>
#include <string>
int main()
{
    std::string str = "Hello";
    std::vector<std::string> v;
    //调用常规的拷贝构造函数,新建字符数组,拷贝数据
    v.push_back(str);
    std::cout << "After copy, str is \\"" << str << "\\"\\n";
    //调用移动构造函数,掏空str,掏空后,最好不要使用str
    v.push_back(std::move(str));
    std::cout << "After move, str is \\"" << str << "\\"\\n";
    std::cout << "The contents of the vector are \\"" << v[0]
                                         << "\\", \\"" << v[1] << "\\"\\n";

输出:

After copy, str is "Hello"
After move, str is ""
The contents of the vector are "Hello", "Hello"

1.5.2 用于unique_ptr传递

#include <stdio.h>
#include <unistd.h>
#include <memory>
#include <iostream>

/***** 类定义开始****/
class TestC {
public:
    TestC(int tmpa, int tmpb):a(tmpa),b(tmpb) {
        std::cout<< "construct TestC " << std::endl;
    }

    ~TestC() {
        std::cout<< "destruct TestC " << std::endl;
    }
    void print() {
        std::cout << "print a " << a << " b " << b << std::endl;
    }

private:
    int a = 10;
    int b = 5;
};

void TestFunc(std::unique_ptr<TestC> ptrC) {
    printf("TestFunc called \\n");
    ptrC->print();
}
/***** 类定义结束****/


int main(int argc, char* argv[]) {

    std::unique_ptr<TestC> gPtrC(new TestC(2, 3));
    //初始化也可以写成如下这一句
    //std::unique_ptr<TestC> gPtrC = std::make_unique<TestC>(2, 3);

    TestFunc(std::move(gPtrC));
    //执行下面这一句会崩溃,因为gPtrC已经没有控制权
    gPtrC->print();

    return 0;
}

输出:

construct TestC 
TestFunc called 
print a 2 b 3
destruct TestC 

从日志可见,只有一次构造。

这种类型的代码,在大型开源项目,如webRTC,随处可见。下次看到了不用纠结,不用关心细节了。只要直到最后拿到unique_ptr的变量(左值)有控制权就行了。

1.6 再说转移对象控制权

从@1.5.2的例子,看到std::move(gPtrC)之后,执行gPtrC->print();会崩溃?这是为什么呢?
其是,不全部是std::move的功劳,还需要使用方,即unique_ptr配合才行。

请看这篇文章:
https://blog.csdn.net/newchenxf/article/details/116274506
当调用
TestFunc(std::move(gPtrC));
这TestFunc的参数ptrC要初始化,调用的是operator=,我把关键代码截取如下:

class unique_ptr
{
private:
	T * ptr_resource = nullptr;
	...

    unique_ptr& operator=(unique_ptr&& move) noexcept
	{
		move.swap(*this);
		return *this;
	}

// swaps the resources
	void swap(unique_ptr<T>& resource_ptr) noexcept
	{
		std::swap(ptr_resource, resource_ptr.ptr_resource);
	}

从函数看,执行完赋值后,智能指针的托管对象,即ptr_resource,交换了。
本来函数的参数ptrC,托管对象ptr_resource为空,现在换来了一个有用的,把空的,换给了gPtrC,于是gPtrC的资源为空,所以gPtrC使用资源时,也遇到空指针的错误了!

2. std::foward

有了前面的讨论,这个就简单一些了,不铺的很开。先看函数原型:

  /**
   *  @brief  Forward an lvalue.
   *  @return The parameter cast to the specified type.
   *
   *  This function is used to implement "perfect forwarding".
   */
  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }

  /**
   *  @brief  Forward an rvalue.
   *  @return The parameter cast to the specified type.
   *
   *  This function is used to implement "perfect forwarding".
   */
  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
            " substituting _Tp is an lvalue reference type");
      return static_cast<_Tp&&>(__t);
    }

有两个函数:
第一个,参数是左值引用,可以接受左值。
第二个,参数是右值引用,可以接受右值。

根据引用折叠的原理,如果传递的是左值,Tp推断为string&,则返回变成
static_cast<string& &&>,也就是static_cast<string&>,所以返回的是左值引用。

如果传递的是右值,Tp推断为string或string&&,则返回变成
static_cast<string&&>,所以返回的是右值引用。

反正不管怎么着,都是一个引用,那就都是别名,也就是谁读取std::forward,都直接可以得到std::foward所赋值的参数。

这就是完美转发的基本原理!

参考

c++ 之 std::move 原理实现与用法总结
[c++11]我理解的右值引用、移动语义和完美转发

以上是关于C++的std::move与std::forward原理大白话总结的主要内容,如果未能解决你的问题,请参考以下文章

C++ std::move()函数(将一个左值强制转化为右值引用,继而可以通过右值引用使用该值)

C++ std::move()函数(将一个左值强制转化为右值引用,继而可以通过右值引用使用该值)

C++ 11 右值引用以及std::move

C++ Primer 5th笔记(chap 16 模板和泛型编程)std::move

std::forward 与 std::move 的用法

为啥 std::move 不能与 std::list 一起使用