【转载】转移和完美转发

【本文转自】:
作者: 苏丙榅
链接: https://subingwen.cn/cpp/move-forward/
来源: 爱编程的大丙

1. std::move

在 C++11 添加了右值引用,并且不能使用左值初始化右值引用,如果想要使用左值初始化一个右值引用需要借助 std::move () 函数,使用std::move方法可以将左值转换为右值。使用这个函数并不能移动任何东西,而是和移动构造函数一样都具有移动语义,将对象的状态或者所有权从一个对象转移到另一个对象,只是转移,没有内存拷贝。

从实现上讲,std::move 基本等同于一个类型转换:static_cast<T&&>(lvalue);,函数原型如下:

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));
}

使用方法如下:

#include <iostream>

class Test
{
public:
    Test() {};
    ~Test() {};
};

int main()
{
    Test t;
    Test&& v1 = t;            // ERROR: 'initializing': cannot convert from 'Test' to 'Test &&', you cannot bind an lvalue to an rvalue reference
    Test&& v2 = std::move(t); // ok, !!通常对 t 执行了 move 语义,意味着 t 变量不在使用!!
    return 0;
}

假设一个临时容器很大,并且需要将这个容器赋值给另一个容器,就可以执行如下操作:

std::list<std::string> ls;
ls.push_back("hello");
ls.push_back("world");
......
std::list<std::string> ls1 = ls;        // 需要拷贝, 效率低
std::list<std::string> ls2 = std::move(ls);

如果不使用 std::move,拷贝的代价很大,性能较低。使用 std::move 几乎没有任何代价,只是转换了资源的所有权。如果一个对象内部有较大的堆内存或者动态数组时,使用 std::move 就可以非常方便的进行数据所有权的转移。另外,我们也可以给类编写相应的移动构造函数(T::T(T&& another))和和具有移动语义的赋值函数(T&& T::operator=(T&& rhs)),在构造对象和赋值的时候尽可能的进行资源的重复利用,因为它们都是接收一个右值引用参数。

2. std::forward

右值引用类型是独立于值的,一个右值引用作为函数参数的形参时,在函数内部转发该参数给内部其他函数时,它就变成一个左值,并不是原来的类型了。如果需要按照参数原来的类型转发到另一个函数,可以使用 C++11 提供的 std::forward () 函数,该函数实现的功能称之为完美转发。

// 函数原型
template <class T> T&& forward (typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward (typename remove_reference<T>::type&& t) noexcept;

// 精简之后的样子
std::forward<T>(t);
  • 当T为左值引用类型时,t将被转换为T类型的左值
  • 当T不是左值引用类型时,t将被转换为T类型的右值

下面通过一个例子演示一下关于 forward 的使用:

#include <iostream>

template<typename T>
void printValue(T& t)
{
    std::cout << "l-value: " << t << std::endl;
}

template<typename T>
void printValue(T&& t)
{
    std::cout << "r-value: " << t << std::endl;
}

template<typename T>
void testForward(T&& v)
{
    printValue(v);
    printValue(std::move(v));
    printValue(std::forward<T>(v));
    std::cout << std::endl;
}

int main()
{
    testForward(520);
    int num = 1314;
    testForward(num);
    testForward(std::forward<int>(num));
    testForward(std::forward<int&>(num));
    testForward(std::forward<int&&>(num));
    return 0;
}

测试代码打印的结果如下:

l-value: 520
r-value: 520
r-value: 520

l-value: 1314
r-value: 1314
l-value: 1314

l-value: 1314
r-value: 1314
r-value: 1314

l-value: 1314
r-value: 1314
l-value: 1314

l-value: 1314
r-value: 1314
r-value: 1314
  • testForward(520); 函数的形参为未定引用类型 T&&,实参为右值,初始化后被推导为一个右值引用

    • printValue(v); 已命名的右值 v,编译器会视为左值处理,实参为左值
    • printValue(std::move(v)); 已命名的右值编译器会视为左值处理,通过 move 又将其转换为右值,实参为右值
    • printValue(std::forward(v)); std::forward 的模板参数为右值引用,最终得到一个右值,实参为 ``右值`
  • testForward(num); 函数的形参为未定引用类型 T&&,实参为左值,初始化后被推导为一个左值引用

    • printValue(v); 实参为左值
    • printValue(std::move(v)); 通过 move 将左值转换为右值,实参为右值
    • printValue(std::forward(v)); std::forward 的模板参数为左值引用,最终得到一个左值引用,实参为左值
  • testForward(std::forward(num)); std::forward 的模板类型为 int,最终会得到一个右值,函数的形参为未定引用类型 T&& 被右值初始化后得到一个右值引用类型

    • printValue(v); 已命名的右值 v,编译器会视为左值处理,实参为左值
    • printValue(std::move(v)); 已命名的右值编译器会视为左值处理,通过 move 又将其转换为右值,实参为右值
    • printValue(std::forward(v)); std::forward 的模板参数为右值引用,最终得到一个右值,实参为右值
  • testForward(std::forward<int&>(num)); std::forward 的模板类型为 int&,最终会得到一个左值,函数的形参为未定引用类型 T&& 被左值初始化后得到一个左值引用类型

    • printValue(v); 实参为左值
    • printValue(std::move(v)); 通过 move 将左值转换为右值,实参为右值
    • printValue(std::forward(v)); std::forward 的模板参数为左值引用,最终得到一个左值,实参为左值
  • testForward(std::forward<int&&>(num)); std::forward 的模板类型为 int&&,最终会得到一个右值,函数的形参为未定引用类型 T&& 被右值初始化后得到一个右值引用类型

    • printValue(v); 已命名的右值 v,编译器会视为左值处理,实参为左值
    • printValue(std::move(v)); 已命名的右值编译器会视为左值处理,通过 move 又将其转换为右值,实参为右值
    • printValue(std::forward(v)); std::forward 的模板参数为右值引用,最终得到一个右值,实参为右值
上一篇:pytorch深度学习:反向传播y=w*x


下一篇:JSP动作元素include/forward