std::move与std::forward

最新推荐文章于 2025-01-02 16:45:32 发布
原创 最新推荐文章于 2025-01-02 16:45:32 发布 · 1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

本文深入解析C++中的左值、右值概念，详细对比std::move与std::forward的功能差异，阐述引用折叠原理及如何实现完美转发，是理解C++现代特性的重要资源。

Purposes:

  1. 理解引用折叠
  2. 理解完美转发
  3. std::move()与std::forward区别

Premise:

  1. 左值: 当一个对象被用作左值的时候,用的是对象的身份(在内存中的位置)
  2. 右值: 当一个对象被用作右值的时候,用的是对象的值(内容), 右值的生命周期很短,表达式结束就会被销毁
  3. 左值引用: 通常指的是在左值前面加一个’&'符号, 左值引用不能绑定到一个右值上, 这就是我们最常用的引用方式, 例如: int i =42; int &r = i;
  4. 右值引用:右值引用必须绑定到一个右值上, 我们通常是用’&&'来获得右值引用, 例如: int &&rr = i * 66;

std::move()

template<class T>
typename remove_reference<T>::type&& move (T&& arg) noexcept;

这就是std::move函数的原型, 这里有三个难点:

  1. remove_reference::type :熟悉模板的童鞋可能知道, 这是模板里的嵌套从属类型, 而这类类型前面是需要加上typename来标注这是一个类型, 而不是一个类
  2. type后面的两个&& :这个就与引用折叠有关了, 在后面会讲到
  3. noexcept : std::move是不需要catch exception的, 如果遇到错误, 就结束进程。这与析构函数和delete操作是一样的，这里主要是为了节省编译器消耗。

std::move()函数是没有完美转发的功能的, 不论是左值还是右值, 只要是入了参, 就都是右值。

std::forward()

lvalue (1)	
template <class T> T&& forward (typename remove_reference<T>::type& arg) noexcept;
rvalue (2)	
template <class T> T&& forward (typename remove_reference<T>::type&& arg) noexcept;

可以看到这里有两个重载的std::forward函数, 再通过引用折叠就可以完成完美转发.

引用折叠

在编译器中, 具体规则是：
1.所有右值引用折叠到右值引用上仍然是一个右值引用。（A&& && 变成 A&&）
2.所有的其他引用类型之间的折叠都将变成左值引用。 （A& & 变成 A&; A& && 变成 A&; A&& & 变成 A&）

也可以说成: 只要含有&就被认为是左值引用, 其余就只剩&& &&了, 这当然就是右值引用。
这就是std::move与std::forward的中心

实际上，开发者是不能写出类似于int& &&i = 0;这种代码的, 这是编译器不允许的，只能通过类型包装或者模板参数间接的使用引用折叠。

Summary:

其实理解引用折叠与完美转发不难。
重点是要掌握基础概念：左值、右值

Appendix:

  1. [引用]https://blog.youkuaiyun.com/zhangxiao93/article/details/74974546
  2. forward的使用:http://www.cplusplus.com/reference/utility/forward/
  3. remove的使用:http://www.cplusplus.com/reference/utility/move/?kw=move
C++11 std::move和std::forward
一颗哈士奇的博客
11-11 425
下文先从C++11引入的几个规则，如引用折叠、右值引用的特殊类型推断规则、static_cast的扩展功能说起，然后通过例子解析std::move和std::forward的推导解析过程，说明std::move和std::forward本质就是一个转换函数，std::move执行到右值的无条件转换，std::forward执行到右值的有条件转换，在参数都是右值时，二者就是等价的。其实std::move和std::forward就是在C++11基本规则之上封装的语法糖。 1 引入的新规则 规则1（引用折叠规则
std::move和std::forward
weixin_47326789的博客
02-26 523
std::move是c++11引入的，用于将一个资源"移动"到另一个对象，而不是复制。但是通过std::move的源码可以发现，其底层实际并没有"转移"的动作，那是如何实现呢？通过源码可以发现，std::move的底层实际只是进行了类型强制转换，将一个变量强制转换成了一个右值。1.remove_reference_t:用于类型转换，用于移除_Ty的引用，如果_Ty是T&或者T&&,都会变成T类型2._Arg是函数参数，并且是一个右值引用，因此参数可以是左值也可以是右值。
c++中std::move和std::forward
qq_35331967的博客
03-28 394
std::move无条件转换到右值。就其本身而言，它没有move任何东西。 std::forward只有在它的参数绑定到一个右值上的时候，它才转换它的参数到一个右值。 std::move和std::forward在运行期都没有做任何事情。它们没有产生需要执行的代码，1个byte都没有。 std::move和std::forward只不过就是执行cast的两个函数（实际上是函数模板）。 std...
std::forward与std::move详解
漫步者
01-02 1034
在阅读代码时遇到了std::forward与std::move，对这两个方法含义及使用场景有点不太清楚，在此写文章进行记录加深印象。
C++中的`std::move`与`std::forward`：完美转发与移动语义的精髓
11-26
`std::move`与`std::forward`之间存在明显的区别。`std::move`用于将左值转换为右值引用，而`std::forward`用于保持参数的原始类型（左值或右值）。`std::move`通常用于需要移动语义的场景，如移动构造函数和移动...
C++ 右值引用 std::move和std::forward的使用
C++ 开发者的博客
01-28 1398
本文对C++11的move，右值引用，完美转发进行了一个简单的说明
C++：std::move() / std::forward()
pomelo的博客
08-01 712
C++：std::move() / std::forward()
std::move()和std::forward()
GXQ的博客
03-27 767
参考:https://www.cnblogs.com/mmmmmmmmm/p/15946627.htmlstd::move和std::forward本质就是一个转换函数，std::move执行到右值的无条件转换，std::forward执行到右值的有条件转换，在参数都是右值时，二者就是等价的一、完美转发 std::forward中文标准库：std::forwardstd::forward是一个模板函数，实现了参数在传递过程中保持其值属性的功能，模板参数决定了它返回的是左值还是右值。
【移动语义和精准转发系列二】std::move和std::forward
五月花
05-28 1947
在我们开始讲解std::move之前，先来介绍一个概念：引用折叠。这个概念仅用于 typedef 和 模板类型参数 中。 在模板世界中，T&& 称为Universal Reference，即通用引用。这与普通函数中形参的&&是不同的，希望不要弄混了。 对于模板函数template void func(T&& t)，对于左值实参，T&& t 推导出的T为string&；对于右值实参，T&& t
深入理解 std::move和std::forward
weixin_42915431的博客
04-14 751
1、移动语义是c++11引入，它的引入是为了解决对象赋值带来的开销，移动的实质是对象所有权的转移，它要比复制更为高效。 2、为了实现移动语义，编译器需要能够识别一个变量在什么时候只是个临时值，指没有名字的变量。 这里引入了左值、右值的概念(继承自C语言)： ①左值：通常出现在赋值运算符的左侧（也可以是在右侧），它是在内存中有位置的对象，具有可访问性和可识别的内存地址。 ②右值：通常出现在赋值运算符的右侧，它是一个临时对象或者子对象，右值也可以占用栈上的数据区的内存，但是这个内存是暂时分配的，而且赋值
关于std::move和std::forward
左雪菲的专栏
10-23 1308
这篇文章介绍的真不错：http://www.cnblogs.com/catch/p/3507883.html总结起来：1. std::move是将左值变成右值减少不必要的拷贝；2. std::forward保持一个值的左值和右值特性不变，以变传给既能接受左值又能接受右值的函数，例：template TYPE* acquire_obj(ARG&& arg) { return new TYPE(
C++的std::move与std::forward
sinat_31608641的博客
07-14 2676
一、背景介绍 什么是左值和右值？ 1、左值引用 C/C++语言中可以放在赋值符号左边的变量，即具有对应的可以由用户访问的存储单元，并且能够由用户去改变其值的量。或者说左值是代表一个内存地址值，并且通过这个内存地址，就可以对内存进行读并且写（主要是能写）操作。相对应的还有右值：当一个符号或者常量放在操作符右边的时候，计算机就读取他们的“右值”，也就是其代表的真实值。 简单来说就是，左值相当于地址值，右值相当于数据值。右值指的是引用了一个存储在某个内存地址里的数据。 左值右...
深入理解std::move和std::forward
zhangsj1007的博客
07-29 2802
    前面写了关于左值引用和右值引用，讲了Move Constructor和Move Assignment，这一节讲最后一部分std::move和std::forward，那么这一个小系列就算说完了。     std::move     我们现在知道怎么用Move Constructor和Move Assignment，但是我们现在还没有方法将一个Rvalue Reference 绑定到一个...
C++理解std::move和转发（std::forward)
2301_80224556的博客
04-04 1529
/在返回类型和类型转换中也要用到typename这段代码很短，但其中有些微妙之处。首先，move的函数参数T&&是一个指向模板类型参数的右值引用。通过引用折叠，此参数可以与任何类型的实参匹配。特别是，我们既可以传递给move一个左值，也可以传递给它一个右值，"),s2;"));// 正确：从一个右值移动数据// 正确：但在赋值之后，s1的值是不确定的//没有打印任何东西为了通过翻转函数传递一个引用，我们需要重写函数，使其参数能保持给定实参的“左造性”。
std：forward与move
最新发布
09-10
<think> 我们被要求解释C++中的std::move和std::forward。根据提供的引用，我们可以总结如下： 1. std::move： - 功能：无条件地将一个表达式转换为右值引用。它本身并不移动任何东西。 - 本质：是一个类型转换函数，将参数转换为右值引用，从而可以使用移动语义（如移动构造函数或移动赋值运算符）。 - 使用场景：主要用于避免不必要的拷贝，提高性能。例如，在将资源从一个对象转移到另一个对象时（如容器重新分配内存、交换对象等）。 - 注意：使用std::move后，源对象处于“有效但未指定状态”，通常不应再使用其值，除非重新赋值或重置。 2. std::forward： - 功能：有条件地将参数转换为右值引用。它通常用于完美转发（perfect forwarding），即在模板函数中将参数以原始类型（保持左值/右值属性）转发给其他函数。 - 条件：当参数被绑定到一个右值时，才转换为右值；如果是左值，则保持左值引用。 - 使用场景：主要用于模板编程中，编写转发函数（如工厂函数、包装函数）时保持参数的值类别（lvalue或rvalue）。 - 实现：通过引用折叠规则和模板类型推导来实现。 根据引用[1]和引用[3]： - 两者在运行期不产生任何代码，只是编译期的类型转换。 引用[2]中的例子展示了函数返回值的类型如何影响重载函数的选择，这有助于理解左右值引用的绑定规则。 引用[4]给出了std::forward的实现，展示了引用折叠的规则。 现在，我们根据以上信息，组织回答： # C++中的std::move与std::forward 在C++中，`std::move`和`std::forward`是两个重要的工具，它们用于支持移动语义和完美转发。两者都是编译期的类型转换，运行期不产生额外开销。 ## 1. std::move：强制转换为右值 ### 定义与作用 `std::move`定义在头文件`<utility>`中，其作用是无条件地将传入的表达式转换为右值引用。它的原型大致如下： ```cpp template <typename T> typename remove_reference<T>::type&& move(T&& t) noexcept; ``` 注意：`std::move`本身并不移动任何数据，它只是将对象标记为可移动（即转换为右值引用），以便在构造或赋值时调用移动构造函数或移动赋值运算符，从而避免深拷贝。 ### 使用示例 ```cpp #include <iostream> #include <string> #include <utility> int main() { std::string src = "Hello, World!"; std::string dest = std::move(src); // 调用移动构造函数 std::cout << "dest: " << dest << std::endl; // 输出: Hello, World! std::cout << "src: " << src << std::endl; // src被移动，内容未定义（通常为空） return 0; } ``` 在上例中，`std::move(src)`将`src`转换为右值，因此`dest`的构造使用了移动构造函数，避免了字符串的深拷贝。移动后，`src`处于有效但未定义的状态（通常为空字符串）。 ### 注意事项 - 被移动的对象不应再使用其值（除非重新赋值）。 - 对于内置类型（如int、float等），移动等同于拷贝，没有性能优势。 ## 2. std::forward：完美转发 ### 定义与作用 `std::forward`同样定义在`<utility>`中，用于实现完美转发。它根据原始参数的值类别（左值或右值）进行有条件的转换：若原始参数为右值，则转换为右值引用；否则，保持左值引用。这使得在模板函数中能够保持参数的值类别。 原型（参考引用[4]的实现）： ```cpp template <class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept { return static_cast<T&&>(t); } template <class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept { static_assert(!is_lvalue_reference_v<T>, "bad forward call"); return static_cast<T&&>(t); } ``` ### 使用场景 `std::forward`主要用于模板函数中转发参数。例如，在编写一个包装函数时，需要将参数原封不动地传递给另一个函数。 ```cpp #include <iostream> #include <utility> void inner(int& x) { std::cout << "lvalue\n"; } void inner(int&& x) { std::cout << "rvalue\n"; } template <typename T> void outer(T&& t) { inner(std::forward<T>(t)); // 完美转发 } int main() { int x = 10; outer(x); // 传递左值：输出 lvalue outer(10); // 传递右值：输出 rvalue return 0; } ``` 上述代码中，`outer`函数通过`std::forward`根据传入参数的值类别（左值x或右值10）选择正确的`inner`重载版本。 ### 注意事项 - `std::forward`通常用于通用引用（`T&&`）的场景。 - 完美转发避免了不必要的拷贝，同时保持了左值和右值的语义。 ## 对比总结 - `std::move`：无条件转右值，用于启动移动语义。 - `std::forward`：有条件转右值，用于完美转发，保持参数原始值类别。 两者都是编译期行为，运行期无开销[^1][^3][^4]。 §§相关问题§§ 1. 在什么情况下使用`std::move`会带来性能提升？ 2. 为什么`std::forward`需要显式指定模板参数类型？ 3. 在模板函数中，如何区分通用引用（universal reference）和右值引用？ 4. 移动语义中，被移动的对象在移动后应该处于什么状态？ </think> ### C++中std::move与std::forward详解 #### **1. std::move：强制转换右值** - **核心作用**：无条件将表达式转换为右值引用（`X&&`），启用移动语义。 - **本质**：编译期类型转换（无运行时开销），不实际移动数据，仅标记对象为“可移动”[^1][^3]。 - **使用场景**： ```cpp std::string src = "Hello"; std::string dest = std::move(src); // 移动构造：src资源转移给dest // src现在处于有效但未定义状态（通常为空）[^3] ``` - **实现原理**： ```cpp template <typename T> typename remove_reference<T>::type&& move(T&& t) noexcept { return static_cast<typename remove_reference<T>::type&&>(t); } // 去除引用后强制转右值[^1][^3] ``` #### **2. std::forward：完美转发** - **核心作用**：**有条件**保持参数的原始值类别（左值/右值），用于转发函数参数[^1][^4]。 - **本质**：依据模板参数`T`的类型决定转换行为（编译期决策）： - 若`T`为左值引用（如`int&`），返回左值引用。 - 若`T`为非引用或右值引用（如`int&&`），返回右值引用。 - **典型场景**（通用引用 + 转发）： ```cpp template <typename T> void wrapper(T&& arg) { target(std::forward<T>(arg)); // 保持arg的原始值类别 } ``` - **实现原理**（引用折叠规则）： ```cpp // 左值版本 template <class T> T&& forward(remove_reference_t<T>& arg) { return static_cast<T&&>(arg); // T&& + & => T& } // 右值版本 template <class T> T&& forward(remove_reference_t<T>&& arg) { static_assert(!is_lvalue_reference_v<T>, "Invalid forward"); return static_cast<T&&>(arg); // T&& + && => T&& }[^4] ``` #### **3. 关键区别** | **特性** | `std::move` | `std::forward` | |----------------|----------------------------|------------------------------| | **转换行为** | 无条件转右值 | 有条件保持原始值类别 | | **使用场景** | 启动移动语义 | 模板函数中的完美转发 | | **参数要求** | 接受任意类型 | 必须与通用引用（`T&&`）配合 | | **运行开销** | 零开销（仅编译期类型转换） | 零开销 | #### **4. 示例解析** 引用[2]中的代码演示值类别如何影响函数重载： ```cpp void func(int&); // 处理左值 void func(int&&); // 处理右值 func(func3()); // 返回左值引用 ⇒ 调用 func(int&) func(func4()); // 返回右值引用 ⇒ 调用 func(int&&) ``` - `std::forward`在类似场景中自动处理这种转发逻辑。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值